1 Resumen

En el presente curso se cubrirá los aspectos esenciales del trabajo con R desde su instalación así como el uso de paquetes de terceros. Se pretende cubrir los tópicos necesarios para empezar a utilizar R como herramienta de manipulación de datos y generador de gráficos estadísticos. Además este curso proporciona una visión sistemática de R como un lenguaje de programación, haciendo hincapié en las buenas prácticas de programación y el desarrollo de código conciso.

2 Fundamentos

2.1 Descripción del programa R

R es un lenguaje y entorno de programación, creado en 1993 por Ross Ihaka y Robert Gentleman, cuya característica principal es que forma un entorno de análisis estadístico con lenguaje de programación para realizar cálculos y crear gráficos.

En su aspecto R puede considerarse como otra implementación del lenguaje de programación S, con la particularidad de ser un software de uso libre.

En la página web del proyecto R se puede conseguir gratuitamente el programa en su última versión, o cualquiera de las anteriores, además de manuales, librerías (package) y demás elementos que conforman entorno de programación denominado R.

R proporciona una ruta de código abierto para la contribución al proyecto, creando modificaciones de datos, funciones y librerías (packages).

2.2 Características del programa R

Ningún otro programa en la actualidad reúne las condiciones de recursos y manejabilidad que posee R; además en los últimos años ha tenido una mayor implantación en la comunidad científica.

Entre otras características dispone de:

  • Almacenamiento y manipulación de datos.
  • Operadores para cálculo con variables indexadas o arreglos (arrays), y en particular con matrices.
  • Herramientas para análisis de datos.
  • Posibilidades gráficas para análisis de datos.

Junto con R se incluyen ocho bibliotecas o paquetes (llamadas bibliotecas estándar) pero otros muchos están disponibles a través de Internet en (http://www.r-project.org).

Actualmente se encuentran disponibles 9249 librerías (packages) desarrollados en R, que cubren multitud de aplicaciones en diversos campos.

Una vez instalado el programa, la forma más fácil de usarlo es de forma interactiva mediante la línea de comandos. Cuando R se inicia, aparece la ventana del programa “Gui” (Graphical User Iinterface) con un mensaje de apertura.

2.3 El editor de comandos (“prompt”)

Debajo del mensaje de apertura de la consola de R se encuentra el “prompt” que es el símbolo “>” (mayor que). Las expresiones en R se escriben directamente a continuación del “prompt” en la consola de R.

Si se escribe e intenta ejecutar un comando que se ha escrito en forma incompleta, el programa presenta un “+” que es el prompt de continuación.

Una característica de R es que nos permite guardar la sesión de trabajo, lo que será muy útil en el caso de que necesitemos utilizar bibliotecas o datos que ya hemos implementado.

Al cerrar el programa o al teclear “q( )” nos preguntará si desea salvar los datos de esta sesión de trabajo. Puede responder: yes (si), o no (no) o cancel (cancelar) pulsando respectivamente las letras y, n o c.

En cada caso respectivamente: salvará los datos antes de terminar, o terminará sin salvar, o volverá a la sesión de R. Los datos que se salvan estarán disponibles en la siguiente sesión de R.

Es importante saber que el nombre de un objeto debe comenzar con una letra (A hasta Z, o, a hasta z) y puede además incluir letras, dígitos (0-9) o puntos (.). R discrimina entre letras mayúsculas y minúsculas para el nombre de un objeto, de tal manera que x y X se refiere a objetos diferentes.

2.4 Función help (ayuda)

R es un lenguaje funcional, esto es, realiza las tareas a través de funciones. La primera función que necesitamos conocer es la que nos proporciona la ayuda del programa, esta es “help”.

Si escribimos help aparece la definición de la función help, la cual nos será útil conocer si queremos realizar alguna modificación en ella.

Pero si lo que queremos es obtener el resultado de la función, debemos escribir entre paréntesis el conjunto de argumentos que quiere suministrar a la misma, o vacío si lo que se quiere es que aparezca la ayuda sin más. Por ejemplo:

help(mean)

Una forma alternativa a esta función es poner el caracter “?” delante del elemento que queremos consultar; o también con la función: “help.search”. Por ejemplo:

help.search(“calibration”)

help.search("calibration")

2.5 Asignaciones

Al igual que ocurre con otros lenguajes de programación R asigna nombres a los diversos objetos (tales como variables o resultados de operaciones). Esto se consigue mediante el símbolo: “< –” ; “– >” ; o , “=” .

Hay que tener en cuenta que R utiliza determinados términos para referirse a algunas funciones por lo que lo mejor es evitar esos nombres a la hora de las asignaciones.

Por ejemplo “c” se utiliza para crear vectores o “t” para calcular la traspuesta de un arreglo de datos (vectores, matrices, dataframe, …), pero si nos confundimos no es dramático, ya que podemos arreglarlo.

Las siguientes instrucciones generan dos vectores (x y X, de orden 6 y 5 respectivamente) usando la función \(rnorm\) que genera números aleatorios (con distribución \(Normal(0,1)\)), y también se crea un vector y, cuyas componentes son los enteros desde uno hasta quince.

rnorm(6) -> x
print(x)
## [1]  0.9529400  2.0902740  1.1330220  0.3449874 -0.6123540  0.5215337
X <- rnorm(5)
X
## [1] -0.6904696 -0.1910501 -0.1738731  0.9805496  0.5392377
y <- 1:15;y
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

En el caso que necesitemos poner comentarios en R, estos se realizan poniendo delante del comentario el símbolo “#”.

Recuerde la importancia de estos para explicar lo que se está haciendo o simplemente para recordar que realiza el programa o la función que hemos implementado.

# Programa realizado en R para simular el fondo de inversiones
# Las siguientes instrucciones permiten crear un vector de 8 números aleatorios entre 0 y 1 con distribución uniforme.
runif(8,0,1)
## [1] 0.54818899 0.85791499 0.66986697 0.46725688 0.36772006 0.83174052
## [7] 0.67832529 0.02219789

2.6 Paquetes

Como ya se ha dicho, R consta de un sistema base de librerías y de un conjunto de paquetes adicionales que extienden su funcionalidad.

En esta sección vamos a ver como se anexan (instalan) los paquetes adicionales.

Tenemos que tener en cuenta que la instalación depende del sistema operativo del computador; hay varias formas de instalar un paquete:

El método más sencillo consiste en es hacerlo directamente desde R, mediante la función:

install:packages( )

Después de haber instalado la librería en el programa, para poder utilizarla debemos descargar el paquete. La forma más común de hacerlo es desde el menú Paquetes > cargar paquete …; entonces aparecerá una lista con todos las librerías instaladas y nos pedirá que instalemos una de ellas, simplemente seleccionando una la tendremos operativa.

install.packages("PASWR")

2.7 Módulo R-Commander (paquete Rcmdr)

R cuenta con entornos amigables para los usuarios, por ejemplo el módulo R-commander (paquete Rcmdr) que es una interfaz gráfica que se compone de una ventana que contiene varios menús, botones y campos de información.

Por defecto RCommander consiste en una barra de menús, una barra de herramientas, una ventana de instrucciones, una ventana de salida y una ventana de mensajes.

Las instrucciones para leer, escribir, transformar y analizar datos se ejecutan usando la barra de menú de la parte superior de la ventana de R Commander.

La mayor parte de los items de este menú le guiarán mediante ventanas de diálogo, preguntando más allá de la especificación.

Bajo la barra de menú se encuentra la barra de herramientas con un campo de información que muestra el nombre del conjunto de datos activos, botones para editar y mostrar el conjunto de datos activos y un campo de información mostrando el modelo estadístico activo.

Bajo la ventana de instrucciones hay un botón Ejecutar para realizar las órdenes indicadas en la ventana de instrucciones.

Los campos de información para los datos y el modelo activo, son botones que pueden ser usados para respectivamente seleccionar éstos entre conjuntos de datos o modelos disponibles en memoria.

Por defecto, las órdenes son registradas en la ventana de instrucciones (la ventana de texto ubicada inmediatamente después de la barra de herramientas); las órdenes y las salidas aparecen en la ventana de resultados (la ventana de texto ubicada después de la ventana de instrucciones).

Si el registro de instrucciones está activo, las órdenes de R editadas o introducidas desde los menús y los cuadros de diálogos, son alojadas en la ventana de instrucciones de R Comander.

Se pueden editar estas órdenes de manera normal y se pueden escribir otras nuevas en la ventana de instrucciones.

Las órdenes individuales pueden ser continuadas en más de una línea. El contenido de la ventana de instrucciones puede ser almacenado durante o al final de la sesión y un conjunto de instrucciones guardado puede ser cargado en la ventana de instrucciones.

El contenido de la ventana de resultados puede ser editado o guardado en un archivo de texto.

Para volver a efectuar una orden o un conjunto de ellas, se seleccionan las líneas que se desean ejecutar usando el ratón (mouse) y se presiona el botón Ejecutar, situado a la derecha de la barra de herramientas (o Control-R); este procedimiento sirve para realizar (correr) el bloque de las instrucciones elegidas.

Si no hay texto seleccionado el botón Ejecutar (o Control-R) envía el contenido de la línea que contiene el cursor de inserción.

En la última ventana (situada abajo) se generará información, se presentan los errores si una orden o algunas órdenes enviadas son incompletas. Para instalar R-Comander hay que cargar el paquete “Rcmdr”.

Al cargar el paquete R-Comander también se instalan muchos otros paquetes (dependencias) que son necesarios para que puedan funcionar todas las opciones de los menús del entorno gráfico.

Cada vez que se quiera abrir el R Commander hay que teclear library(Rcmdr) en la consola de comandos, o entrar en el menú Paquetes ->Cargar paquete… y seleccionar Rcmd en la ventana que aparece.

2.8 Editor de archivos Tinn-R

Tinn-R es un editor de archivos que mejora al bloc de notas de Windows ya que contiene mejoras para permitir el uso de sintaxis de R; también proporciona un menú y una barra de herramientas adicional que se comunica y llama al R-Gui, lo que permite ejecutar el código en el mismo programa.

Existen más entornos gráficos útiles, a semejanza de los anteriores, cada uno con sus ventajas e inconvenientes; algunos de ellos son: JGR o Java GUI for R, es una multiplataforma basada en Java; RExcel, que permite usar R y Rcmdr desde Microsoft Excel; Rggobi; Sage; Statistical Lab; NexusBPM; RWorkBench; etc. El que vamos usar durante el curso es RStudio debido a su potencia para integrar varias salidas(documentos y gráficos), simplificación de la busqueda de ayuda, instalación de paquetes, entre otros facilidades.

2.9 Función library

La función library gestiona los libros de la biblioteca, dando información sobre los existentes y cargándolos en memoria o descargándolos de la misma.

Un libro está formado por funciones, datos y documentación; todos ellos contenidos en un directorio que contiene varios subdirectorios, con informaciones diversas, de acuerdo con un formato establecido.

De hecho, al instalar R, se carga al menos un primer libro denominado “base”.

Por ejemplo “library()” devuelve la lista de los libros que hay en la biblioteca predeterminada de R, con una breve descripción a su lado derecho.

library()

La instrucción “library(help=”base“)” devuelve una pequeña ayuda sobre el libro base.

# Para cargar una libria, por ejemplo el paquete "prob", damos la instrucción: 
library(PASWR)
## Loading required package: e1071
## Loading required package: MASS
## Loading required package: lattice
# Usando la instrucción "search" se presentan todos los paquetes cargados
search()
##  [1] ".GlobalEnv"        "package:PASWR"     "package:lattice"  
##  [4] "package:MASS"      "package:e1071"     "package:stats"    
##  [7] "package:graphics"  "package:grDevices" "package:utils"    
## [10] "package:datasets"  "package:methods"   "Autoloads"        
## [13] "package:base"
# Se puede ver la información del paquete "PASWR", mediante la instrucción:
library(help = PASWR)

2.10 Operaciones con números reales y complejos

R es un lenguaje interpretado, es decir podemos escribir órdenes y R las ejecutará inmediatamente.

De hecho puede utilizar R como una calculadora, ya que es capaz de manejar todas las operaciones elementales: suma, resta, multiplicación, división y potenciación, que se realizan mediante los símbolos: + , - , * , ^ .

# R como calculadora
2+3
## [1] 5
7*3
## [1] 21

Es importante saber que R no evalúa una expresión hasta que tiene la certeza de que se ha terminado su escritura; por ejemplo, si la expresión comienza con un paréntesis, se debe cerrar la expresión con otro paréntesis, sino R considerará que no terminó la acción, igualmente corchetes, llaves etc. En general, para cualquier función, su escritura sin los paréntesis indican al lenguaje que debe devolver la definición, en tanto que al incluir paréntesis, le indica que intente ejecutarla.

15/3
## [1] 5
15/4
## [1] 3.75
3^4
## [1] 81

También podemos hacer los mismos cálculos con números complejos, en este caso utilizaremos como es usual la letra “i” para referirnos a la unidad imaginaria (1i*1i = – 1) que debe ir acompañado siempre del coeficiente (parte imaginaria del número).

(3+3i)+(-3+2i)
## [1] 0+5i
#(2+2i)*(3+i)
(2+2i)*(3+1i)
## [1] 4+8i
(2+2i)/(3+1i)
## [1] 0.8+0.4i

2.11 Funciones usuales

R proporciona las funciones usuales para hacer todo tipo de evaluaciones básicas, tales como: suma, raíz cuadrada, valor absoluto, senos, cosenos, logaritmo natural, exponencial, entre otras

  • sum( ): Suma de los elementos
  • sqrt( ): Raíz cuadrada.
  • abs( ): Valor absoluto.
  • sin( ), cos( ), …: Funciones trigonométricas.
  • log( ), exp( ): Logaritmo y exponencial.
  • round( ): Redondeo de valores numéricos.
# A continuación se presentan ejemplos del uso de algunas funciones usuales.
sqrt(81)
## [1] 9
abs(-7)
## [1] 7
sin(-2*pi)
## [1] 2.449213e-16
log(100)
## [1] 4.60517

2.12 Operadores Comparativos y Lógicos:

Los operadores comparativos y lógicos son muy importantes a la hora de programar funciones, ya que gracias a ellos se puede hacer distinciones de datos, agrupaciones, etc.. Se presenta a continuación una pequeña introducción de ellos:

Los operadores comparativos o de relación interaccionan sobre cualquier tipo de elemento devolviendo uno o varios valores lógicos. Siempre necesitan dos elementos ( a < b ) para poder comparar.

Los operadores lógicos pueden actuar sobre uno o dos objetos de tipo lógico, y pueden devolver uno (o varios) valores lógicos.

Operadores de Relación:

Símbolo Relación
\(<\) Menor que
\(>\) Mayor que
\(\le\) Menor o igual que
\(\ge\) Mayor o igual que
\(=\) Igual
\(!=\) Diferente

Operadores Lógicos:

Símbolo Lógicos
\(!x\) Negación
\(x & y\) Conjunción (˄)
\(x && y\) Igual
\(x|y\) Disyunción (ν)
\(x||y\) Igual

Para comparar “totalmente” dos objetos se requiere usar la función “identical”.

# A continuación se asigna a x el valor 10
x<-10
# Ahora se pregunta si x es menor que 5
x<5
## [1] FALSE
# La siguiente instrucción pregunta si x es mayor o igual que 5
x>=5
## [1] TRUE
# Se pregunta si el valor de x es igual a 5
x==5
## [1] FALSE
# A continuación se pregunta si x es distinto de 5
x!=5
## [1] TRUE
# Ahora se crean dos vectores
u<-1:3
v<-3:1
# La siguiente instrucción pregunta si los dos vectores son iguales
identical(u,v)
## [1] FALSE
# Veamos los elementos que coinciden
u==v
## [1] FALSE  TRUE FALSE

3 UTILIZACIÓN DE DATOS

3.1 Generación de vectores

El primer tipo de objeto que manejaremos es el vector (arreglo de elementos del mismo tipo).

Utilizando la opción “:” (que su ubica entre dos números a:b) se genera un vector que comienza en el primer número suministrado (que está a la izquierda) y finaliza en el segundo número dado, o en un número anterior sin sobrepasarlo (al que está en la derecha), y de manera que entre una componente y la siguiente haya una diferencia de uno; por tanto las componentes crecen si a es menor que b, y decrecen si a es mayor que b.

# Ejemplos de generación de vectores
1:10    
##  [1]  1  2  3  4  5  6  7  8  9 10
10:1
##  [1] 10  9  8  7  6  5  4  3  2  1
1.5:7.5
## [1] 1.5 2.5 3.5 4.5 5.5 6.5 7.5

En general un vector se crea mediante la función de concatenación “c( )”. Por ejemplo:

c(1,2,4,3)
## [1] 1 2 4 3
c(1:5)
## [1] 1 2 3 4 5
c(1:5,-2,4,-3)
## [1]  1  2  3  4  5 -2  4 -3

Hay también otras formas de generar vectores; una de las más comunes es usando la función “seq(a,b,c)”, que genera secuencias de números reales, donde la primera componente indicará el principio de la secuencia, la segunda el final y la tercera el incremento que se debe usar para generar la secuencia. Aunque también se puede poner la función en estas formas: “seq(length = d; from = a; to = b)” “seq(by = c; from = a; to = b)” siendo “d” la longitud del vector.

seq(1,10,2)
## [1] 1 3 5 7 9
seq(from = 1, to = 20, by =2)
##  [1]  1  3  5  7  9 11 13 15 17 19
seq(1,10,2)
## [1] 1 3 5 7 9
# Vector secuencia de 1 a 10 con increment de 2 
seq(from = 1, to = 10, by =2)
## [1] 1 3 5 7 9
# Si lo que queremos es 6 componentes
seq(from = 1, to = 10, length =6)
## [1]  1.0  2.8  4.6  6.4  8.2 10.0
# Con el argumento along creamos un vector con los índices del vector argumento que llamemos (o consideremos en la función)
x<-c(1,2,1,3,4)
seq(along=x)
## [1] 1 2 3 4 5

La función “rep(a; b)” que crea un vector con “b” componentes idénticos al valor “a”.

# A continuación, se crea el vector  de diez (10) componentes iguales a tres (3) . 
rep(3,10)
##  [1] 3 3 3 3 3 3 3 3 3 3
# repetimos el vector "a" 2 veces; por ejemplo, si a=(1,2,3,4,5).
a=1:5
rep(a,2)
##  [1] 1 2 3 4 5 1 2 3 4 5

3.2 Tipos de vectores

Un vector siempre está formado por elementos del mismo tipo, no pueden mezclarse números y cadenas de caracteres (se transformará en cadenas de caracteres).

c("Hola", "Adios")
## [1] "Hola"  "Adios"

Del mismo modo, si las componentes tienen números reales y complejos, se entenderán todos como complejos.

c(1, 1+2i)
## [1] 1+0i 1+2i
c(1-1i, 2)
## [1] 1-1i 2+0i
# Se presenta un ejemplo de vector con cadenas de caracteres
dias.semana=c("Lunes","Martes","Miércoles","Jueves","Viernes" ,"Sábado","Domingo")
dias.semana
## [1] "Lunes"     "Martes"    "Miércoles" "Jueves"    "Viernes"   "Sábado"   
## [7] "Domingo"

En R podemos asignar nombres a los elementos de un vector mediante la función “names” (que también se puede utilizar para nombrar cualquier objeto).

x<-1:7
x
## [1] 1 2 3 4 5 6 7
names(x)<-c("Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Do mingo")
x
##     Lunes    Martes Miercoles    Jueves   Viernes    Sabado  Do mingo 
##         1         2         3         4         5         6         7

También podemos conocer o cambiar el modo o tipo de los elementos que forman el vector mediante la función “mode” (tomaría los valores: logical, numeric, complex, character, null, list, function, graphics, expression, name, frame, raw y unknown).

y<-seq(from=3, to=11, by=2)
y
## [1]  3  5  7  9 11
mode(y)
## [1] "numeric"
# Cambiamos el vector y, a componentes en los complejos
mode(y)<-"complex"
y
## [1]  3+0i  5+0i  7+0i  9+0i 11+0i

3.3 Operaciones con vectores

Como sucede con los números reales, R nos permite operar con vectores (dentro de las propiedades de estos).

Podemos multiplicar vectores por escalares, vectores por vectores, potencias, sumas, etc.

Teniendo el cuenta el uso del paréntesis y el número de componentes del vector, ya que nos llevaría a diferentes resultados e incluso a errores si no son múltiplos los tamaños entre si.

(1:5)*(2:6)
## [1]  2  6 12 20 30
(1:5)^2
## [1]  1  4  9 16 25
1:5^2
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
## [24] 24 25

Si olvidamos el asterisco *, que es el símbolo del producto, entre los vectores R envía el mensaje del error cometido

#(1:5)(2:6)
(1:5)+(2:6)
## [1]  3  5  7  9 11
#(1:5)+(2:4)
# Para elevar a una potencia, basta poner:
(1:5)^3
## [1]   1   8  27  64 125

La longitud de un vector puede obtenerse con la función “length” que sirve además para definir la longitud del vector, haciéndolo más largo o más corto; en caso de hacerlo más largo, se completará con NA (valores faltantes).

j<-4
j
## [1] 4
length(j)
## [1] 1

3.4 Funciones de vectores

# Asigno a j una longitud igual a 5
length(j)<-5
length(j)
## [1] 5
j
## [1]  4 NA NA NA NA
jj<-c("Pepe","Paco")
# Asigno a jj una longitud igual a 5
length(jj)<-5
jj
## [1] "Pepe" "Paco" NA     NA     NA

Podemos referirnos a la componente que ocupa la posición “i” de un vector “x”, mediante “x[i]” o referirnos a ciertas componentes dadas por medio del respectivo vector de subíndices.

aa<-(1:6)^3
aa
## [1]   1   8  27  64 125 216
aa[5]
## [1] 125
aa[c(1,3,5)]
## [1]   1  27 125

Si los subíndices son valores lógicos, se corresponden con los mismos elementos del vector, pero sólo hacen referencia a los que tienen un subíndice con valor lógico TRUE.

# Asignamos sexo a tres componentes:
sexo<-c("Mujer","Mujer","Hombre")
# Asignamos nombre a tres elementos ordenados
nombre<-c("Pepa","Pepita","Pepe")
# Preguntamos las componentes de nombre que corresponden a Mujer
#sexo==Mujer
#Error: objeto 'Mujer' no encontrado
# Un caracter tiene que ir siempre entre ""
sexo=="Mujer"
## [1]  TRUE  TRUE FALSE
# Si se desean solo las componentes que son iguales a Mujer
nombre[sexo=="Mujer"]
## [1] "Pepa"   "Pepita"

A continuación tenemos un conjunto de funciones muy útiles a la hora de trabajar con vectores:

FUNCIONES DESCRIPCIÓN
mean(x) Media aritmética de los valores del vector x
median(x) Mediana de los valores del vector x
sum(x) Suma de los valores del vector x
max(x) Maximo valor de los valores del vector x
min(x) Mínimo valor de los valores del vector x
range(x) Rango de los valores del vector x
var(x) Cuasivarianza de los valores del vector x
cov(x) Covarianza de los valores del vector x
cor(x,y) Coeficiente correlacion entre los vectores x y y
sort(x) Una version ordenada de x
order(x) Indica la posicion que tendrian los valores ordenados de x
quantile(x) Mínimo, primer cuartil, mediana, tercer cuartil y maximo de x
cumsum(x) Vector formado por la frecuencia acumulada del vector x
cumprod(x) Vector formado por el producto acumulado del vector x
cummax(x) Vector de x tal que cada valor menor se sustituye por el anterior
cummin(x) Vector de x tal que cada valor mayor se sustituye por el anterior
pmax(x,y,z) Vector con longitud la más larga de x, y o z, con los valores máximos de cada posición
pmin(x,y,z) Vector con longitud la más larga de x, y o z, con los valores mínimos de cada posición

Un ejemplo en el que podemos ver el comportamiento de cada una de las funciones:

x<-c(1,2,3,4,5)
y<-c(1,3,3,1,5)
z<-c(1,3,3)
mean(x)
## [1] 3
median(x)
## [1] 3
sum(x)
## [1] 15
max(x)
## [1] 5
min(x)
## [1] 1
range(x)
## [1] 1 5
# La cuasivarianza, o varianza muestral
var(x)
## [1] 2.5
# Veamos que es así
n=length(x)
sum((x-mean(x))^2)/(n-1)
## [1] 2.5
# La varianza sería
((n-1)/n)*var(x)
## [1] 2
sum((x-mean(x))^2)/(n)
## [1] 2
cov(x,y)
## [1] 1.5
sum((x-mean(x))*(y-mean(y)))/(n-1)
## [1] 1.5
cor(x,y)
## [1] 0.5669467
sort(x)
## [1] 1 2 3 4 5
sort(y)
## [1] 1 1 3 3 5
cumprod(y)
## [1]  1  3  9  9 45
cummax(x)
## [1] 1 2 3 4 5
cummin(x)
## [1] 1 1 1 1 1
pmax(x,y,z)
## Warning in pmax(x, y, z): an argument will be fractionally recycled
## [1] 1 3 3 4 5
pmin(x,y,z)
## Warning in pmin(x, y, z): an argument will be fractionally recycled
## [1] 1 2 3 1 3

3.5 Generación de matrices

Las matrices o variables indexadas (Arrays) son generalizaciones multidimensionales de vectores.

De hecho, son vectores indexados por dos o más indices y que se imprimen de modo especial. Para crearlas utilizamos la función “matrix”.

Los parámetros principales de esta función son: data (vector que contiene los valores que formarán la matriz), nrow (número de filas), ncol (número de columnas).

m1<-matrix(1,2,3)
# Hemos generado una matriz de unos de dos filas y tres columnas
m2<-matrix(1:8,4)
m2
##      [,1] [,2]
## [1,]    1    5
## [2,]    2    6
## [3,]    3    7
## [4,]    4    8
# Hemos formado una matriz con el vector 1:8 de cuatro filas
# Hay que tener en cuenta el tamaño de la matriz
#m2<-matrix(1:4,3)
m3<-matrix(1:8,ncol=4)
# Hemos formado una matriz con el vector 1:8 de cuatro columnas

Si se quiere dar nombres a las columnas (o a las filas) puede hacerlo asignando valores al parámetro “dimnames”, lista con los nombres de las filas y las columnas. Las componentes de la lista deben tener longitud 0 o ser un vector de cadenas de caracteres con la misma longitud que la dimensión de la matriz.

# Renombramos las columnas
matrix(1:9,3,3,dim=list(c(),c("A1","A2","A3")))
##      A1 A2 A3
## [1,]  1  4  7
## [2,]  2  5  8
## [3,]  3  6  9
# Renombramos las filas
matrix(1:9,3,3,dim=list(c("a1","a2","a3"),c()))
##    [,1] [,2] [,3]
## a1    1    4    7
## a2    2    5    8
## a3    3    6    9
# Renombramos filas y columnas
matrix(1:9,3,3,dim=list(c("a1","a2","a3"),c("A1","A2","A3")))
##    A1 A2 A3
## a1  1  4  7
## a2  2  5  8
## a3  3  6  9

3.6 Operaciones con matrices

Una operación muy común es hacer referencia a una submatriz o a un elemento de la matriz, se realiza indicando los índices de los elementos a los que se hace referencia.

Podemos hacer referencia a una fila (vector) mediante matriz[i; ], con i el índice de la fila que queremos mostrar, o a una columna mediante matriz[ ; j] con j el índice de la columna que queremos mostrar.

Si se quiere mostrar una componente concreta indicamos los dos índices correspondientes: matriz[i; j].

Por ejemplo: matriz[2; 1], da el valor de la segunda fila y primera columna.

Un argumento útil en estas operaciones es la variable lógica “byrow” que indica si la matriz debe construirse por filas o por columnas (el valor predeterminado es F).

Se puede realizar operaciones con matrices de la misma forma que con los vectores, es decir componente a componente: suma, resta, multiplicación por escalares, multiplicación elemento a elemento,

División elemento a elemento, exponenciación, que se realizan mediante los símbolos: + , - , * , =; ^.

M1<-matrix(1:6,2,3)
M2<-matrix((1:6)^2,2,3)
M2
##      [,1] [,2] [,3]
## [1,]    1    9   25
## [2,]    4   16   36
# La suma de las dos matrices
M1+M2
##      [,1] [,2] [,3]
## [1,]    2   12   30
## [2,]    6   20   42
# Se ha sumado componente a componente
M1*M2
##      [,1] [,2] [,3]
## [1,]    1   27  125
## [2,]    8   64  216
# Se ha multiplicado componente a componente
M2/M1
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
# Se ha dividido componente a componente
M2%%M1
##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0

Es posible realizar el producto matricial mediante el operador “% * %”.

A1<-matrix(1:6,2,3)
B1<-matrix(1:12,3,4)
A1%*%B1
##      [,1] [,2] [,3] [,4]
## [1,]   22   49   76  103
## [2,]   28   64  100  136
#B1%*%A1
# Hay que tener en cuenta las dimensiones de las matrices

La función “crossprod” devuelve el producto matricial cruzado de dos matrices (la traspuesta de la primera matriz, multiplicada por la segunda). Si no se especifica la segunda matriz, R la toma igual a la primera, con lo que obtiene XtX .

A1<-matrix(1:6,2,3)
A2<-matrix(c(1,1,2,3),2)
crossprod(A1,A2)
##      [,1] [,2]
## [1,]    3    8
## [2,]    7   18
## [3,]   11   28
crossprod(A1)
##      [,1] [,2] [,3]
## [1,]    5   11   17
## [2,]   11   25   39
## [3,]   17   39   61

La función “rbind” se usa para unir dos matrices por filas ( y “cbind” por columnas)

m1<-matrix(1,nr=2,nc=2)
m1
##      [,1] [,2]
## [1,]    1    1
## [2,]    1    1
m2<-matrix(2,nr=2,nc=2)
m2
##      [,1] [,2]
## [1,]    2    2
## [2,]    2    2
# A continuación se unen las dos matrices por filas con la siguiente orden:
rbind(m1,m2)
##      [,1] [,2]
## [1,]    1    1
## [2,]    1    1
## [3,]    2    2
## [4,]    2    2
# Se unen las dos matrices por columnas usando la siguiente instrucción:
cbind(m1,m2)
##      [,1] [,2] [,3] [,4]
## [1,]    1    1    2    2
## [2,]    1    1    2    2

3.7 Funciones de matrices

La función “t( )” calcula la matriz traspuesta.

A1
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
t(A1)
##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
## [3,]    5    6

La función “diag( )” se puede usar para extraer o modificar la diagonal de una matriz o para construir una matriz diagonal.

diag(m1)
## [1] 1 1
diag(m2)
## [1] 2 2
# A continuación se modifica la diagonal de la matriz m1
diag(m1)=15
m1
##      [,1] [,2]
## [1,]   15    1
## [2,]    1   15

Ahora se crea una matriz diagonal, de orden 3, con las componentes del vector:

v<-c(10,15,20)
diag(v)
##      [,1] [,2] [,3]
## [1,]   10    0    0
## [2,]    0   15    0
## [3,]    0    0   20
diag(3.6,nr=2,nc=5)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]  3.6  0.0    0    0    0
## [2,]  0.0  3.6    0    0    0

También se puede evaluar funciones de operaciones matriciales, por ejemplo:

diag(rbind(m1,m2)%*%cbind(m1,m2))
## [1] 226 226   8   8

La función “solve” invierte una matriz (si se le da un argumento) y resuelve sistemas lineales de ecuaciones (cuando se le dan dos).

El primer argumento es una matriz que debe ser cuadrada no singular, y el segundo argumento (opcional) es un vector o matriz de coeficientes.

También podemos utilizarla para resolver sistemas de ecuaciones (por ejemplo x + 2y = 1, x + 3y = 2), pasando el sistema a forma matricial.

A2
##      [,1] [,2]
## [1,]    1    2
## [2,]    1    3
b1=c(1,2)
b1
## [1] 1 2
solve(A2)
##      [,1] [,2]
## [1,]    3   -2
## [2,]   -1    1
solve(A2,b1)
## [1] -1  1

La función “eigen” calcula los autovalores y autovectores de una matriz cuadrada, el resultado es una lista de dos componentes llamados values y vectors.

A2
##      [,1] [,2]
## [1,]    1    2
## [2,]    1    3
eigen(A2)
## $values
## [1] 3.7320508 0.2679492
## 
## $vectors
##            [,1]       [,2]
## [1,] -0.5906905 -0.9390708
## [2,] -0.8068982  0.3437238

Con la función “det” calculamos el determinante de una matriz cuadrada.

det(A2)
## [1] 1
#Además existen funciones como svd( ) que calcula la descomposición en #valores singulares.
svd(A2)
## $d
## [1] 3.8643285 0.2587772
## 
## $u
##            [,1]       [,2]
## [1,] -0.5760484 -0.8174156
## [2,] -0.8174156  0.5760484
## 
## $v
##            [,1]       [,2]
## [1,] -0.3605967 -0.9327218
## [2,] -0.9327218  0.3605967

3.8 arrays (variables multiindexadas).

La generalización de los vectores y matrices son las variables multiindexadas, denominadas arrays, y de las cuales son casos particulares los vectores y matrices.

Una variable indexada (array) es una colección de datos, por ejemplo numéricos, indexados por varios índices.

R permite crear y manipular variables indexadas, por ejemplo para crear una variable multiindexada se utiliza la función “array(data, dim, dimnames)” donde “dim” es un vector de dimensiones.

Además podemos hacer referencia a cualquier subconjunto de la misma, de modo similar a las matrices.

# array se comporta de la misma manera que matrix
i<-array(c(1:5,3:1),dim=c(3,2))
i
##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    3

Un arreglo (array) puede tener más dimensiones; por ejemplo, ser de orden 2x3x3

z<-array(1:5,c(2,3,3))
z
## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    1
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]    2    4    1
## [2,]    3    5    2
## 
## , , 3
## 
##      [,1] [,2] [,3]
## [1,]    3    5    2
## [2,]    4    1    3
z[1,,]
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    3    4    5
## [3,]    5    1    2
z[1,1,1]
## [1] 1

3.9 Listas.

Una lista se construye con la función “list” que devuelve un objeto de tipo lista con tantos componentes como argumentos se le suministren y es utilizado para devolver el resultado de una función. >dias.semana=c(“Lunes”,“Martes”,“Miercoles”,“Jueves”,“Viernes”,“Sabado”,“Domingo”)

dias.semana
## [1] "Lunes"     "Martes"    "Miércoles" "Jueves"    "Viernes"   "Sábado"   
## [7] "Domingo"
list(A=dias.semana,B=1:7)
## $A
## [1] "Lunes"     "Martes"    "Miércoles" "Jueves"    "Viernes"   "Sábado"   
## [7] "Domingo"  
## 
## $B
## [1] 1 2 3 4 5 6 7

Puede referirse a cada uno de los elementos de la lista de dos formas distintas: Si tiene nombre, como en este caso, mediante el nombre de la lista, el símbolo $ y el nombre del elemento.

En todo caso, siempre se puede referir a él mediante el índice de posición entre dobles corchetes.

list(A=dias.semana,B=1:7)$A
## [1] "Lunes"     "Martes"    "Miércoles" "Jueves"    "Viernes"   "Sábado"   
## [7] "Domingo"
list(A=dias.semana,B=1:7)$B
## [1] 1 2 3 4 5 6 7
list(A=dias.semana,B=1:7)[[2]]
## [1] 1 2 3 4 5 6 7
list(A=dias.semana,B=1:7)[[1]]
## [1] "Lunes"     "Martes"    "Miércoles" "Jueves"    "Viernes"   "Sábado"   
## [7] "Domingo"

3.10 Hoja de datos (data.frame).

Una hoja de datos (Data frame) es una lista que pertenece a la clase “data.frame”.

Hay restricciones en las listas que pueden pertenecer a esta clase, en particular: las componentes deben ser vectores (numéricos, cadenas de caracteres, o lógicos), factores, matrices numéricas, listas u otras hojas de datos.

Las matrices, listas, y hojas de datos contribuyen a la nueva hoja de datos con tantas variables como columnas, elementos o variables posean, respectivamente.

Peso <- c(90,120,56)
Altura <- c(1.90,1.87,170)
Sexo <- c("Hombre","Hombre","Mujer")
Nombres <- c("Pepe", "Paco", "Pepita")
datos3<-data.frame(Peso = Peso, Altura = Altura, Sexo = Sexo, Nombres = Nombres)
datos3
##   Peso Altura   Sexo Nombres
## 1   90   1.90 Hombre    Pepe
## 2  120   1.87 Hombre    Paco
## 3   56 170.00  Mujer  Pepita

Si desea seleccionar un subconjunto de una hoja de datos, puede hacerlo con la función subset. Función que puede utilizar también en vectores.

subset(datos3,select=c(Sexo,Nombres))
##     Sexo Nombres
## 1 Hombre    Pepe
## 2 Hombre    Paco
## 3  Mujer  Pepita
subset(datos3,select=c(Sexo=="Mujer"))
## data frame with 0 columns and 3 rows

Para realizar modificaciones en un data frame es muy útil la función transform.

transform(datos3,logPeso=log(Peso))
##   Peso Altura   Sexo Nombres  logPeso
## 1   90   1.90 Hombre    Pepe 4.499810
## 2  120   1.87 Hombre    Paco 4.787492
## 3   56 170.00  Mujer  Pepita 4.025352
transform(datos3,IMC=Peso/(Altura)^2)
##   Peso Altura   Sexo Nombres          IMC
## 1   90   1.90 Hombre    Pepe 24.930747922
## 2  120   1.87 Hombre    Paco 34.316108553
## 3   56 170.00  Mujer  Pepita  0.001937716

Hay funciones que permiten comprobar si un objeto es de un tipo determinado, todas comienzan por is., o facultan cambiar el objeto a un tipo concreto, funciones que comienzan por as. A continuación se ilustra el uso de tales funciones

x<-1:10
is.vector(x)
## [1] TRUE
is.data.frame(x)
## [1] FALSE
x<-as.data.frame(x)
as.data.frame(x)
##     x
## 1   1
## 2   2
## 3   3
## 4   4
## 5   5
## 6   6
## 7   7
## 8   8
## 9   9
## 10 10

La función de R “data.frame” concatena todas las variables en un solo conjunto de datos, o también se las podría guardar en un archivo de datos utilizando la función “write.table”.

El formato del archivo guardado es .CSV (comma separated variables, variables separadas por comas), el cual es un formato de texto muy fácil de leer con cualquier editor de texto o con Excel. El archivopuede ser leído en R con la función “read.csv”.

La notación $ para componentes de listas, como por ejemplo “cont$dom”, puede no ser la más apropiada. En ocasiones, será cómodo que los componentes de una lista, o de una hoja de datos, pudiesen ser tratados temporalmente como variables cuyo nombre fuese el del componente, sin tener que especificar explícitamente el nombre de la lista.

La función “attach( )” puede tener como argumento el nombre de una lista, o de una hoja de datos, y permite conectar la lista o la hoja de datos directamente.

Supongamos que abc es una hoja de datos con tres variables, abc$u, abc$v y abc$w.

La orden “attach(abc)” conecta la hoja de datos colocándola en la segunda posición de la trayectoria de búsqueda y, si no existen variables denominadas u, v o w en la primera posición; u, v y w aparecerán como variables por sí mismas.

Para desconectar una hoja de datos, utilice la función “detach()”. Esta función desconecta la entidad que se encuentre en la segunda posición de la trayectoria de búsqueda.

Una vez realizada esta operación dejarán de existir las variables u, v y w como tales, aunque seguirán existiendo como componentes de la hoja de datos.

Las entidades que ocupan en la trayectoria de búsqueda posiciones superiores a la segunda, pueden desconectarse dando su posición o su nombre como argumento a la función “detach”.

Preferimos esta segunda opción, como por ejemplo detach(abc) o detach(“abc”).

Hay que tener en cuenta que la trayectoria de búsqueda puede almacenar un número finito y pequeño de elementos, por tanto no debemos conectar una misma hoja de datos más de una vez.

Del mismo modo, es conveniente desconectar una hoja de datos cuando termine de utilizar sus variables.

3.11 Lectura y escritura de datos.

Una opción tan interesante como necesaria es la de lectura y escritura de ficheros de datos.

R permite importar datos desde cualquier tipo de fichero de datos básico, tal como bases de datos, archivos excel, de SPSS, de Minitab, de STATA, de documentos de texto, archivos .dat, etc.

La orden de lectura de datos es “read.table”, con ella y con sus argumentos podemos leer los ficheros e indicar el modo en el que ellos están construidos.

La forma correcta y más simple de utilizar la instrucción será:

read.table(del archivo/datos1.txt“, header=TRUE, sep=, na.strings=”, dec=.“)

Con ella estamos diciendo que lea los datos 1.txt." que se encuentra en tal ruta (separada por /), que dichos datos tienen cabecera, es decir que existe una primera fila con los nombres de las variables (si no tienen los datos cabecera, el argumento será header=FALSE).

Con na.strings=“NA”le decimos que los valores faltantes los tome como nulos.

El separador decimal de los datos que tenemos es el punto en vez de la coma.

Hay otros argumentos que se pueden añadir a la función, tales como indicar el tipo de valores de los datos (lógicos, enteros, etc.) el número de columnas, etc.

# Leemos el archivo s.txt y lo llamo Datos
#Datos <- read.table("C:/Users/jmcontreras/Desktop/MALETA/s.txt",header=FALSE, sep="", na.strings="NA", dec=".")
#Con la función "View" se visualizan los datos que hemos cargado en la memoria anteriormente.
#View(Datos)

La función write tiene como argumentos los siguientes write(x, file = “data”, ncolumns = , append =FALSE, sep = " “), donde x el nombre de la variable que queremos exportar, file es el nombre y tipo de fichero que crearemos, ncolumns el número de columnas y sep es el separador (en nuestro caso espacios en blanco). El argumento”append" es el más útil a la hora de simulaciones ya que con el podemos conservar los datos del fichero que tuviésemos anteriormente si append=TRUE, solo que los nuevos se añadirán a los anteriores en filas posteriores. Si append = FALSE remplazaremos los datos anteriores por los nuevos.

4 FUNCIONES

4.1 Definición de una función

Como se ha mencionado anteriormente, las funciones permiten realizar las diferentes acciones.

Existen funciones definidas (pueden ser modificadas), pero lo más importante es que R permite crear objetos del modo function, es decir nos permite construir nuevas funciones de R que realicen tareas que no estaban definidas en el momento de instalar el programa, que además pueden utilizar a su vez en expresiones posteriores ganando considerablemente en potencia, comodidad y elegancia.

Estas nuevas funciones se incorporan al lenguaje y se utilizan posteriormente como las previamente existentes.

Nota: Para obtener ayuda sobre qué es lo que hace una función utilizaremos la función help. Si necesita ejecutar un programa del sistema operativo puede utilizar la función system, que permite incluso salir al sistema operativo con la orden system(“cmd”).

Para obtener información del sistema utilizamos shell, por ejemplo en shell(“dir”).

Las funciones tradicionales en cualquier lenguaje de uso matemático y estadístico, están definidas.

Entre ellas se encuentran, entre otras: abs, sqrt, sin, cos, tan, asin, acos, atan, exp, log, log10, min, max, sum, prod, length, mean, range, median, var, cov, summary, sort, rev, order.

#Algunos ejemplos de evaluación de funciones usuales
sin(1:5)
## [1]  0.8414710  0.9092974  0.1411200 -0.7568025 -0.9589243
sin(pi)
## [1] 1.224606e-16
sin(pi/2)
## [1] 1
sum(1:5)
## [1] 15
prod(1:5)
## [1] 120

Una función se define asignando a un objeto la palabra " seguida de los argumentos que desee dar a la función, escritos entre paréntesis y separados por comas, seguida de la orden, entre llaves si son varias órdenes, que desee asignar a la misma. Entre los argumentos destaca que si utiliza tres puntos seguidos, …, ello indica que el número de argumentos es arbitrario.

nombre<- function(arg1,arg2,….)expression

La expresión es una fórmula, o grupo de fórmulas, que utilizan los argumentos para calcular su valor.

El valor de dicha expresión es el valor que proporciona R en su salida, y éste puede ser un número, un vector, una grafica, una lista o un mensaje.

El uso (o evaluación) de la función es normalmente de la forma: NombreDeFuncion(expr 1,expr 2,…) .

La instrucción “return” termina la función y devuelve su(s) resultado(s); cuando se encuentra esta función se detiene la ejecución y se devuelven los valores indicados.

Es posible acceder a los argumentos de una función mediante la función “formals”.

formals(primera.función)

4.2 Ejemplos sobre creación de funciones

Como pretendemos que este sea una introducción al uso de R sobre todo para su uso estadístico, empezaremos creando la función más común en este área: la media.

La función media es una función de un solo argumento (si no se especifica lo tomaremos por NA (valor nulo) y el resultado sería NA).

En caso de que se le suministre un argumento, no se comprueba si es válido o no, sino que suponiendo que es un vector, se eliminan del mismo los elementos correspondientes a NA; para ello se utiliza la negación “!” y la condición de ser un valor no disponible.

# A continuación se crea la función media
media<-function(x=NA)
{
x<-x[!is.na(x)]
sum(x)/length(x)
}
media(c(2,4,1,3,6,7))
## [1] 3.833333
media(c(2,4,1,3,6,NA))
## [1] 3.2

Como ejemplo se ha creado la función media, usando de R las funciones sum y length; aún cuando R ya tiene implementada, como vimos anteriormente, la función “mean” que calcula la media de los valores que le indiquemos.

mean(c(2,4,1,3,6,7))
## [1] 3.833333

Así mismo podríamos crear o simplemente usar la función “var” que corresponde a la varianza, etc.

5 ESTRUCTURAS DEL LENGUAJE R

5.1 Estructuras condicionales

La primera estructura es: if (condición) acción1 [else acción2] La segunda estructura es: ifelse(condición, acción en caso cierto, acción en caso falso). La tercera estructura es: switch(expresión,[valor-1=]acción-1,….,[valor-n=]acción-n).

En la construcción condicional “if” de la forma:

if (expr1) expr2 else expr3

La primera expresión expr1 es una condición que debe producir un valor lógico (T o F); si éste es verdadero (T), se ejecutará la acción manifestada en expr2; y si es falso (F), y se ha escrito la opción else, que es opcional, se ejecutará la acción declarada por expr3.

Estas acciones pueden ser múltiples instrucciones (particularmente asignaciones) que deben agruparse entre llaves {instr.1; instr.2; …; inst.m}. Por tanto se pueden pensar las llaves: “{” como begin (inicio); y, “}” como end (fin) del bloque de instrucciones.

5.2 Estructuras de repetición

Hay tres tipos de estructuras de repetición, representadas por las construcciones: “for“,”while“, y,”repeat“, cuya sintaxis se describe a continuación: for (variable in valores) acción La estructura”for” asigna a variable cada uno de los valores y realiza la acción para cada valor. while (condición) acción La estructura “while” evalúa la condición y mientras esta es cierta se realiza la acción.

La tercera estructura de repetición es: repeat acción La estructura “repeat” realiza la acción indefinidamente.

En estas estructuras también las acciones pueden ser múltiples instrucciones (particularmente asignaciones) que deben agruparse entre llaves {instr.1; instr.2; …; inst.m}.

Por tanto se pueden pensar las llaves: “{” como begin (inicio) y “}” como end (fin) del bloque de instrucciones.

En los tres casos, el valor del ciclo completo es el de la última ejecución de la acción.

Las expresiones pueden contener algún condicional como “if” asociado con las funciones “next” o “break”.

La estructura “next” indica que debe terminarse la iteración actual y pasar a la siguiente. La estructura “break” indica que debe terminarse el ciclo actual.

5.3 Uso de estructuras para crear funciones

#Factorial de un número
factorial<-function(n)
 {
 f<-1
 if(n>1)
 for(i in 1:n)
 f<-f*i
 return(f)
 }
factorial(3)
## [1] 6
factorial(25)
## [1] 1.551121e+25
factorial(0)
## [1] 1
factorial(4)
## [1] 24

Para generar los términos de una progresión aritmética, se puede construir tres funciones: la primera corresponde a la forma explícita, la segunda a la forma recursiva y la tercera a la forma recursiva vectorial.

arit.1<-function(n=1,a1=1,d=1) a1+d*(n-1)
arit.2<-function(n=1,a1=1,d=1)
 {
 if(n>1){return(arit.2(n-1,a1,d)+d)}
 else (return(a1))
 }
arit.3<-function(n=1,a1=1,d=1)
 {
 A=1:n 
 A[1]=a1
 for(i in 2:n)A[i]=A[i-1]+d
 return(A[n])
 }
arit.1(10)
## [1] 10
arit.2(10)
## [1] 10
arit.3(10)
## [1] 10

Para generar los términos de una progresión geométrica, se puede construir la función:

P.geometrica<-function(n=1,a1=1,r=1)
{
a1+r^(n-1)
}
P.geometrica()
## [1] 2
P.geometrica(2,3,2)
## [1] 5
# Otra forma sería:
P.geometrica2<-function(n=1,a1=1,r=1)
 {
 if(n>1){P.geometrica(n-1,a1,r)*r}
 else{a1}
 }
P.geometrica2(2,3,2)
## [1] 8
# Una última forma sería
P.geometrica3<-function(n=1,a1=1,r=1)
 {
 if(n==1) return(a1)
 A=1:n 
 A[1]=a1
 for(i in 2:n) A[i]=A[i-1]*r 
 return(A[n])
 }
P.geometrica3(2,3,2)
## [1] 6

6 DISPOSITIVOS GRÁFICOS

6.1 Funciones gráficas básicas

Algunos de los gráficos más usuales pueden generarse a partir de funciones básicas tales como:

FUNCIONES DESCRIPCIÓN
abline( ) Funcion que añade una o más líneas rectas
plot( ) Función genérica para representar, en el plano xy, puntos, líneas, etc.
barplot( ) Diagramas de barras
pie( ) Diagramas de sectores
hist( ) Histogramas
boxplot( ) Diagramas de box-and-whisker
stripplot( ) Similares a boxplot( ) con puntos
sunflowerplot( ) Representación en el plano xy de diagramas de girasol
qqnor( ) Diagramas de cuantil a cuantil frente a la distribución normal
qqplot( ) Diagramas de cuantil a cuantil de dos muestras
qqline( ) Representa la lnea que pasa por el primer y el tercer cuartil
lines( ) Añade líneas a un gráfico
points( ) Añade puntos a un gráfico
segments( ) Añade segmentos a un gráfico
arrows( ) Añade fechas a un gráfico
polygons( ) Añade polígonos a un gráfico
rect( ) Añade rectángulos a un gráfico
abline( ) Añade una recta de pendiente e intersección dada
curve( ) Representa una función dada

Además existen funciones específicas en las que funciona de modo especial, como por ejemplo para data.frame, lm, etc.

A continuación se usan las funciones descritas anteriormente, en ejemplos ilustrativos: plot es una función genérica que crea un gráfico en el dispositivo gráfico actual.

x<-seq(-10,10)
x
##  [1] -10  -9  -8  -7  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5   6
## [18]   7   8   9  10
plot(x,x,xlim=c(0,10),ylim=c(0,10))

Se puede también dar la siguiente instrucción, un poco más elaborada o dificultosa:

plot(1:100,(1:100)^2,type="l")

# A continuación se genera un gráfico de dos variables comprendidas entre –4 y 4, así:
plot(-4:4, -4:4, type = "n")
# Ahora se representan veinte números aleatorios, con una distribución normal en rojo, con la instrucción:
points(rnorm(20), rnorm(20), col = "red")

Ahora se presentan diez números aleatorios, con una distribución normal, en azul y más grandes, con la orden

y <- x <- rnorm(10)
plot(x,y)
points(x, y, col = "blue", cex = 3)
#La función abline se puede usar para crear un conjunto de líneas que separen en filas la gráfica.
for(i in 1:10) abline(h=i,col=i)

#Se usa también para crear un conjunto de líneas que separen la gráfica en columnas.
for(i in 1:10) abline(v=i,col=i)

A continuación se crea una gráfica de dos variables x e y; con x entre –2 y 3 y con y entre –1 y 5.

plot(c(-2,3), c(-1,5), type = "n", xlab="x", ylab="y", asp = 1)
# Se genera ahora un eje xy de color rojo
abline(h=0, v=0, col = "red")
# Se asigna una leyenda (recta y = 0), de color azul en el par (1,0)
text(1,0, "recta( y = 0 )", col = "blue", adj = c(0, -.1))
# Se crea una recta de pendiente 2 y término independiente 1
abline(a=1, b=2, col = 2)
# Se añade una leyenda para nombrar la recta y=2x+1
text(1,3, "recta y=2x+1", col= "green", adj=c(-.1,-.1))

Con la función “curve” se crean funciones no lineales, tanto polinomiales como trigonométricas.

curve(sin, -2*pi, 2*pi)

curve(tan)

# Si borramos la gráfica anterior sale diferente
# Polinomiales
curve(x^3-3*x, -2, 2)
# Le adjuntamos una parábola
curve(x^2-2*x+1, add = TRUE, col = "red")

Un argumento interesante es add, con el podemos adjuntar varias gráficas a la vez.

curve(sin(x),-pi,pi, col="blue")
curve(cos(x),-pi,pi,add=TRUE, col="red")

#La función text es muy útil, ya que nos permite añadir texto a un gráfico existente; por ejemplo, al gráfico de la función seno.
curve(sin(x),-pi,pi,col="red")
text(-2,0.5,"seno de x", col="blue")

6.2 Funciones para gráficos estadísticos

Los diagramas de barras los creamos con la función “barplot”

Empezamos con un ejemplo fácil, supongamos que hemos recogido unos datos que hemos codificado con escalas del 1 al 4.

Se requiere hacer un diagrama de barras con los resultados del análisis de la variable x.

x<-c(1,2,3,1,2,1,2,4,1,3,2,4,1,2,3,1,2,4,2,1)
# Se determina la frecuencia acumulada de cada una de las variables
table(x)
## x
## 1 2 3 4 
## 7 7 3 3
frec.x<-table(x)
# Se crea el diagrama de barras con las leyendas
barplot(frec.x, main="Frecuencia relativa", xlab="Valores de la variable")

Entonces se ponen nombres a las variables y se cambia las barras de vertical a horizontal.

barplot(frec.x, main="Frecuencia relativa", xlab="valores de la variable",
 horiz=TRUE,names.arg=c("Menores de 18", "De 18 a 45", "De 45 a 65",
 "Más de 65"))

Los diagramas de sectores circulares para datos cualitativos se crean con la función pie. Por ejemplo, un diagrama básico será:

# Diagrama simple de sectores
muestra <- c(15, 12,4, 16, 8)
paises<- c("USA", "Inglaterra", "Australia", "Alemania", "Francia")
pie(muestra, labels = paises, main="Diagrama de sectores de países")

Los histogramas para variables continuas se construyen con la función “hist”

#  Histograma de la variable x, con 1000 datos normales
x<-rnorm(1000)
hist(x)

Como vemos crea un histograma con los datos y como estos datos son normales el histograma se asemeja a la curva normal. R asigna el número de intervalos y la amplitud de ellos; si se quiere modificarlos se usan los argumentos “break” que indican los puntos de corte junto con otros argumentos para darles efectos visuales.

# Se crean 13 intervalos (12 puntos de corte), de color azul y lineas rosas
hist(x, freq = FALSE, breaks = 12, col="lightblue", border="pink")