INTRODUCCIÓN A LA

PROGRAMACIÓN ESTADÍSTICA
CON EL SOFTWARE R

CURSO 2023-2024

Alba M. Franco Pereira

Departamento de Estadı́stica e Investigación Operativa

Universidad Complutense de Madrid
2
Índice general

1. PRIMERAS NOCIONES 5
1.1. Conceptos iniciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2. Función help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3. Asignaciones y Cáculos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1. Asignaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2. Operaciones con números reales . . . . . . . . . . . . . . . . . . . . . 9
1.3.3. Operadores comparativos y lógicos . . . . . . . . . . . . . . . . . . . 11
1.3.4. Valores ausentes (“missing values”) . . . . . . . . . . . . . . . . . . . 13
1.4. Scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5. Paquetes y Librerı́as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2. MANIPULACIÓN DE DATOS 17
2.1. Operaciones con Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2. Operaciones con Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3. Operaciones con Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.4. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5. Hoja de datos (data.frame) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.6. Lectura y escritura de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.7. Bases de datos conocidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3. FUNCIONES 45
3.1. Definición de una función . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2. Ejemplos de funciones elementales en Estadı́stica . . . . . . . . . . . . . . . 47
3.2.1. Función media . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2.2. Función varianza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3. Estructuras condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.4. Estructuras de repetición definida e indefinida . . . . . . . . . . . . . . . . . 50
3.5. Más ejemplos de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.5.1. Factorial de un número . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.5.2. Suma de una progresión aritmética . . . . . . . . . . . . . . . . . . . 51
3.5.3. Suma de una progresión geométrica . . . . . . . . . . . . . . . . . . . 52

3
4 ÍNDICE GENERAL

4. OPCIONES GRÁFICAS 53
4.1. Funciones gráficas básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2. Función plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.2.1. Funciones points, abline y lines . . . . . . . . . . . . . . . . . . . 54
4.2.2. Funciones polygon, rect, arrows y segments . . . . . . . . . . . . . 56
4.3. Función curve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.4. Gráficos estadı́sticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.4.1. Función barplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.4.2. Función pie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.4.3. Función hist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.4. Función boxplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.5. Función pairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Capı́tulo 1

PRIMERAS NOCIONES

1.1. Conceptos iniciales

R es un lenguaje y entorno de programación creado en 1993 por Ross Ihaka y Robert
Gentleman del Departamento de Estadı́stica de la Universidad de Auckland, cuya carac-
terı́stica principal es que forma un entorno de análisis estadı́stico para la manipulación de
datos, su cálculo y la creación de gráficos. R puede considerarse como otra implementación
del lenguaje de programación S, con la particularidad de que es un software GNU, General
Public License (conjunto de programas desarrollados por la Free Software Foundation), es
decir, de uso libre.

La página principal del proyecto “R-project” es http://www.r-project.org. Desde ella

podemos descargarnos de forma gratuita la última versión del programa, pero también cual-
quiera de las anteriores (en el caso de utilizar paquetes no implementados en las últimas
versiones), además de manuales, librerı́as o paquetes, y demás elementos que forman la gran
familia que es R.

Ningún otro programa en la actualidad reúne las condiciones de madurez, cantidad de

recursos y manejabilidad que posee R, además de ser el que en los últimos años ha tenido
una mayor implantación por parte de la comunidad cientı́fica. Es un entorno completamente
programable, siendo posible automatizar los procedimientos repetitivos mediante scripts del
propio usuario. También es fácil crear nuevas funciones y paquetes.

Entre otras caracterı́sticas, es capaz de llevar a cabo tareas de almacenamiento y mani-

pulación de datos y dispone de herramientas para el análisis de datos (incluyendo numerosas
posibilidades gráficas). Este manual constituye una pequeña guı́a que explica cómo instalar
el programa, cómo utilizar diferentes paquetes y librerı́as y cómo llevar a cabo la lectura y
análisis estadı́stico de datos (tanto analı́tica como gráficamente).

5
6 CAPÍTULO 1. PRIMERAS NOCIONES

Procedemos, por tanto, a instalar el programa. Necesitamos conexión a internet. Vamos

a seguir los pasos que mostramos a continuación:
1. Abrimos la página web http://www.r-project.org.
2. En la parte izquierda pinchamos en “Download CRAN”.
3. Buscamos los enlaces disponibles desde Spain y pinchamos en cualquiera de ellos.
4. Pinchamos en “Download R for Windows” y a continuación en “install R for the first
time” y en “Download R 3.3.1 for Windows”.
5. El último paso es ejecutar el archivo .exe.

Una vez instalado el programa, la forma más fácil de usarlo es de forma interactiva me-
diante la lı́nea de comandos. Cuando R se inicia, aparece la ventana del programa “Gui”
(graphical user interface) con un mensaje de apertura.

Debajo del mensaje de apertura de la consola de R (RConsole) se encuentra el “prompt”

que es el sı́mbolo > (mayor que). Las expresiones en R se escriben directamente a continua-
cion 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.
Se puede ver en que directorio se trabaja (Workspace) tecleando getwd(). Para cambiar
el directorio de trabajo, se utiliza la funcion setwd("path"). Es necesario proporcionar la
dirección (“path”) completa del archivo si éste no se encuentra en el directorio de trabajo. De-
bemos tener en cuenta que en el “path” hay que cambiar la barra inclinada \ por esta barra /.

Una diferencia fundamental de la filosofı́a de R, y también de S, con el resto del software

estadı́stico es el uso del “objetos” como entidad básica. La programación orientada a objetos
(POO, u OOP según sus siglas en inglés) es un paradigma de programación que viene a
innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la
obtención de datos de salida especı́ficos, donde cada objeto ofrece una funcionalidad especial.
Los objetos prediseñados permiten la agrupación o la creación, por parte del usuario, de pa-
quetes o librerı́as. Como ya veremos más adelante, tecleando objects() (o ls()) se obtiene
la lista de los objetos que se tienen almacenados.

Tipos de objetos: vectores (numéricos, de caracteres, de ı́ndices), matrices o más general-

mente arrays, factores, listas (vectores cuyos elementos no tienen porqué ser del mismo tipo),
data frames (generalización de las matrices, ya que puede haber columnas de diferente tipo),
funciones, etc. De un objeto se puede conocer, por ejemplo, su tipo con mode(), su longitud
con length() y su estructura con str().
1.2. FUNCIÓN HELP 7

Ejemplo: Los datos “Nile” son una serie temporal del flujo del rı́o Nilo.
> Nile
T imeSeries :
Start = 1871
End = 1970
F requency = 1
[1] 1120 1160 963 1210 1160 1160 813 1230 1370 1140 995 935 1110 994 1020
[16] 960 1180 799 958 1140 1100 1210 1150 1250 1260 1220 1030 1100 774 840
[31] 874 694 940 833 701 916 692 1020 1050 969 831 726 456 824 702
[46] 1120 1100 832 764 821 768 845 864 862 698 845 744 796 1040 759
[61] 781 865 845 944 984 897 822 1010 771 676 649 846 812 742 801
[76] 1040 860 874 848 890 744 749 838 1050 918 986 797 923 975 815
[91] 1020 906 901 1170 912 746 919 718 714 740
> mode(Nile)
[1] "numeric"
> length(Nile)
[1] 100
> str(Nile)
Time-Series [1:100] from 1871 to 1970: 1120 1160 963 1210 1160 1160 813
1230 1370 1140 ...
Es importante saber que el nombre de un objeto debe comenzar con una letra (A-Z ó a-z)
y además puede 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 referirán a objetos
diferentes.

Una caracterı́stica de R es que nos permite guardar la sesión de trabajo, lo que nos será
muy útil en el caso de que necesitemos utilizar librerı́as o datos que ya hemos implementado.
Al cerrar el programa o al teclear q() nos preguntará si deseamos salvar los datos de esta
sesión. Podemos responder Yes (Sı́), No (No) o Cancel (Cancelar). Los datos salvados estarán
disponibles en la siguiente sesión de R.

1.2. Función help

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, ésta es
help. Si escribimos help aparece la definición de la función help. Si lo que queremos es
obtener el resultado de la función, debemos escribir entre paréntesis el nombre del elemento
a consultar. De manera alternativa en lugar de help podemos poner el sı́mbolo ? .
> help(mean)
8 CAPÍTULO 1. PRIMERAS NOCIONES

Cuando queremos consultar funciones especificadas por caracteres especiales, el argu-

mento deberá ir entre comillas para transformarlo en una cadena de caracteres. Por ejemplo:
help("[["). Otra forma de buscar ayuda es usando la función help.search como muestra el
ejemplo siguiente. Al ejecutar, se abrirá una nueva ventana con distintas funciones o archivos
de datos cuyo nombre, palabra clave, etc. esté relacionado con la palabra introducida.
> help.search("mean")
Una opción interesante de la ayuda es que podemos encontrar ejemplos de uso. La for-
ma de ejecutar los ejemplos es escribiendo example o demo. Por ejemplo, con la sentencia
example(InsectSprays) obtenemos una muestra de diferentes gráficas que podemos realizar
con los datos InsectSprays.

Otra opción muy útil es la ayuda a través de internet. Si tecleamos help.start() aparece
una ayuda en formato HTML con la información más actual.

1.3. Asignaciones y Cáculos

1.3.1. Asignaciones
Al igual que ocurre con otros lenguajes de programación, R asigna nombres a los resul-
tados de ciertas operaciones. Esto lo hacemos mediante el sı́mbolo < −, − > ó =.

Como para poder visualizar un dato renombrado hay de escribir el nombre después de ha-
berlo asignado, puede resultar útil recurrir al sı́mbolo ; después de la asignacion para ahorrar
lı́neas de código. 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 y t calcula la traspuesta de un conjunto de datos
(vectores, matrices, dataframes, etc.).

Habitualmente, a la hora de nombrar objetos, no existen reglas definidas aunque se suele

seguir una pauta. Por ejemplo, los dataframes suelen nombrarse con la inicial en mayúscula
y las variables en minúscula.

> rnorm(6)->x
> x
[1] -0.05092882 0.39198294 -0.76096311 0.25944247 1.70030099 0.40690559
> X<-rnorm(5)
> X
[1] -1.0556861 0.4802372 0.4809718 -0.2799668 0.2983207
> y=1:15; y
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1.3. ASIGNACIONES Y CÁCULOS 9

> c
function (..., recursive = FALSE) .Primitive("c")

En el caso que necesitemos poner comentarios en R, estos se realizan poniendo delante

del comentario el sı́mbolo #.

> #Hola
> #Recuerda que los comentarios son siempre de gran utilidad ;)

1.3.2. Operaciones con números reales

Los comandos de R pueden ser asignaciones, como ya hemos comentado, y expresiones. A
continuación vamos a ver como R se puede utilizar como una calculadora. Es capaz de reali-
zar todas las operaciones elementales: suma, resta, multiplicación, división, exponenciación,
división entera y módulo, que se realizan mediante los sı́mbolos: +, −, ∗, /,ˆ, %/ % y % %;
respectivamente.

Es importante saber que R no evalúa una expresión hasta que tiene la certeza de que se
ha terminado su escritura. Ası́, si la expresion comienza con un paréntesis, deberemos cerrar
la expresión con otro paréntesis.

> #R como calculadora

> 2+3
[1] 5
> 7*3
[1] 21
> 15/3
[1] 5
> 15/4
[1] 3.75
> 3^4
[1] 81
> #Cociente de la división
> 15%/%2
[1] 7
> #Resto de la división
> 15%%2
[1] 1

R proporciona funciones para hacer todo tipo de operaciones básicas como sumas, senos,
cosenos, etc. En la siguiente tabla se muestran algunos comandos frecuentes.
10 CAPÍTULO 1. PRIMERAS NOCIONES

Comando Significado
sum(...) Suma de elementos.
sqrt(...) Raı́z cuadrada.
abs(...) Valor absoluto.
sin(...), cos(...),... Funciones trigonométricas.
log(...), exp(...) Logaritmo y exponencial.
round(...), signif(...) Redondeo de valores numéricos.

A continuación vemos cómo manejar estos comandos a través de algunos ejemplos:

> sum(1,4,6)
[1] 11
> seq(1,9,by=2)
[1] 1 3 5 7 9
> rep(1:3,3)
[1] 1 2 3 1 2 3 1 2 3
> sum(seq(1,9,by=2))
[1] 25
> cumsum(seq(1,9,by=2))
[1] 1 4 9 16 25
> sqrt(81)
[1] 9
> abs(-9)
[1] 9
> sin(-2*pi)
[1] 2.449294e-16
> log(100)
[1] 4.60517
> exp(3)
[1] 20.08554
> round(2.345632)
[1] 2
> round(2.3456432,3)
[1] 2.346
> ceiling(2.3456432)
[1] 3
> floor(2.3456432)
[1] 2
> signif(2.345432,3)
[1] 2.35
1.3. ASIGNACIONES Y CÁCULOS 11

1.3.3. Operadores comparativos y lógicos

Los operadores comparativos y lógicos son muy importantes a la hora de programar. Los
operadores comparativos o de relación interaccionan sobre dos elementos (que pueden ser
de cualquier tipo) devolviendo uno o varios valores lógicos. Los operadores lógicos pueden
actuar sobre uno o dos objetos de tipo lógico, y pueden devolver uno o más valores lógicos.

Los vectores lógicos pueden utilizarse en expresiones aritméticas, en cuyo caso se transfor-
man primero en vectores numéricos, de tal modo que FALSE se transforma en 0 y TRUE en 1.

En lógica la conjunción &, es un enunciado con dos o más elementos que deben verifi-
carse de forma simultánea. Por ejemplo, “una lámpara eléctrica se enciende si hay corriente
eléctrica, el interruptor está conectado y el fusible está correcto. En cualquier otro caso la
lámpara no se encenderá.” Por otra parte, la disyuncion | es un enunciado con dos o más
elementos optativos. Por ejemplo, “puedes ejecutar el código durante la clase o en casa” es
una disyunción con dos elementos, mientras que “puedes ejecutar el código durante la clase,
en casa o no hacerlo” es una disyunción con tres elementos.

De relación Lógicos
< menor que !x negación
> mayor que x&y conjunción
<= menor o igual que x&&y conjunción (∗)
>= mayor o igual que x|y disyunción
== igual que x||y disyunción (∗)
!= distinto a xor(x, y) ó exclusivo (∗∗)

(∗) Cuando ponemos dos sı́mbolos evaluamos la expresión de izquierda a derecha exami-
nando sólo el primer elemento de cada vector. Puede resultar conveniente en programación,
especialmente en sentencias “if”.

(∗∗) Da como valor verdadero si uno y sólo un argumento es válido.

Vamos a reforzar estos conceptos con el siguiente código:

> #Asignamos a x el valor 10

> x=10; x
[1] 10
> #Le preguntamos si x es menor que 5
> x<5
[1] FALSE
> #Le preguntamos si x es mayor o igual que 5
> x>=5
12 CAPÍTULO 1. PRIMERAS NOCIONES

[1] TRUE
> #Le preguntamos si x vale 5
> x==5
[1] FALSE
> #Le preguntamos si x es distinto de 5
> x!=5
[1] TRUE
> #Creamos dos vectores
> y=1:3; z=3:1
> #Le preguntamos si son iguales
> identical(y,z)
[1] FALSE
> #Vemos los elementos que coinciden
> y==z
[1] FALSE TRUE FALSE
> #Renombramos x e y
> x=1:5
> y=c(2,4,3,6,5)
> x==y
[1] FALSE FALSE TRUE FALSE TRUE
> x!=y
[1] TRUE TRUE FALSE TRUE FALSE
> x[x==y]
[1] 3 5
> x[x!=y]
[1] 1 2 4
> A=c(TRUE,FALSE);A
[1] TRUE FALSE
> !A
[1] FALSE TRUE
> B=c(TRUE,TRUE);B
[1] TRUE TRUE
> xor(A,B)
[1] FALSE TRUE
> #A y B
> A & B
[1] TRUE FALSE
> A && B
[1] TRUE
> #A o B
> A | B
1.3. ASIGNACIONES Y CÁCULOS 13

[1] TRUE TRUE

> A || B
[1] TRUE
> #Podemos comparar los elementos x e y creados anteriormente con:
> x<y
[1] TRUE TRUE FALSE TRUE FALSE
> x<=y
[1] TRUE TRUE TRUE TRUE TRUE
> x>=y
[1] FALSE FALSE TRUE FALSE TRUE
> x>y
[1] FALSE FALSE FALSE FALSE FALSE
> x[x>y]
integer(0)
> #No lo forma ningún elemento
> x[x<y]
[1] 1 2 4
> #Son los elementos de x que cumplen la condición
> y[x>y]
numeric(0)
> x[x<=y]
[1] 1 2 3 4 5

1.3.4. Valores ausentes (“missing values”)

Hay situaciones en las que un valor está no disponible porque es un resultado imposible
o se ha perdido, son los valores ausentes en Estadı́stica y en estos casos aparece como va-
lor NA. Cualquier operación con ellos seguirá siendo NA, no disponible. No obstante, con
la función is.na se puede construir un nuevo vector donde aparece TRUE si y sólo si el
elemento correspondiente es NA. Si el resultado imposible surge de un cálculo, el sı́mbolo
que aparece es NaN (not a number), siendo otra categorı́a de valores ausentes que se cambia
también con is.na. Si únicamente se quieren cambiar los valores NaN se debe teclear is.nan.

En el siguiente ejemplo vemos las posibles posibilidades de “missing values”:

> m=c(2,4,6,1,NA,3)
> m
[1] 2 4 6 1 NA 3
> m-1
[1] 1 3 5 0 NA 2
> is.na(m)
14 CAPÍTULO 1. PRIMERAS NOCIONES

[1] FALSE FALSE FALSE FALSE TRUE FALSE

> is.nan(m)
[1] FALSE FALSE FALSE FALSE FALSE FALSE
> m/(m-1)
[1] 2.000000 1.333333 1.200000 Inf NA 1.500000
> (m-1)/m
[1] 0.5000000 0.7500000 0.8333333 0.0000000 NA 0.6666667
> (m-1)/(m-1)
[1] 1 1 1 NaN NA 1
> is.na((m-1)/(m-1))
[1] FALSE FALSE FALSE TRUE TRUE FALSE
> is.nan((m-1)/(m-1))
[1] FALSE FALSE FALSE TRUE FALSE FALSE

1.4. Scripts
Los scripts son ficheros que contienen listas de comandos según se escriben en la consola,
pudiendo incluir comentarios (recordamos: lı́neas comenzando por #) que explican lo que se
pretende hacer. Son muy útiles para repetir en sucesivas ocasiones, ciertos procedimientos
que hemos tecleado en un determinado momento y para almacenar los comandos utilizados
en las diferentes sesiones.

Ejemplo: Para crear y hacer funcionar un script que genere dos muestras de tamaño 50
de una distribución N (2, 3) y calcule su coeficiente de correlación.
Arrancar R
En la persiana “File” seleccionar “New Script”, si se quiere utilizar un script almacenado
seleccionar “Open Script”.
Escribir en el script las siguientes lı́neas:

> x=rnorm(50,2,3)
> y=rnorm(50,2,3)
> plot(x,y)
> cor(x,y)

Seleccionar todas las lı́neas y presionar el botón derecho del ratón y aparecerá una
ventana de diálogo en la que se selecciona “Run line or selection”, ası́ se ejecutarán
todas las sentencias del script. Si no se selecciona nada, se ejecuta la sentencia al final
de la cual está colocado el cursor. También se puede seleccionar un bloque de sentencias
a ejecutar.
1.5. PAQUETES Y LIBRERÍAS 15

Para guardar y cerrar el script debemos activar la ventana del mismo y seleccionar “File
→ Save”. Se guardará con extensión .R. A continuación: “Close Script” para cerrarlo.

1.5. Paquetes y Librerı́as

Como ya hemos comentado, R consta de un sistema de librerı́as y de un conjunto de
paquetes adicionales que extienden su funcionalidad. En esta sección vamos a ver cómo se
instalan los paquetes adicionales.

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

install.packages. Después de haber instalado el paquete, debemos de cargarlo. Esto lo va-
mos a hacer de la siguiente manera “Packages → Load Package”. Ahı́ aparecerá una lista con
todas las librerı́as a las que tenemos acceso. Simplemente seleccionando una, la tendremos
operativa.

Con la función search() podemos ver los paquetes que hay actualmente en memoria y
con la funcion library() una lista con las librerı́as disponibles. Si dentro de los paréntesis
ponemos el nombre de una de ellas, se cargará para su uso.

search()
[1] ".GlobalEnv" "tools:RGUI" "package:stats" "package:graphics"
[5] "package:grDevices" "package:utils" "package:datasets" "package:methods"
[9] "Autoloads" "package:base"
> library()
> library(MASS)

En resumen, se podrı́a considerar que los paquetes R proporcionan una forma de manejar
conjuntos de funciones o datos y su documentación.
16 CAPÍTULO 1. PRIMERAS NOCIONES
Capı́tulo 2

MANIPULACIÓN DE DATOS

2.1. Operaciones con Vectores

El primer tipo de objeto que manejaremos será el vector. Podemos escribir vectores de
varias maneras. A continuación vemos algunas. La más utilizada es a través de la función
concatenación c.

> 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
> 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

Otra de las más comunes es utilizando la función seq(a,b,c) que genera una secuencia
de números reales comenzando en a, terminando en b y con incremento c. Otras variantes de
esta función son seq(length=d,from=a,to=b) o seq(by=c,from=a,to=b). Veamos algunos
ejemplos:
> 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
> #Si lo que queremos son 6 elementos

17
18 CAPÍTULO 2. MANIPULACIÓN DE DATOS

> seq(from=1,to=10,length=6)
[1] 1.0 2.8 4.6 6.4 8.2 10.0

La función rep(a,b) crea un vector con b elementos idénticos al valor a.

> #Repetimos el elemento 3 diez veces

> rep(3,10)
[1] 3 3 3 3 3 3 3 3 3 3
> #Repetimos el vector "a" 2 veces
> a=1:5; rep(a,2)
[1] 1 2 3 4 5 1 2 3 4 5
> y=rep(2,5)
> y
[1] 2 2 2 2 2
> #Repetimos cada elemento de a tantas veces como indica y
> rep(a,y)
[1] 1 1 2 2 3 3 4 4 5 5
> rep(a,a)
[1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
> #Repetimos cada elemento del vector 3 veces de 5 en 5
> rep(1:3,rep(5,3))
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
> rep(1:3,5)
[1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
> x=2
> #Repetimos el elemento x 5 veces
> rep(x,length=5)
[1] 2 2 2 2 2

La función sequence crea una secuencias de enteros. Cada secuencia terminará en el

número especificado como argumento.

> sequence(3)
[1] 1 2 3
> sequence(c(3,2))
[1] 1 2 3 1 2
> #Hemos creado una secuencia del vector 1:3 y del 1:2
> c(1:3,1:2)
[1] 1 2 3 1 2
> sequence(c(5,3))
[1] 1 2 3 4 5 1 2 3
> #Hemos creado una secuencia del vector 1:5 y del 1:3
2.1. OPERACIONES CON VECTORES 19

R, además de con números reales, nos permite operar con vectores. Podemos multiplicar
vectores por escalares, vectores por vectores, realizar sumas de vectores, etc. Veremos algunos
ejemplos.

> (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 25
> (1:5)(2:6)
Error: tentativa de aplicar una no-función
> (1:5)+(2:6)
[1] 3 5 7 9 11
> (1:5)+(2:4)
[1] 3 5 7 6 8
Mensajes de aviso perdidos
In (1:5) + (2:4) :
longitud de objeto mayor no es múltiplo de la longitud de uno menor
> (1:5)^3
[1] 1 8 27 64 125
> (1:5)^(1:3)
[1] 1 4 27 4 25
Mensajes de aviso perdidos
In (1:5)^(1:3) :
longitud de objeto mayor no es múltiplo de la longitud de uno menor
> (1:5)^(1:5)
[1] 1 4 27 256 3125

La longitud de un vector puede obtenerse con la función length. Esta función sirve además
para definir la longitud del vector, haciéndolo ası́ más largo o más corto. En el caso de querer
hacerlo más largo, se completar con NAs (valores faltantes).

> jj=c("Pepe","Paco")
> jj
[1] "Pepe" "Paco"
> length(jj)
[1] 2
> #Asigno a jj una longitud igual a 5
> length(jj)=5
> jj
[1] "Pepe" "Paco" NA NA NA
20 CAPÍTULO 2. MANIPULACIÓN DE DATOS

Podemos referirnos a un elemento que ocupa la posicion i de un vector x mediante x[i]

o referirnos a un subconjunto del vector mediante un conjunto de ı́ndices. Si los ı́ndices son
números naturales, éstos harán referencia a las posiciones dentro del vector. Si los ı́ndices son
valores lógicos, se corresponden con los elementos del vector con un ı́ndice con valor lógico
TRUE. Veamos algunos ejemplos.

> 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
> #Asignamos un género a tres elementos ordenados
> sexo=c("Mujer","Mujer","Hombre")
> sexo
[1] "Mujer" "Mujer" "Hombre"
> #Asignamos un nombre a tres elementos ordenados
> nombre=c("Pepa","Pepita","Pepe")
> nombre
[1] "Pepa" "Pepita" "Pepe"
> #Preguntamos cual de los elementos son mujeres
> sexo==Mujer
Error: objeto ‘Mujer’ no encontrado
> #Si es un caracter tiene que ir entre ""
> sexo=="Mujer"
[1] TRUE TRUE FALSE
> #Quiero sólo los nombres de las mujeres
> nombre[sexo=="Mujer"]
[1] "Pepa" "Pepita"

Un factor es un vector de cadenas de caracteres que sirve para representar datos categóri-
cos o diferentes niveles posibles de una variable. El atributo levels indica los posibles valores
en el vector. Se utiliza, por ejemplo, para clasificar una poblacion en grupos.

La función factor se utiliza para codificar un vector como un factor, creando tantos
niveles como le indiquemos.

> #Tres niveles

> factor(1:3)
[1] 1 2 3
Levels: 1 2 3
2.1. OPERACIONES CON VECTORES 21

> #Cinco niveles

> factor(1:3, levels=1:5)
[1] 1 2 3
Levels: 1 2 3 4 5
> #Tres niveles con etiquetas
> factor(1:3, labels=c("A","B","C"))
[1] A B C
Levels: A B C
> #Un vector de dos elementos con cuatro niveles
> aa=factor(c(2,3),levels=2:5)
> aa
[1] 2 3
Levels: 2 3 4 5
> levels(aa)
[1] "2" "3" "4" "5"
> factor(c("Mujer","Mujer","Hombre"))
[1] Mujer Mujer Hombre
Levels: Hombre Mujer
> levels(factor(c("Mujer","Mujer","Hombre")))
[1] "Hombre" "Mujer"

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

Comando Significado
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) Máximo 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 correlación entre los vectores x e y
sort(x) Una versión ordenada del vector x
rank(x) Vector de las filas de los valores en x
order(x) Indica la posición que tendrı́an los valores ordenados de x
quantile(x) Mı́nimo, primer cuartil, mediana, tercer cuartil y máximo de x
cumsum(x) Vector formado por la frecuencia acumulada del vector x
cumprod(x) Vector formado por el producto acumulado del vector x

El siguiente código sirve como ejemplo de cómo utilizar las funciones anteriores:

> x=c(1,2,3,4,5)
22 CAPÍTULO 2. MANIPULACIÓN DE DATOS

> 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 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 vendrı́a dada por
> ((n-1)/n)*var(x)
[1] 2
> sum((x-mean(x))^2)/(n)
[1] 2
> #La cuasicovarianza
> cov(x,y)
[1] 1.5
> sum((x-mean(x))*(y-mean(y)))/(n-1)
[1] 1.5
> #La covarianza serı́a
> ((n-1)/n)*cov(x,y)
[1] 1.2
> sum((x-mean(x))*(y-mean(y)))/(n)
[1] 1.2
> cor(x,y)
[1] 0.5669467
> sort(x)
[1] 1 2 3 4 5
> sort(y)
2.2. OPERACIONES CON MATRICES 23

[1] 1 1 3 3 5
> sort(y,index.return=TRUE)
$x
[1] 1 1 3 3 5

$ix
[1] 1 4 2 3 5
> y
[1] 1 3 3 1 5
> rank(x)
[1] 1 2 3 4 5
> rank(y)
[1] 1.5 3.5 3.5 1.5 5.0
> order(y)
[1] 1 4 2 3 5
> cumsum(y)
[1] 1 4 7 8 13
> cumprod(y)
[1] 1 3 9 9 45

2.2. Operaciones con Matrices

Las matrices son generalizaciones bidimensionales de los vectores. Se puede decir que son
vectores indexados por dos ı́ndices, y se imprimen de modo especial. Para crearlas utilizamos
la funcion 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) y ncol (número de columnas).

> m0=matrix(1:6,ncol=2,nrow=3)
> #Hemos formado una matriz de unos de dos filas y tres columnas
> m0
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> m1=matrix(1,nrow=2,ncol=3)
> m1
[,1] [,2] [,3]
[1,] 1 1 1
[2,] 1 1 1
> m2=matrix(1:4,2)
> m2
24 CAPÍTULO 2. MANIPULACIÓN DE DATOS

[,1] [,2]
[1,] 1 3
[2,] 2 4
> 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
> m3=matrix(1:8,ncol=4)
> m3
[,1] [,2] [,3] [,4]
[1,] 1 3 5 7
[2,] 2 4 6 8
> #Hemos formado una matriz con el vector 1:8 de cuatro columnas
> #Tenemos que tener en cuenta el tama~no de la matriz
> m2=matrix(1:4,3)
Mensajes de aviso perdidos
In matrix(1:4, 3) :
la longitud de los datos [4] no es un submúltiplo o múltiplo del
número de filas [3] en la matriz
> m2
[,1] [,2]
[1,] 1 4
[2,] 2 1
[3,] 3 2

Si se quiere dar nombre a las columnas (o a las filas), se puede hacer asignando valores
al parámetro dim, con los nombres de las filas y las columnas como se ilustra el siguiente
ejemplo.

> #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()))
2.2. OPERACIONES CON MATRICES 25

[,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

Para hacer referencia a una submatriz o a un elemento de la matriz, indicaremos los

ı́ndices de los elementos que se desean considerar. Podemos hacer referencia a una fila (que
es un vector) mediante nombre matriz[i,], con i el ı́ndice de la fila que queremos mostrar;
o a una columna mediante nombre matriz[,j], con j el ı́ndice de la columna que quere-
mos mostrar. Si lo que queremos es un elemento concreto indicamos los dos ı́ndices ası́:
nombre matriz[i,j].

Un argumento útil del comando matrix es byrow, que indica si la matriz debe construirse
por filas (el valor predeterminado es FALSE).

> #Introducimos los datos, peso, altura, edad.

> datos=c(70,108,82,1.80,2.06,1.98,27,19,32)
> mm=matrix(datos,ncol=3,dimnames=list(c("Peso","Altura","Edad"),c()),byrow=T)
> #Con byrow=T (o byrow=TRUE) le hemos dicho que lea primero por filas
> mm
[,1] [,2] [,3]
Peso 70.0 108.00 82.00
Altura 1.8 2.06 1.98
Edad 27.0 19.00 32.00
> mm=matrix(datos,ncol=3,dimnames=list(c("Peso","Altura","Edad"),c()),byrow=F)
> #Con byrow=F le hemos dicho que lea primero por columnas,
con lo que no se muestra correctamente
> mm
[,1] [,2] [,3]
Peso 70 1.80 27
Altura 108 2.06 19
Edad 82 1.98 32

Hemos visto como crear una matriz a partir de un vector con la función matrix pero
también puede resultar interesante ver cómo podemos pasar de una matriz a un vector.
Veamos el siguiente ejemplo:
26 CAPÍTULO 2. MANIPULACIÓN DE DATOS

> A=matrix(c(1:4,2,3,1,2,7),nrow=3)
> A
[,1] [,2] [,3]
[1,] 1 4 1
[2,] 2 2 2
[3,] 3 3 7
> x=c(A)
> x
[1] 1 2 3 4 2 3 1 2 7
Podemos realizar operaciones con matrices de la misma forma que lo hacı́amos con los
vectores, es decir, componente a componente: suma, resta, multiplicación por escalares, mul-
tiplicación elemento a elemento, división, exponenciación, división entera y módulo, que se
realizan mediante los sı́mbolos: +, −, ∗, /,ˆ, %/ % y % %, respectivamente. Veamos algunos
ejemplos ejecutando el código siguiente:

> M1=matrix(1:6,2,3)
> M1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> M2=matrix((1:6)^2,2,3)
> M2
[,1] [,2] [,3]
[1,] 1 9 25
[2,] 4 16 36
> M1+M2
[,1] [,2] [,3]
[1,] 2 12 30
[2,] 6 20 42
> #He sumado componente a componente
> M1*M2
[,1] [,2] [,3]
[1,] 1 27 125
[2,] 8 64 216
> #He multiplicado componente a componente
> M2/M1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> #He dividido componente a componente
> M2%%M1
2.2. OPERACIONES CON MATRICES 27

[,1] [,2] [,3]

[1,] 0 0 0
[2,] 0 0 0
> M2*(3:6)
[,1] [,2] [,3]
[1,] 3 45 75
[2,] 16 96 144
Mensajes de aviso perdidos
In M2 * (3:6) :
longitud de objeto mayor no es múltiplo de la longitud de uno menor

Mediante la funcion t calculamos la matriz traspuesta.

> M1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> t(M1)
[,1] [,2]
[1,] 1 2
[2,] 3 4
[3,] 5 6
> #Para realizar la multiplicación usual de matrices uso %*%
> #Ojo a las dimensiones
> dim(M1)
[1] 2 3
> dim(M2)
[1] 2 3
> M1%*%t(M2)
[,1] [,2]
[1,] 153 232
[2,] 188 288

Los comandos cbind y rbind nos permiten concatenar matrices y/o vectores. La función
diag se puede usar para extraer o modificar la diagonal de una matriz o para construir una
matriz diagonal.

> m1=matrix(1,nr=2,nc=2)
> m1
[,1] [,2]
[1,] 1 1
[2,] 1 1
28 CAPÍTULO 2. MANIPULACIÓN DE DATOS

> m2=matrix(2,nr=2,nc=2)
> m2
[,1] [,2]
[1,] 2 2
[2,] 2 2
> #Unimos las dos matrices por filas
> rbind(m1,m2)
[,1] [,2]
[1,] 1 1
[2,] 1 1
[3,] 2 2
[4,] 2 2
> #Unimos las dos matrices por columnas
> cbind(m1,m2)
[,1] [,2] [,3] [,4]
[1,] 1 1 2 2
[2,] 1 1 2 2
> #Mostramos la diagonal de la matriz
> diag(m1)
[1] 1 1
> diag(m2)
[1] 2 2
> #Cambiamos la diagonal de la matriz
> diag(m1)=15
> m1
[,1] [,2]
[1,] 15 1
[2,] 1 15
> #Creamos una matriz diagonal de orden 4
> diag(4)
[,1] [,2] [,3] [,4]
[1,] 1 0 0 0
[2,] 0 1 0 0
[3,] 0 0 1 0
[4,] 0 0 0 1
> v=c(10,15,20)
> diag(v)
[,1] [,2] [,3]
[1,] 10 0 0
[2,] 0 15 0
[3,] 0 0 20
2.2. OPERACIONES CON MATRICES 29

> 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

Ya hemos visto cómo se agregan filas y columnas a una matriz ya existente, pero a veces
es útil también eliminarlas. Veamos algún ejemplo.

> A=matrix(c(1,2,1,3,1,4,5,6),nrow=2)
> A
[,1] [,2] [,3] [,4]
[1,] 1 1 1 5
[2,] 2 3 4 6
> #Para eliminar la tercera columa simplemente la selecciono con - delante
> A[,-3]
[,1] [,2] [,3]
[1,] 1 1 5
[2,] 2 3 6
> #Para filas es análogo

La función solve invierte una matriz (si se le da sólo un argumento) y resuelve sistemas
lineales de ecuaciones (cuando se le dan dos). El primer argumento debe ser una matriz cua-
drada no singular, y el segundo argumento (opcional) será un vector o matriz de coeficientes.

> A2=matrix(c(1,2,1,3),nrow=2)
> A2
[,1] [,2]
[1,] 1 1
[2,] 2 3
> b1=c(1,2)
> b1
[1] 1 2
> solve(A2)
[,1] [,2]
[1,] 3 -1
[2,] -2 1
> solve(A2)%*%A2
[,1] [,2]
[1,] 1 0
[2,] 0 1
> A2%*%solve(A2)
[,1] [,2]
30 CAPÍTULO 2. MANIPULACIÓN DE DATOS

[1,] 1 0
[2,] 0 1
> solve(A2,b1)
[1] 1 0
> A2%*%solve(A2,b1)==b1
[,1]
[1,] TRUE
[2,] TRUE

La función eigen calcula los autovalores y autovectores de una matriz cuadrada, el resul-
tado es una lista de dos componentes llamados values y vectors. Con la función det calculamos
el determinante de una matriz cuadrada..

> A2
[,1] [,2]
[1,] 1 1
[2,] 2 3
> eigen(A2)
$values
[1] 3.7320508 0.2679492

$vectors
[,1] [,2]
[1,] -0.3437238 -0.8068982
[2,] -0.9390708 0.5906905
> #Si sólo me interesan los autovectores puedo extraerlos asi
> eigen(A2)$vectors
[,1] [,2]
[1,] -0.3437238 -0.8068982
[2,] -0.9390708 0.5906905
> eigenvec1=eigen(A2)$vectors[,1]
> eigenvec1
[1] -0.3437238 -0.9390708
> det(A2)
[1] 1

2.3. Operaciones con Arrays

Se puede definir un array como una colección de observaciones con subı́ndices, siendo
las matrices un caso particular: en concreto arrays bidimensionales (ya que sus elementos
constan de dos subı́ndices). R es especialmente adecuado para crear y manejar este tipo de
2.3. OPERACIONES CON ARRAYS 31

objetos. Tienen como atributo la dimensión, que puede asignarse o describirse mediante dim.
Un vector numérico puede utilizarse como un array si se le asigna una dimensión.

El siguiente código nos ayuda a entender cómo funciona dim, y cómo podemos pasar de
un vector a un array mediante este simple comando.

> w=c(seq(2,10,by=2),rep(0,2),1:5)
> w
[1] 2 4 6 8 10 0 0 1 2 3 4 5
> dim(w)
NULL
> dim(w)=c(6,2)
> w
[,1] [,2]
[1,] 2 0
[2,] 4 1
[3,] 6 2
[4,] 8 3
[5,] 10 4
[6,] 0 5
> dim(w)=c(2,6)
> w
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 2 6 10 0 2 4
[2,] 4 8 0 1 3 5
> dim(w)=c(6,2)
> w
[,1] [,2]
[1,] 2 0
[2,] 4 1
[3,] 6 2
[4,] 8 3
[5,] 10 4
[6,] 0 5
> dim(w)=c(2,3,2)
> w
, , 1

[,1] [,2] [,3]

[1,] 2 6 10
[2,] 4 8 0
32 CAPÍTULO 2. MANIPULACIÓN DE DATOS

, , 2

[,1] [,2] [,3]

[1,] 0 2 4
[2,] 1 3 5

Como se puede observar en el ejemplo anterior, la forma de colocar los datos es rellenando
por columnas los sucesivos bloques. A los elementos colocados en cada posición se les puede
denominar con el nombre del array seguido de su posición entre [ ] y separando los subı́ndices
que describen dicha posición entre comas.

> #Para obtener el valor que se encuentra en la segunda fila de la segunda

columna del primer bloque escribimos
> w[2, 2, 1]
[1] 8
> #Para obtener la segunda columna del primer bloque
> w[,2,1]
[1] 6 8
> #Para obtener las segundas columnas de los dos bloques
> w[,2,]
[,1] [,2]
[1,] 6 2
[2,] 8 3

Otra forma de construir arrays a partir de vectores, es mediante la función array, espe-
cificando el nombre del vector y la dimensión del nuevo objeto. Veamos un ejemplo.

> x=rnorm(50, 2, 3)
> arx=array(x, c(5, 5, 2))
> arx
, , 1

[,1] [,2] [,3] [,4] [,5]

[1,] -2.427067 2.2985124 -0.8902211 2.5477677 4.1822495
[2,] 5.225509 4.0487850 -1.0995668 4.1126750 2.5445917
[3,] 2.809060 0.8936185 1.4651909 -0.9141957 -0.4895224
[4,] 3.044384 5.1428972 1.0284270 3.5359491 0.2088279
[5,] 3.430658 1.9416653 0.4417464 1.7847717 -2.3978360

, , 2
2.4. LISTAS 33

[,1] [,2] [,3] [,4] [,5]

[1,] 3.81192334 10.986071 -2.7946941 4.125017 2.769069
[2,] -0.02396428 4.684890 3.8211341 4.134969 2.786864
[3,] 1.00936032 5.475427 0.5606429 -3.542194 -1.825927
[4,] 1.38705332 -4.690577 3.2945309 -2.201784 1.937688
[5,] -3.45243499 -1.025671 4.3453096 -4.537629 7.136423

Cuando usamos la función array, si el vector no tiene elementos suficientes para rellenar
los huecos del array, éste se completa con los primeros valores del vector.

2.4. Listas
La función list devuelve un objeto tipo “lista” con tantas componentes como argumentos
se le suministren. Se utiliza para devolver resultados de una función.

> dias.semana=c("Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo")
> dias.semana
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes" "Sabado"
[7] "Domingo"
> list(A=dias.semana,B=1:7)
$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes" "Sabado"
[7] "Domingo"
$B
[1] 1 2 3 4 5 6 7

Para referirnos a cada uno de los elementos de la lista lo hacemos mediante dobles corche-
tes. Si los elementos tienen nombre, entonces también podemos usar el sı́mbolo $ y el nombre
del elemento.

> list(A=dias.semana,B=1:7)[[1]]
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes" "Sabado"
[7] "Domingo"
> list(A=dias.semana,B=1:7)[[2]]
[1] 1 2 3 4 5 6 7
> list(A=dias.semana,B=1:7)$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes" "Sabado"
[7] "Domingo"
> list(A=dias.semana,B=1:7)$B
[1] 1 2 3 4 5 6 7
34 CAPÍTULO 2. MANIPULACIÓN DE DATOS

La diferencia fundamental entre las tres formas: [, [[ y $ es que la primera permite selec-
cionar varios elementos, en tanto que las dos últimas sólo permiten seleccionar uno. Además,
$ no permite utilizar ı́ndices calculados. El operador [[ necesita que se le indiquen todos los
ı́ndices (ya que debe seleccionar un solo elemento) y [ permite obviar ı́ndices, en cuyo caso
se seleccionan todos los valores posibles. Si se aplican a una lista, [[ devuelve el elemento de
la lista especificado y [ devuelve una lista con los elementos especificados.

> lista1=list(A=dias.semana,B=1:7)
> lista2=list(lista1,C="Hola",D=matrix(1:8,2))
> lista1
$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes" "Sabado"
[7] "Domingo"
$B
[1] 1 2 3 4 5 6 7
> lista2
[[1]]
[[1]]$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes"
[6] "Sabado" "Domingo"

[[1]]$B
[1] 1 2 3 4 5 6 7

$C
[1] "Hola"

$D
[,1] [,2] [,3] [,4]
[1,] 1 3 5 7
[2,] 2 4 6 8
> lista2[[1]]
$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes"
[6] "Sabado" "Domingo"

$B
[1] 1 2 3 4 5 6 7

> lista2[[2]]
2.5. HOJA DE DATOS (DATA.FRAME) 35

[1] "Hola"
> lista2[[3]]
[,1] [,2] [,3] [,4]
[1,] 1 3 5 7
[2,] 2 4 6 8
> lista2[[4]]
Error in lista2[[4]] : subı́ndice fuera de los lı́mites
> lista2[[1]]$A
[1] "Lunes" "Martes" "Miercoles" "Jueves" "Viernes"
[6] "Sabado" "Domingo"
> lista2[[1]]$B
[1] 1 2 3 4 5 6 7

2.5. Hoja de datos (data.frame)

Una hoja de datos es una lista que pertenece a la clase data.frame. Las componentes de
este tipo de listas 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 con-
tribuyen a la nueva hoja de datos con tantas variables como columnas, elementos o variables
posean, respectivamente. Los vectores que constituyen la hoja de datos deben tener la misma
longitud, y las matrices el mismo tamaño. La diferencia fundamental con la matriz de datos
es que este objeto no tiene porqué estar compuesto de elementos del mismo tipo. Los objetos
pueden ser, como ya hemos dicho, vectores, factores, matrices, listas e incluso hojas de datos.
> datos1=data.frame(Peso=c(90,120,56),Altura=c(1.90,1.87,1.70))
> datos1
Peso Altura
1 90 1.90
2 120 1.87
3 56 1.70
> datos2=data.frame(datos1,Sexo=c("Hombre","Hombre","Mujer"))
> datos2
Peso Altura Sexo
1 90 1.90 Hombre
2 120 1.87 Hombre
3 56 1.70 Mujer
Con los siguientes comandos vemos cómo diferencia R entre los distintos objetos.
> is.vector(datos1)
[1] FALSE
> is.matrix(datos1)
36 CAPÍTULO 2. MANIPULACIÓN DE DATOS

[1] FALSE
> is.data.frame(datos1)
[1] TRUE
> datos1[2]
Altura
1 1.90
2 1.87
3 1.70
> datos2[3]
Sexo
1 Hombre
2 Hombre
3 Mujer
> is.factor(datos1[2])
[1] FALSE
> str(datos1[2])
‘data.frame’: 3 obs. of 1 variable:
$ Altura: num 1.9 1.87 1.7
> is.factor(datos2[[3]])
[1] TRUE

Para introducir un vector de nombres se tiene que utilizar la función I.

> nombres=c("Pepe","Paco","Pepita")
> nombres
[1] "Pepe" "Paco" "Pepita"
> datos3=data.frame(datos2,Nombres=I(nombres))
> datos3
Peso Altura Sexo Nombres
1 90 1.90 Hombre Pepe
2 120 1.87 Hombre Paco
3 56 1.70 Mujer Pepita

Si se desea seleccionar un subconjunto de una hoja de datos, se puede hacer con la función
subset, función que puede utilizar también en vectores. Para realizar modificaciones en un
data frame es muy útil la función transform.

> datos3
Peso Altura Sexo Nombres
1 90 1.90 Hombre Pepe
2 120 1.87 Hombre Paco
3 56 1.70 Mujer Pepita
2.5. HOJA DE DATOS (DATA.FRAME) 37

> subset(datos3,select=c(Sexo,Nombres))
Sexo Nombres
1 Hombre Pepe
2 Hombre Paco
3 Mujer Pepita
> subset(datos3,subset=c(Sexo=="Mujer"))
Peso Altura Sexo Nombres
3 56 1.7 Mujer Pepita
> subset(datos3,subset=Sexo=="Mujer")
Peso Altura Sexo Nombres
3 56 1.7 Mujer Pepita
> 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 1.70 Mujer Pepita 4.025352
> transform(datos3,IMC=Peso/Altura^2)
Peso Altura Sexo Nombres IMC
1 90 1.90 Hombre Pepe 24.93075
2 120 1.87 Hombre Paco 34.31611
3 56 1.70 Mujer Pepita 19.37716
> #Obsérvese que el archivo original no cambia
> datos3
Peso Altura Sexo Nombres
1 90 1.90 Hombre Pepe
2 120 1.87 Hombre Paco
3 56 1.70 Mujer Pepita

Como hemos visto, la funcion de R data.frame permite concatenar todas las variables
en un solo conjunto de datos. De la misma forma, también podemos guardar en un archivo
dicho conjunto de datos utilizando la función write.table. El formato del archivo guardado
es .CSV (comma separated variables, variables separadas por comas). Éste es un formato de
texto muy fácil de leer con cualquier editor de texto como Excel. Para leer el archivo en R
usaremos read.csv.

La notación $ para componentes de listas no siempre es la más apropiada. En ocasiones,

serı́a 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
38 CAPÍTULO 2. MANIPULACIÓN DE DATOS

abc$w. La orden attach(abc) conecta la hoja de datos y ahora u, v y w apareceran como

objetos por sı́ mismos. Para desconectar una hoja de datos se usa la función detach(). Una
vez realizada esta operacion dejarán de existir las variables u, v y w como tales, aunque
seguiran existiendo como componentes de la hoja de datos. Es conveniente desconectar una
hoja de datos cuando termine de utilizar sus variables.

Veamos algunos ejemplos.

> misdatos=list(A=c(1,2),B=matrix(0,nrow=3,ncol=2),CC="Hola")
> misdatos
$A
[1] 1 2

$B
[,1] [,2]
[1,] 0 0
[2,] 0 0
[3,] 0 0

$CC
[1] "Hola"

> A
Error: objeto ’A’ no encontrado
> B
Error: objeto ’B’ no encontrado
> CC
Error: objeto ’CC’ no encontrado
> attach(misdatos)
> A
[1] 1 2
> B
[,1] [,2]
[1,] 0 0
[2,] 0 0
[3,] 0 0
> CC
[1] "Hola"
> detach(misdatos)
> A
Error: objeto ’A’ no encontrado
2.6. LECTURA Y ESCRITURA DE DATOS 39

> B
Error: objeto ’B’ no encontrado
> CC
Error: objeto ’CC’ no encontrado
> misdatos=data.frame(A=c(1,2),B=matrix(0,nrow=3,ncol=2),CC="Hola")
Error in data.frame(A = c(1, 2), B = matrix(0, nrow = 3, ncol = 2), CC = "Hola") :
arguments imply differing number of rows: 2, 3, 1
> misdatos=data.frame(A=c(1,2),B=matrix(0,nrow=2,ncol=3),CC="Hola")
> misdatos
A B.1 B.2 B.3 CC
1 1 0 0 0 Hola
2 2 0 0 0 Hola
> attach(misdatos)
> A
[1] 1 2
> B.1
[1] 0 0
> CC
[1] Hola Hola
Levels: Hola
> detach(misdatos)
> A
Error: objeto ’A’ no encontrado
> B.1
Error: objeto ’B.1’ no encontrado
> CC
Error: objeto ’CC’ no encontrado

2.6. 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: archivos de 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 están construidos. La orden serı́a de la siguiente forma:

read.table("path_archivo",header=TRUE,sep="",na.strings="NA",dec=".")

Con ella estamos indicando que R debe leer los datos que se encuentran en la ruta indicada
(usando /) y que dichos datos tienen cabecera (es decir que existe una primera fila con los
nombres de las variables). Con na.strings=“NA” indicamos que los valores faltantes los tome
40 CAPÍTULO 2. MANIPULACIÓN DE DATOS

como NAs. El separador decimal de los datos que tenemos es el punto en vez de la coma.
Hay otros argumentos que se le pueden añadir a la función, tales como el tipo de valores de
los datos (lógicos, enteros, etc.), el número de columnas, etc.

> #Leemos el archivo scoredata.txt y lo llamo Datos.

> #Primero vemos cual es el directorio de trabajo y lo cambiamos si es necesario
> #getwd() y setwd
> Datos=read.table("scoredata.txt",header=TRUE,sep="",na.strings="NA",dec=".")
> #Con la siguiente orden mostramos los primeros datos del archivo y los nombres
> head(Datos)
Mechanics_C Vectors_C Algebra_O Analysis_O Statistics_O
1 77 82 67 67 81
2 63 78 80 70 81
3 75 73 71 66 81
4 55 72 63 70 68
5 63 63 65 70 63
6 53 61 72 64 73
> #La siguiente muestra sólo los nombres
> names(Datos)
[1] "Mechanics_C" "Vectors_C" "Algebra_O" "Analysis_O" "Statistics_O"

También serı́a posible leer los datos directamente de una página web o repositorio digital
de la siguiente forma:

> Datos=read.table("http://www.mat.ucm.es/~albfranc/eng/scoredata.txt",
header=T,sep="",na.strings="NA",dec=".")

Con la función View visualizamos los datos que hemos cargado en memoria anteriormente.

> View(Datos)

Con la función fix podemos modificar los datos cambiando o añadiendo elementos.

> fix(Datos)

Para dejar de editar la tabla de datos, pulsamos Esc.

Con la función write podemos crear ficheros a partir de los datos que vamos calculando
con R o con datos que nosotros vamos introduciendo. Por ejemplo:

> #Con la siguiente orden creamos una tabla en blanco a la que nombramos Datos1
> Datos1=edit(as.data.frame(NULL))
2.7. BASES DE DATOS CONOCIDAS 41

Vamos a crear dos variables con los siguientes datos:

var1: 1, 3, 2, 4, 3
var2: 2, 4, 1, 2, 1

Cuando terminamos de introducir los datos, cerramos la ventana Editor de datos. Y vemos
que, efectivamente, se ha creado el fichero de datos Datos1.

> Datos1
var1 var2
1 1 2
2 3 4
3 2 1
4 4 2
5 3 1
> #Vamos a guardar en A y en B, respectivamente, las columnas
> A=Datos1$var1
> B=Datos1$var2
> A
[1] 1 3 2 4 3
> B
[1] 2 4 1 2 1
> #Creamos un fichero vector con la suma de los dos elementos
> A+B
[1] 3 7 3 6 4
> #Lo guardamos en un fichero .txt que se llame sumaAyB
> write(A*B,"sumaAyB.txt")

La función write funciona con argumentos similares a la función read.table de la siguien-

te manera: 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, nco-
lumns el número de columnas y sep es el separador (en nuestro caso espacio en blanco). El
argumento append es también muy útil. Si append=TRUE los nuevos datos se añadirán a
los anteriores en filas posteriores. Si append=FALSE los datos anteriores son sustituidos por
los nuevos.

2.7. Bases de datos conocidas

Vamos a visualizar los conjuntos de datos más populares que están disponibles en R. Para
ello escribimos:

> data()
42 CAPÍTULO 2. MANIPULACIÓN DE DATOS

El archivo “AirPassengers” es una base muy conocida en el contexto de las series tempo-
rales. Si queremos más información relativa a estos datos podemos escribir:

> AirPassengers
Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
1949 112 118 132 129 121 135 148 148 136 119 104 118
1950 115 126 141 135 125 149 170 170 158 133 114 140
1951 145 150 178 163 172 178 199 199 184 162 146 166
1952 171 180 193 181 183 218 230 242 209 191 172 194
1953 196 196 236 235 229 243 264 272 237 211 180 201
1954 204 188 235 227 234 264 302 293 259 229 203 229
1955 242 233 267 269 270 315 364 347 312 274 237 278
1956 284 277 317 313 318 374 413 405 355 306 271 306
1957 315 301 356 348 355 422 465 467 404 347 305 336
1958 340 318 362 348 363 435 491 505 404 359 310 337
1959 360 342 406 396 420 472 548 559 463 407 362 405
1960 417 391 419 461 472 535 622 606 508 461 390 432
> help(AirPassengers)
starting httpd help server ... done

El archivo “USArrests” muestra el valor de 4 variables relacionadas con violencia y eva-

luadas en los 50 estados de EEUU.

> dim(USArrests)
[1] 50 4

El archivo “cars” contiene datos relativos a la velocidad y distancias de frenada de 50

coches. Estos datos son muy conocidos en el contexto de regresión.

> dim(cars)
[1] 50 2

Para probar nuevas técnicas de análisis discriminante se suele recurrir al archivo “iris”,
que contiene medidas del ancho y la longitud del pétalo y el sépalo de un conjunto de tres
tipos de flores.

También, dentro de algunos paquetes, se encuentran bases de datos especı́ficas.

La librerı́a MASS es una de las más utilizadas. Está directamente ligada al libro de
Venables y Ripley (2002).

> library(MASS)
> data()
2.7. BASES DE DATOS CONOCIDAS 43

Con estos comandos vemos las bases de datos que ya tenı́amos y a las que tenemos acceso
ahora que hemos cargado la librerı́a MASS. Para visualizar los datos Aids2 ponemos:

> Aids2

Una librerı́a muy importante en el Análisis de Supervivencia es survival, en la que también

se encuentran numerosas bases de datos. Por ejemplo, si cargamos la librerı́a survival tenemos
el conjunto de datos pbc.

> pbc
Error: objeto ‘pbc’ no encontrado
> library(survival)
Loading required package: splines
> pbc
44 CAPÍTULO 2. MANIPULACIÓN DE DATOS
Capı́tulo 3

FUNCIONES

Como hemos visto anteriormente, las funciones permiten realizar las diferentes acciones.
Existen funciones ya definidas (aunque pueden ser modificadas) pero, además, R permite
crear nuevas funciones. Estas nuevas funciones se incorporan al lenguaje y se utilizan poste-
riormente como las ya existentes.

Las funciones tradicionales de uso matemático y estadı́stico, están definidas. Entre ellas
las más utilizadas son: abs, sqrt, sin, cos, tan, exp, log, log10, min, max, sum, prod,
length, range, mean, median, var, cov, summary, sort, rev y order.

> sin(1:5)
[1] 0.8414710 0.9092974 0.1411200 -0.7568025 -0.9589243
> rev(sin(1:5))
[1] -0.9589243 -0.7568025 0.1411200 0.9092974 0.8414710
> sin(pi)
[1] 1.224606e-16
> sin(pi/2)
[1] 1
> sum(1:5)
[1] 15
> prod(1:5)
[1] 120

3.1. Definición de una función

Una función se define asignando a un objeto la palabra function seguida de los argu-
mentos que se desee dar a la función, escritos entre paréntesis y separados por comas.

nombre=function(arg1, arg2, ...) {expresión}

45
46 CAPÍTULO 3. FUNCIONES

La expresión es una fórmula o grupo de fórmulas que utilizan los argumentos para calcular
un valor. El valor de dicha expresion es el valor que proporciona R en su salida y éste puede
ser un simple número, un vector, una gráfica, una lista o un mensaje.

Veamos un ejemplo de cómo crear y utilizar una función:

> funcion.suma=function(A,B){
+ A+B}
> funcion.suma(10,3)
[1] 13
> funcion.suma(12,30)
[1] 42

La función que acabamos de definir no se refiere a la suma de dos números, sino a la suma
de dos objetos, que podrán ser vectores, matrices, variables indexadas, etc. Si le asignamos
dos valores concretos los sumará, como hemos visto en el ejemplo anterior.

> funcion.suma(c(1,12),c(3,0))
[1] 4 12

Si se desea enfatizar cuál será el valor devuelto, se puede utilizar el comando return.
Cuando se encuentra esta orden, la función detiene la ejecución y devuelve los valores indi-
cados.

> primera.funcion=function(A,B){
+ #esta función devuelve el valor suma A+B
+ return(A+B)
+ }
> primera.funcion(2,4)
[1] 6

Podemos dar valores por defecto a los argumentos de la siguiente forma:

> primera.funcion=function(A=1,B=-2){
+ #esta función devuelve el valor suma A+B
+ return(A+B)
+ }
> primera.funcion()
[1] -1
> primera.funcion(3)
[1] 1

Es posible acceder a los argumentos o cuerpo de una función mediante los comandos
formals y body.
3.2. EJEMPLOS DE FUNCIONES ELEMENTALES EN ESTADÍSTICA 47

> formals(primera.funcion)
> formals(primera.funcion)
$A
[1] 1

$B
-2

> body(primera.funcion)
{
return(A + B)
}
A través de la función expression. En el siguiente ejemplo se muestra cómo utilizar esta
función.
#Modificamos el cuerpo de la función
> body(primera.funcion)=expression(A*B)
> body(primera.funcion)
A * B
> body(primera.funcion)=expression({A*B})
> body(primera.funcion)
{
A * B
}
> primera.funcion(3,1)
[1] 3
> primera.funcion(3)
[1] -6
Otra orden interesante para modificar funciones es edit. Con ella podemos editar la
función que necesitemos y adaptarla a nuestras necesidades.
> edit(primera.funcion)
Se abre una ventana que nos permite editar la función que hemos creado conteriormente.

3.2. Ejemplos de funciones elementales en Estadı́stica

3.2.1. Función media
Como ya hemos visto, R ya tiene implementada la función mean que calcula la media de
los valores que le indiquemos. Tenemos la opción de decirle que si algún elemento es NA, no
lo considere para poder hacer el cálculo. Vemos cómo:
48 CAPÍTULO 3. FUNCIONES

> mean(c(2,4,1,3,6,7))
[1] 3.833333
> mean(c(2,4,1,3,6,NA))
[1] NA
> mean(c(2,4,1,3,6,NA),na.rm=TRUE)
[1] 3.2

Vamos a crear nuestra propia función media. Será una función de un único argumento.
La función presupone que el argumento dado es un vector, elimina las componentes de dicho
vector que son NAs y calcula la media del resto de las componentes. Recordemos que ! indica
negación.

> media=function(x){
+ 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

3.2.2. Función varianza

Como ya hemos visto, R tiene implementada la función var, que calcula la cuasivarianza
muestral.

> var(c(2,4,1,3,6,7))
[1] 5.366667
> var(c(2,4,1,3,6,NA))
[1] NA
> var(c(2,4,1,3,6,NA),na.rm=TRUE)
[1] 3.7

Creamos una nueva función en R que calcule la cuasivarianza muestral. Será una función
de un único argumento. La función presupone que el argumento dado es un vector, elimina
las componentes de dicho vector que son NAs y calcula la cuasivarianza del resto de las
componentes.

> Varianza=function(x){
+ x=x[!is.na(x)]
+ v=sum((x-(sum(x)/length(x)))^2)/(length(x)-1)
+ return(v)
+ }
3.3. ESTRUCTURAS CONDICIONALES 49

> Varianza(c(2,4,1,3,6,7))
[1] 5.366667
> Varianza(c(2,4,1,3,6,NA))
[1] 3.7

3.3. Estructuras condicionales

En las próximas secciones veremos algunos elementos útiles a la hora de programar.

Las estructuras condicionales son aquellas que, según el resultado de una comparación,
realizan una u otra acción. La primera estructura que veremos es:

if (condición) acción1 [else acción2]

donde los corchetes indican que esa parte es opcional.

> #Creamos una función que calcule el logaritmo de un número

> logaritmo=function(x){
+ if(is.numeric(x) && min(x)>0)
+ log(x)
+ else "x no es numérico o es menor o igual que cero"
+ }
> logaritmo(3)
[1] 1.098612
> logaritmo(0)
[1] "x no es numérico o es menor o igual que cero"
> logaritmo(-2)
[1] "x no es numérico o es menor o igual que cero"
> logaritmo(e)
Error in logaritmo(e) : objeto ’e’ no encontrado
> logaritmo("e")
[1] "x no es numérico o es menor o igual que cero"
> logaritmo(exp(1))
[1] 1

La segunda estructura es:

ifelse(condición C, acción en caso de que se cumpla C, acción en caso de que no)

Vemos cómo funciona con el siguiente ejemplo:

50 CAPÍTULO 3. FUNCIONES

> x=c(-2:3)
> Inverso=ifelse(x==0,"no se puede dividir por 0",1/x)
> Inverso
[1] "-0.5" "-1"
[3] "no se puede dividir por 0" "1"
[5] "0.5" "0.333333333333333"

3.4. Estructuras de repetición definida e indefinida

Hay principalmente tres tipos de estructuras, que son las siguientes:

for (variable in valores) {acción}

while (condición) {acción}

repeat {acción}

La estructura for asigna a “variable” cada uno de los valores y realiza la acción para cada
uno de ellos. La estructura while evalúa la condición y, mientras ésta es cierta, se realiza
la acción. La estructura repeat realiza la acción indefinidamente. En los tres casos, el valor
del ciclo completo es el correspondiente a la última acción. Las expresiones pueden contener
algún condicional como if asociado con las funciones next o break. El comando next indica
que debe terminarse la iteración actual y pasar a la siguiente. El comando break indica que
debe terminarse el ciclo. Vamos a ver algunos ejemplos.

3.5. Más ejemplos de funciones

En los siguientes apartados vemos ejemplos de funciones que existen en R y proponemos
algunos ejempos que nos sirven para repasar algunas de las estructuras vistas en este capı́tulo.

3.5.1. Factorial de un número

Con la función factorial de R podemos calcular el factorial de un número. A continua-
ción presentamos una función alternativa.

> new_factorial=function(n){
+ f=1
+ if(n>1) {for(i in 1:n) f=f*i}
+ return(f)
+ }
3.5. MÁS EJEMPLOS DE FUNCIONES 51

> new_factorial(3)
[1] 6
> new_factorial(25)
[1] 1.551121e+25
> new_factorial(0)
[1] 1
La siguiente función es similar pero utiliza while en lugar de for:
> new_factorial2=function(n){
+ f=1
+ i=1
+ if(n>1) {while(i<=n){
+ f=f*i
+ i=i+1}}
+ return(f)
+ }
> new_factorial2(3)
[1] 6
> new_factorial2(25)
[1] 1.551121e+25
> new_factorial2(0)
[1] 1

3.5.2. Suma de una progresión aritmética

Una progresión aritmética es una sucesión de números tales que la diferencia de dos térmi-
nos sucesivos cualesquiera es constante. Podemos construir varias funciones para implementar
la suma de una progresión aritmética. Usaremos la siguiente notación:

Sn = a1 + a2 + . . . + an = n(a1 + an )/2,

con ai + 1 = ai + d, para todo i.

A continuación presentamos dos funciones alternativas para calcular la suma de una

progresión aritmética en R.
> arit.1=function(n,a1,d){
+ v=numeric() #ası́ inicializo un vector
+ v[1]=a1
+ for (i in 2:n){
+ v[i]=v[i-1]+d
+ }
52 CAPÍTULO 3. FUNCIONES

+ return(sum(v))
+ }
> arit.1(10,2,3)
[1] 155
> arit.2=function(n,a1,d){
+ v=numeric()
+ v[1]=a1
+ for (i in 2:n){
+ v[i]=v[i-1]+d
+ }
+ return(n*(v[1]+v[n])/2)
+ }
> arit.2(10,2,3)
[1] 155

3.5.3. Suma de una progresión geométrica

Una progresión geométrica es una secuencia en la que cada término se obtiene multipli-
cando el anterior por una constante.

En este caso también podemos construir varias funciones para implementarla. Usaremos
la siguiente notación:

Sn = a1 + a2 + . . . + an = a1 (rn − 1)/(r − 1),

con ai + 1 = ai ∗ r, para todo i.

> geom.1=function(n,a1,r){
+ v=numeric()
+ v[1]=a1
+ for(i in 2:n) v[i]=v[i-1]*r
+ return(sum(v))
+ }
> geom.1(2,3,2)
[1] 9
> geom.2=function(n,a1,r) a1*(r^n-1)/(r-1)
> geom.2(2,3,2)
[1] 9
Capı́tulo 4

OPCIONES GRÁFICAS

Los gráficos disponibles en R son todos de gran calidad y poseen una versatilidad muy
grande. Para hacernos una idea, podemos ejecutar la demo:

> demo("graphics")

4.1. Funciones gráficas básicas

Algunos de los gráficos más usuales pueden generarse a partir de las siguientes funciones:

Comando Significado
plot(...) Función genérica para representar en el plano xy puntos, lı́neas, etc.
curve(...) Representa gráficamente una función dada.
barplot(...) Representa un diagramas de barras.
pie(...) Realiza un diagramas de sectores.
hist(...) Crea el histograma.
boxplot(...) Realiza un diagramas de box-and-whisker (caja y bigotes).
pairs(...) Crea un diagrama de puntos entre dos o más variables.

Para crear gráficos más completos podemos ayudarnos de las siguientes funciones:

Comando Significado
points(...) Añade puntos a un gráfico.
abline(...) Añade una recta de pendiente e intersección dadas.
lines(...) Añade curvas a un gráfico.
polygon(...) Añade polı́gonos a un gráfico.
rect(...) Añade rectángulos a un gráfico.
arrows(...) Añade flechas a un gráfico.
segments(...) Añade segmentos a un gráfico.

53
54 CAPÍTULO 4. OPCIONES GRÁFICAS

4.2. Función plot

La función plot es una función genérica de creación de gráficos.

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

Veamos algunos argumentos que podemos usar en la función plot, como type:

> plot(x,x,xlim=c(0,10),ylim=c(0,10),type="l")
> plot(x,x,xlim=c(0,10),ylim=c(0,10),type="s")

4.2.1. Funciones points, abline y lines

Mediante el siguiente código explicaremos cómo añadir puntos, rectas y curvas a un gráfi-
co. Utilizamos la funcion abline para crear un conjunto de lı́neas horizontales, verticales o
con una cierta pendiente en la gráfica actual. Los argumentos de abline indican respectiva-
mente el valor de la ordenada y de la pendiente de la recta. Cuando falta alguno de ellos, se
considera nulo.

> plot(1:100,(1:100)^2,type="l")
> #Ahora generamos un gráfico de dos variables comprendidas entre -4 y 4
> plot(-4:4,-4:4,type="n")
> # Representamos 20 números aleatorios de una distribución normal en rojo
> points(rnorm(20),rnorm(20),col="red")
> #Ojo porque para que points funcione debo tener un gráfico activo
> #Representamos 10 números aleatorios de una distribución normal en azul más grandes
> points(rnorm(10),rnorm(10),col="blue",cex=3)
> abline(1,1,col="blue")
> abline(1,2,col="blue")
> for(i in 1:10) {abline(h=i,col=i)}
> for(i in -2:2) {abline(v=i,col="red")}

Al igual que points, abline requiere que haya un gráfico activo para funcionar.

También text es una función muy útil, ya que nos permite añadir texto a un gráfico
existente. A continuación creamos una gráfica de dos variables x e y, con x entre -2 y 3 e y
entre -1 y 5.
4.2. FUNCIÓN PLOT 55

> plot(c(-2,3),c(-1,5),type="n",xlab="x",ylab="y")
> #Creamos un eje xy de color rojo
> abline(h=0,v=0,col="red")
> #Asignamos una leyenda (recta y=0), de color azul en el par (1,0)
> text(1.75,0.25,"recta (y = 0)",col="blue")
> #Creamos una red para distinguir los pares
> abline(h=-1:5,v=-2:3,col="lightgray",lty=3)
> #Creamos una recta de pendiente 2 y término independiente 1
> abline(a=1,b=2,col=2)
> #A~
nadimos una leyenda para nombrar la recta y=2x+1
> text(1.75,3.25,"recta y=2x+1",col="green")

A la hora de titular un gráfico tenemos dos opciones: o bien creamos directamente el

gráfico con un tı́tulo dado, o bien le añadimos el tı́tulo al gráfico después. Lo vemos en el
siguiente ejemplo.

> x=-5:5
> #Creamos un gráfico con tı́tulo
> plot(x,x^2-2,type="l",main="Gráfico con tı́tulo",sub="y subtı́tulo")
> #A~
nadimos tı́tulo y subtı́tulo a un gráfico
> plot(x=-5:5,x^2-2,type="l")
> title(main="Gráfico con tı́tulo",sub="y subtı́tulo")

Otra manera de crear el gráfico anterior:

> x=-5:5
> plot(x,2*x+1,type="l",xlab="x",ylab="y",xlim=c(-4,5),ylim=c(-1,5),col="red")
> lines(x,rep(0,length(x)),col="red")
> y=-2:6
> lines(rep(0,length(y)),y,col="red")
> text(1,0,"recta( y = 0 )",col="blue")
> abline(h=-1:5,v=-2:3,col="lightgray",lty=3)
> abline(a=1,b=2,col=2)
> text(1,3,"recta y=2x+1",col="green")

La función par nos permite presentar gráficos múltiples. El argumento mfcol=c(m,n), di-
vide el dispositivo gráfico en mxn partes iguales, que se rellenan por columnas. Análogamente
mfrow=c(m,n) rellena por filas.

> x=1:10
> y=(3:12)^3
> par(mfrow=c(2,3))
> plot(x)
56 CAPÍTULO 4. OPCIONES GRÁFICAS

> plot(y)
> plot(x,y)
> plot(x^2,y)
> plot(x,y^2)
> plot(x^2,y^2)

Cada gráfico que creamos es independiente y podemos dar tı́tulo a cada uno.

4.2.2. Funciones polygon, rect, arrows y segments

La función polygon dibuja un polı́gono cuyos vértices se dan a partir de dos vectores x
e y. Al igual que con points y abline, para utilizar estas funciones es necesario que haya
un gráfico activo para funcionar. Veamos dos ejemplos de lo que podemos hacer con esta
función.

> plot(0,0,type="n",xlim=c(-5,5),ylim=c(-5,5))
> x=c(0,4,2,-2,-4)
> y=c(-4,0,4,4,0)
> polygon(x,y,col="red",border="black")
> plot(0,0,type="n",xlim=c(-5,5),ylim=c(-5,5))
> x=c(0,4,2,-2,-4)
> y=c(-4,0,4,4,0)
> polygon(1:9,c(2,1,2,1,NA,2,1,2,1),density=c(10,20),angle=c(-45,45),col=c(2,"blue"))

Con la funcion rect creamos rectángulos del color que deseemos.

> #Creamos un marco para la gráfica con x entre -10 y 10 e y en entre -10 y 10
> plot(0,0,type="n",xlim=c(-10,10),ylim=c(-10,10))
> #Creamos un rectángulo con x de -4 a 4 e y de -4 a 4 de color rojo
> rect(-4,-4,4,4,col="red",border="black")

Con la funcion arrows creamos flechas entre puntos de un par de variables.

> x=1:12
> y=c(10,2,3,10,11,5,6,3,8,11,9,12)
> plot(x,y,main="Flechas")
> #Flechas
> for (s in 1:12){arrows(x[s],y[s],x[s+1],y[s+1],col=1:3)}

Con segments creamos figuras o segmentos a partir de los valores.

> #Volvemos a crear el diagrama de puntos

> plot(x,y, main="Segmentos")
> for (s in 1:12){segments(x[s],y[s],x[s+1],y[s+1],col="pink")}
4.3. FUNCIÓN CURVE 57

También podemos jugar con los valores de x e y.

> # Volvemos a crear el diagrama de puntos

> plot(x,y, main="Flechas y Segmentos")
> # Unimos los pares
> for (s in 1:12){segments(x[s],y[s],x[s+2],y[s+2],col="pink")}

4.3. Función curve

Con la función curve creamos funciones no lineales, tanto polinomiales como trigonométri-
cas. Un argumento interesante es add, con él podemos dibujar varias gráficas a la vez.

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

La función curve también permite añadir un tı́tulo, de estas dos maneras:

> #Directamente introduciendo el tı́tulo como argumento

> curve(tan,-2*pi,2*pi,main="Dibujo")
> #O a~
nadiéndolo después
> curve(tan,-2*pi,2*pi)
> title(main="Dibujo")

4.4. Gráficos estadı́sticos

4.4.1. Función barplot
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 en una escala del 1
al 4. Queremos hacer un diagrama de barras con los resultados para cada una de los valores
de las variables.

> x=c(1,2,3,1,2,1,2,4,1,3,2,4,1,2,3,1,2,4,2,1)
> #Primero calculamos la frecuencia acumulada de cada una de las variables
> table(x)
58 CAPÍTULO 4. OPCIONES GRÁFICAS

x
1 2 3 4
7 7 3 3
> frec.x=table(x)
> #Creamos el diagrama de barras con las leyendas
> barplot(frec.x, main="Frecuencia absoluta",xlab="Valores de la variable")
Vamos a ponerle nombre a las variables y a cambiar las barras verticales por barras
horizontales.
> barplot(frec.x, main="Frecuencia absoluta", xlab="valores de la variable",
horiz=TRUE,names.arg=c("Menores de 18","De 18 a 45","De 45 a 65","Mas de 65"))
Veamos ahora cómo realizar un gráfico de barras un poco más complejo.
> #Representamos un diagrama de barras con tres variables
> barplot(height=cbind(c(4,9),c(8,2),c(3,7)),beside=TRUE,width=c(45,50,35),
col=c(1,2),legend.text=c("hombre","mujer"))

4.4.2. Función pie

Los diagramas de sectores para datos cualitativos los creamos con la funcion pie. Por
ejemplo, un diagrama básico serı́a:
> #Diagrama de sectores simple
> 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")
Lo vamos a complicar mı́nimamente para mejorar la visualizacion de los datos que pro-
porciona el gráfico.
> #Diagrama de sectores con porcentajes
> muestra=c(15,12,4,16,8)
> paises=c("USA","Inglaterra","Australia","Alemania","Francia")
> pct=round(muestra/sum(muestra)*100)
> #Juntamos porcentajes y etiquetas
> paises=paste(paises,pct)
> #Juntamos % y etiquetas
> paises=paste(paises,"%",sep="")
> pie(muestra,labels=paises,col=rainbow(length(paises)),main="Diagrama de sectores
de paı́ses")
También podemos crear gráficos en 3-dimensiones, para ello tenemos que servirnos del
paquete “plotrix”.
4.4. GRÁFICOS ESTADÍSTICOS 59

> #Diagrama de sectores 3D

> #Necesitamos el paquete plotris
> install.packages("plotrix")
> escanos=c(125,120,4,16,8)
> partidos=c("P1","P2","P3","P4","P5")
> pie3D(escanos,labels=partidos,explode=0.1,main="Elecciones Nacionales Ficticias")

4.4.3. Función hist

Los histogramas para variables continuas los representamos con la función hist. R asig-
na el número de intervalos y la amplitud de ellos. Si queremos modificarlos utilizamos los
argumentos breaks que indican los puntos de corte junto con otros argumentos para darles
efectos visuales.
> #Representamos un histograma de la variable x, con x 1000 datos normales
> x=rnorm(1000)
> hist(x)
> #Creamos 13 intervalos (12 puntos de corte), de color azul y lineas rosas
> hist(x,freq=FALSE,breaks=12,col="lightblue",border="pink")
> #Creamos 4 intervalos (3 puntos de corte), de color azul y lineas rosas
> hist(x,freq=FALSE,breaks=3,col="red",border="green")
Podemos dibujar el histograma junto con gráfica de densidad normal.
> x=rnorm(1000)
> hist(x,col="red",freq=F,xlim=c(-5,5))
> curve(dnorm(x),-5,5,add=T,col="blue")

4.4.4. Función boxplot

Con la función boxplot se puede crear un diagrama de cajas para una o varias variables.
Como ejemplo vamos a utilizar un conjunto de datos: mtcars.
> help(mtcars)
Vemos que la base de datos cuenta con 11 variables. Imaginemos que nos interesa úni-
camente la variable mpg (millas recorridas por galón de combustible). Vamos a realizar un
boxplot de esta variable:
> #Sin desconectar los datos de la base de datos
> boxplot(mpg,data=mtcars)
> #Desconecto los datos de la base de datos para llamar directamente a las variables
> attach(mtcars)
> boxplot(mpg)
> detach(mtcars)
60 CAPÍTULO 4. OPCIONES GRÁFICAS

Si nos fijamos, hay una variable numérica en la base de datos que es cyl y que discrimina
entre aquellos coches con 4, 6 u 8 cilindros. Con las siguientes intrucciones veremos cómo
realizar un boxplot en función de los valores que toma cyl.

> #Sin desconectar los datos de la base de datos

> boxplot(mpg~cyl,data=mtcars)
> #Desconectando los datos de la base de datos
> #para poder nombrar directamente a las variables
> attach(mtcars)
> boxplot(mpg~cyl)
> detach(mtcars)

Podemos usar los distintos argumentos de boxplot para que éste sea más vistoso y fácil
de interpretar.

> boxplot(mpg~cyl,data=mtcars,main="Km",xlab="Cilindros",ylab="Km por litro")

> boxplot(mpg~cyl,data=mtcars,main="Km",xlab="Cilindros",ylab="Km por litro",
col=(c("gold","darkgreen")))

4.4.5. Función pairs

Esta función permite crear una matriz de diagramas de puntos entre dos o más variables.

> x=1:20
> y=rnorm(20)
> z=y^3
> pairs(cbind(x,y,z))
> pairs(~x+y+z)
Bibliografı́a

[1] Arriaza A. J., Fernandez F. y otros (2008), Estadı́stica Básica con R y R-Commander,
Servicio de Publicaciones de la Universidad de Cádiz.

[2] Cortreras J. M., Molina E. y Arteaga P. (2010), Introducción a la programación estadı́sti-

ca con R para profesores. Departamento de didáctica de la matemática. Universidad de
Granada.

[3] Crawley M.J. (2007), The R Book, Hardcover.

[4] Everitt, Brian S. (2005). An R and S-Plus Companion to Multivariate Analysis. Springer.

[5] Faraway, J. (2004). Linear Models with R. Chapman Hall/CRC, Boca Raton, FL.

[6] Febrero, M., Galeano, P., González J. y Pateiro B. (2008). Prácticas de Estadı́stica en R
Ingenierı́a Técnica en Informática de Sistemas.

[7] González A. y González S. (2000), Introducción a R: Notas sobre R: Un entorno de

programación para Análisis de Datos y Gráficos, R Development Core Team.

[8] Navarro, H. y Maı́n, P. Iniciacióna R, http://www.mat.ucm.es/ palomam/paloframe.htm

[9] Paradis E. (2002), R para Principiantes, Institut des Sciences de l’Evolution Universit
Montpellier II.

[10] Quick-R; http://www.statmethods.net/

[11] R bloggers; http://www.r-bloggers.com/

[12] Venables W. N. y Ripley B. D. (2002), Modern Applied Statistics with S.

[13] Verzani, J. (2005). Using R for Introductory Statistics. Chapman Hall/CRC, Boca
Raton, FL.

61