R para Novatos

para novatos
Notas escritas por uno de ellos

Noviembre de 2009

I – INTRODUCCIÓN

R es un programa y un lenguaje de programación, creado en el año 1996 por Ross Ihaka y Robert
Gentleman para realizar análisis estadísticos y construir gráficos.
R tiene tres características básicas en lo que a lenguaje se refiere: es interpretado (los comandos son
ejecutados directamente), orientado a objetos (los objetos que usa R se guardan en la memoria activa
del computador) y tiene una sintaxis simple e intuitiva.

II – LOS OBJETOS DE R

Cada objeto de R tiene un nombre y dos atributos intrínsecos.
El nombre de un objeto debe comenzar con una letra y puede incluir letras, dígitos (del 0 al 9) y puntos;
importa tener en cuenta que R discrimina entre letras mayúsculas y minúsculas.
Los dos atributos intrínsecos a un objeto son su tipo y su longitud:
- El tipo de un objeto se refiere a las características de sus elementos.
Hay cuatro tipos principales: numérico (números reales), carácter, complejo (números complejos) y
lógico (FALSE o TRUE).
- La longitud de un objeto es el número de sus elementos.

En la tabla que sigue presentamos algunos objetos usados por R y para cada uno de ellos indicamos los
tipos que puede tener y la posibilidad o no de la existencia simultánea de más de un tipo.

Tipo ¿Es posible la coexistencia de más de
Objeto N C Co L un tipo?
Vector Sí Sí Sí Sí No
Factor Sí Sí No No No
Matriz Sí Sí Sí Sí No
Arreglo Sí Sí Sí Sí No
Lista Sí Sí Sí Sí Si
Hoja de datos Sí Sí Sí Sí Sí
Serie de tiempo Sí Sí Sí Sí Sí
Tipo: N (numérico), C (carácter), Co (complejo), L (lógico).

Para listar o eliminar objetos son útiles las funciones de la próxima tabla.

Función Resultado
ls( ) Lista los objetos en memoria.
ls(pat=”...”) Lista los objetos en memoria cuyo nombre tiene el carácter indicado en ...
ls(pat=”^...”) Lista los objetos en memoria cuyo nombre comienza con el carácter indicado
en ...
ls.str( ) Muestra todos los detalles de cada uno de los objetos en memoria.
ls.str(max.level=‐1) Muestra algunos detalles de cada uno de los objetos en memoria.
rm(...,...) Elimina de la memoria los objetos indicados en ...
rm(list=ls( )) Elimina de la memoria todos los objetos.

A continuación nos ocuparemos de los objetos, indicando no sólo cómo crearlos sino también cómo
incorporar datos a ellos.

A – Vector

Creación de un vector

La palabra vector se usa en R con su significado habitual en matemática.
Para crear un vector se usa la orden vector(mode=”...”,length=...), donde mode es el tipo del vector
(numeric, character, complex, logical) y length su longitud. Esa orden puede abreviarse así:
vector(“...”,...).
Jorge Moretti, R para novatos
2
Por ejemplo:
- Para crear un vector numérico de longitud 10 con nombre x escribimos
x=vector(”numeric”,10)
Esa orden motiva que R cree el vector x y le asigne el número 0 a cada uno de sus diez elementos.
También podemos escribir
x <‐ vector(“numeric”,10)
vector(“numeric”,10) ‐> x
- Para crear otro vector y con las mismas características que x escribimos
y=x
- Para crear un vector de caracteres de longitud 4 con nombre z escribimos
z=vector(”character”,4)
Así obtenemos un vector z al que R le ha asignado un espacio en blanco a cada uno de sus cuatro
elementos.
- Para crear un vector lógico de longitud 3 con nombre u escribimos
u=vector(”logical”,3)
Ahora tenemos un vector u al que R le ha asignado FALSE a cada uno de sus tres elementos.

Incorporación de datos a un vector

En lo que sigue veremos distintas formas de completar con datos vectores numéricos (casi todas esas
formas crean el vector y simultáneamente lo completan con datos) e indicaremos cuáles de ellas
pueden usarse para vectores con caracteres (los caracteres deben escribirse entre comillas; para que la
comilla sea parte de los caracteres debe estar precedida por \).

♣ Uso de for (válido para caracteres aunque no muy útil)
Supongamos que deseamos completar el vector x que recién definimos con los números 1, 1/2, 1/3, ...,
1/10; podemos lograrlo con la orden: “Para cada número entre 1 y 10 coloque en el respectivo lugar de
x el inverso del número”.
for (i in 1:10) x[i]=1/i
El símbolo x[i] identifica al elemento de x que está en el lugar i.
Las siguientes dos órdenes (redactadas en un renglón y separadas por ;) completan el vector y con los
números 1, 4, 9, 16, 25, 37, 50, 65, 82, 101.
for (i in 1:5) y[i]=i^2 ; for (i in 6:10) y[i]=i^2+1

♣ Uso de data.entry
Para completar un vector w que ya hemos creado (o para cambiar o ampliar su contenido) podemos
usar la orden data.entry(w), la cual motiva que R nos proporcione un editor para nuestro trabajo, similar
a una hoja de cálculo.

♣ Uso de scan (válido para caracteres)
La orden
a=scan(what=”numeric”)
crea un vector a cuyos elementos son los números que vamos digitando en el espacio que R nos
suministra.

♣ Uso de c (válido para caracteres)
La orden
b=c(2,5,3,7,9)
crea un vector b cuyos elementos son los números 2, 5, 3, 7 y 9.

♣ Uso de a:b (números enteros)
La orden
c=3:8
crea un vector c cuyos elementos son los números 3, 4, 5, 6, 7 y 8.
La orden
d=8:3
crea un vector d cuyos elementos son los números 8, 7, 6, 5, 4 y 3.

3
♣ Uso de seq
La orden
e=seq(from=2,to=5,by=0.5)
crea un vector e cuyos elementos son los números 2, 2.5, 3, 3.5, 4, 4.5 y 5.
Esa orden puede abreviarse así:
e=seq(2,5,0.5)
Las siguientes dos órdenes crean el mismo vector e
e=seq(from=2,to=5,length=7)
e=seq(2,5,length=7)

♣ Uso de sequence (números mayores o iguales que 1)
La orden
f=sequence(4.5)
crea un vector f cuyos elementos son los números 1, 2, 3 y 4 (desde 1 hasta la parte entera de 4,5).

♣ Uso de rep (válido para caracteres)
La orden
g=rep(x=1,times=4)
crea un vector g cuyos elementos son los números 1, 1, 1 y 1.
Esa orden puede abreviarse así:
g=rep(1,4)

♣ Uso de funciones de densidad o cuantía (vectores aleatorios)
La orden
h=rnorm(5,mean=0,sd=1)
crea un vector h cuyos cinco elementos son datos aleatorios de la normal de media 0 y varianza 1.
La orden
i=rbinom(7,size=20,prob=0.3)
crea un vector i cuyos siete elementos son datos aleatorios de la binomial de parámetros 20 y 0.3.
En la página 16 del libro “R para principiantes, Emmanuel Paradis” hay una tabla con varias
distribuciones (discretas y absolutamente continuas).

Algunos números asociados a vectores numéricos

A partir de uno o dos vectores numéricos podemos calcular números usando funciones estadísticas.
En la próxima tabla, donde x e y son vectores numéricos, detallamos algunas de esas funciones.

Función Resultado
sum(x) Suma de los elementos de x.
prod(x) Producto de los elementos de x.
max(x) Valor máximo en x.
min(x) Valor mínimo en x.
which.max(x) Primer índice del máximo en x.
which.min(x) Primer índice del mínimo en x.
range(x) Rango de x.
length(x) Longitud de x.
mean(x) Promedio de los elementos de x.
median(x) Mediana de los elementos de x (*).
var(x) Cuasi varianza de los elementos de x.
cov(x,y) Cuasi covarianza entre x e y.
cor(x,y) Coeficiente de correlación lineal entre x e y.
(*) R ordena los elementos de x en forma creciente y toma como mediana el elemento central cuando la
longitud de x es impar o el promedio de los dos elementos centrales cuando la longitud de x es par.

4
Creación de vectores a partir de uno o más vectores

♣ Uso de for e if o de ifelse (válido para caracteres aunque no muy útil)
Supongamos que a partir del vector x cuyos elementos son los números 1, 1/2, 1/3, ..., 1/10, queremos
formar otro vector x1 que coincida con x en los lugares donde los elementos de x son menores que 1/4 y
que en los restantes lugares esté el número 0. Eso podemos lograrlo así:
x1=x
for (i in 1:10) if (x[i]<1/4) x1[i]=x[i] else x1[i]=0
Obtenemos el mismo resultado anterior con la orden
x1=ifelse(x<1/4,x,0)

♣ Uso de c (válido para caracteres)
Sean v y w vectores.
La orden
t=c(v,w)
crea un vector t cuyas primeras componentes son las de v y las restantes las de w.

♣ Uso de sequence (números mayores o iguales que 1)
Sea v un vector cuyos elementos son números mayores o iguales que 1.
La orden
t=sequence(v)
crea el mismo vector t que la orden t=c(sequence(v[1]),sequence(v[2]), ...).
Por ejemplo:
La orden
t1=sequence(c(2.5,4))
crea un vector t1 cuyos elementos son los números 1, 2, 1, 2, 3 y 4.
La orden
t2=sequence(c(4,2.5))
crea un vector t2 cuyos elementos son los números 1, 2, 3, 4, 1 y 2.
La orden
t3=sequence(2:4)
crea un vector t3 cuyos elementos son los números 1, 2, 1, 2, 3, 1, 2, 3 y 4.
La orden
t4=sequence(4:2)
crea un vector t4 cuyos elementos son los números 1, 2, 3, 4, 1, 2, 3, 1 y 2.

♣ Uso de rep (válido para caracteres)
Sea v un vector.
La orden
t1=rep(v,times=3)
crea un vector t1 repitiendo tres veces el vector v.
La orden
t2=rep(v,each=2)
crea un vector t2 repitiendo dos veces el primer elemento de t, luego dos veces el segundo elemento de
t y así sucesivamente.
Sean v y w vectores de igual longitud, donde los elementos de w son naturales positivos.
La orden
t3=rep(v,times=w)
crea un vector t3 repitiendo el primer elemento de v tantas veces como lo indica el primer elemento de
w y así sucesivamente.

♣ Uso de vectores numéricos como índices (válido para caracteres)
Sean v y w vectores tales que los elementos de w son un arreglo sin repetición de los números 1, 2, 3, ...
l, donde l es la longitud de v. A w se le llama un vector numérico de índices (es claro que la longitud de w
es a lo sumo la de v).
La orden
t1=v[w]
crea un vector t1 seleccionando los elementos de v indicados por w.
Por ejemplo, si v = (2.5 , 3.8 , ‐5 , 7, 9.1) y w = (3 , 4 , 1) resulta que t1 = (‐5, 7 , 2.5).
5
La orden
t2=v[‐w]
crea un vector t2 quitándole al vector v los lugares que indica w.
Por ejemplo, si v = (2.5 , 3.8 , ‐5 , 7 , 9.1) y w = (3 , 4 , 1) resulta que t2 = (3.8 , 9.1).
Sea, además, z un vector del mismo tipo que v y de igual longitud que w.
La orden
v[w]=z
cambia los elementos de v que están en los lugares que indica w por los respectivos elementos de z.
Por ejemplo, si v = (2.5 , 3.8 , ‐5 , 7, 9.1), w = (3 , 4 , 1) y z = (0 , 1.2 , 8.1) llegamos a que v queda de la
siguiente manera: v = (8.1 , 3.8 , 0 , 1.2 , 9.1).
Sean ahora v y w vectores tales que los elementos de w son l+1, l+2, ..., l+k (l es la longitud de v) y z un
vector del mismo tipo que v y de igual longitud que w. Este w también es un vector numérico de índices
(con longitud k).
La orden
v[w]=z
agrega los elementos de z a v en los respectivos lugares que indica w.
Por ejemplo, si v = (2.5 , 3.8 , ‐5 , 7, 9.1), w = (6 , 7 , 8) y z = (0 , 1.2 , 8.1) llegamos a que v queda de la
siguiente manera: v = (2.5 , 3.8 , ‐5 , 7, 9.1 , 0 , 1.2 , 8.1) .

♣ Uso de vectores lógicos como índices (válido para caracteres)
Sean v y w vectores de igual longitud tales que los elementos de w son un arreglo con repetición de las
palabras FALSE y TRUE. A w se le llama un vector lógico de índices.
La orden
t1=v[w]
crea un vector t1 tomando del vector v los lugares donde aparece TRUE en w.
Por ejemplo, si v = (2 , 5 , 0 , 9 , 8) y w = (FALSE , TRUE, TRUE , FALSE , TRUE) resulta que t1 = (5, 0 , 8).
Importa que notemos que si definimos w = (FALSE , TRUE) obtenemos t1 = (5 , 9) pues R recicló nuestro
w así: (FALSE , TRUE, FALSE , TRUE , FALSE).
Sea, además, z un vector del mismo tipo que v y con longitud el número de TRUE en w.
La orden
v[w]=z
cambia los elementos de v que están en los lugares donde aparece TRUE en w por los respectivos
elementos de z.
Por ejemplo, si v = (2 , 5 , 0 , 9 , 8), w = (FALSE , TRUE, TRUE , FALSE , TRUE) y z = (1 , 7 , 6) llegamos a
que v queda así: v = (2 , 1 , 7 , 9 , 6).

♣ Uso de expresiones comparativas para construir vectores lógicos
Las expresiones comparativas son las que usan operadores comparativos y a veces operadores lógicos.
En la próxima tabla listamos dichos operadores.

Operadores comparativos Operadores lógicos
< Menor que ! No lógico
> Mayor que & Y lógico
<= Menor o igual que && Y lógico
>= Mayor o igual que ⏐ O lógico
== Igual ⏐⏐ O lógico
!= Diferente de
Los operadores comparativos actúan sobre dos El primer operador comparativo (!) actúa sobre un
vectores de igual tipo y devuelven uno o varios vector lógico y los restantes sobre dos y todos
valores lógicos. La comparación se realiza devuelven uno o varios valores lógicos.
elemento a elemento (R recicla el de menor & y ⏐ actúan sobre cada elemento.
longitud si es necesario). && y ⏐⏐ actúan sobre el primer elemento.

Supongamos que x = (1 , 2 , 3 , ‐1) e y = (1 , ‐3 , 2 , 4).
La orden
z1=x<y
crea el vector z1=(FALSE , FALSE , FALSE , TRUE).
6
La orden
z2=x>y
crea el vector z2=(FALSE , TRUE , TRUE , FALSE).
La orden
z3=x==y
crea el vector z1=(TRUE , FALSE , FALSE , FALSE).
La orden
z4=x>0&y>=2
crea el vector z4=(FALSE , FALSE , TRUE , FALSE).
La orden
z5=x>0&&y>=2
crea el vector z5=(FALSE).
La orden
z6=x>0⏐y>=2
crea el vector z6=(TRUE , TRUE , TRUE , TRUE).
La orden
z7=(x>0⏐y>=2)&!(x>0&y>=2)
crea el vector z7=(TRUE , TRUE , FALSE , TRUE).

Es claro que podemos componer lo que acabamos de ver con el uso de vectores lógicos como índices
para construir vectores. Por ejemplo, en relación con los vectores x e y con los que recién trabajamos:
La orden
x1=x[x>0]
crea el vector x1=(1 , 2 , 3).
La orden
xy=c(x[x>0],y[y>=2])
crea el vector xy=(1 , 2 , 3 , 2 , 4).

♣ Uso de operadores aritméticos
Operadores aritméticos
Los operadores aritméticos actúan sobre dos vectores de igual + Adición
longitud (R recicla el de menor longitud si es necesario). Cada ‐ Substracción
uno de esos vectores puede ser numérico, complejo o lógico (R * Multiplicación
transforma los vectores lógicos en numéricos asignando el / División
número 0 a FALSE y el 1 a TRUE). ^ Potencia
La operación se realiza elemento a elemento. %/% Cociente de la división entera
%% Resto de la división entera

Con esos operadores podemos construir nuevos vectores a partir de vectores conocidos.
Por ejemplo, si x = (1 , 2 , 3 , ‐1) e y = (1 , ‐3 , 2 , 4) tenemos que:
(x+y)^2‐3*y= (1 , 10 , 19 , ‐3).
x%/%y= (1 , ‐1 , 1 , ‐1) ; x%%y= (0 , ‐1 , 1 , 3).
y%/%x= (1 , ‐2 , 0 , ‐4) ; y%%x= (0 , 1 , 2 , 0).

♣ Uso de funciones estadísticas
A partir de uno o dos vectores numéricos podemos calcular otros usando funciones estadísticas
(también podemos usar funciones reales de una variable real: valor absoluto, parte entera, signo, raíz
cuadrada, exponencial, logarítmica, trigonométricas, hiperbólicas, funciones de densidad, de cuantía o
de distribución).
En la próxima tabla detallamos algunas funciones estadísticas (x e y son vectores numéricos).

7
Función Resultado
cumsum(x) Vector en el que el elemento en el lugar i es la suma desde x[1] a x[i].
cumprod(x) Vector en el que el elemento en el lugar i es el producto desde x[1] a x[i].
cummax(x) Vector en el que el elemento en el lugar i es el máximo desde x[1] a x[i].
cummin(x) Vector en el que el elemento en el lugar i es el mínimo desde x[1] a x[i].
which(x...) Vector con los lugares de x donde la expresión comparativa x... vale TRUE.
round(x,n) Redondea los elementos de x a n cifras decimales.
rev(x) Invierte el orden de los elementos de x.
sort(x) Ordena los elementos de x en forma ascendente.
sample(x,size) Muestra aleatoria simple de tamaño size de los elementos de x.
sample(x,size,replace=TRUE) Muestra aleatoria con reposición de tamaño size de los elementos de x.
unique(x) Vector en el que se suprimieron los elementos repetidos de x.
na.omit(x) Elimina los lugares de x con datos ausentes (NA).
pmin(x,y) (*) Vector en el que el elemento en el lugar i es el mínimo de x[i] e y[i].
pmax(x,y) (*) Vector en el que el elemento en el lugar i es el mínimo de x[i] e y[i].
match(x,y) Vector en el que el iésimo elemento es el lugar en que está en y el iésimo
elemento de x o NA si ese iésimo elemento de x no está en y.
(*) Pueden ser más de dos vectores.
Por ejemplo, si x = (1 , 2 , 3 , ‐1) e y = (1 , ‐3 , 2 , 4) tenemos que:
cumsum(x)= (1 , 3 , 6 , 5).
cummin(y)= (1 , ‐3 , ‐3 , ‐3).
which(y>1)= (3 , 4).
sample(x,3)= (2 , ‐1 , 3) ; este resultado es aleatorio.
sample(y,7,replace=TRUE)= (4 , 1 , 4 , ‐3 , 1 , 1 , 1); este resultado es aleatorio.
pmin(x,y)=(1 , ‐3 , 2 , ‐1).
match(x,y)=(1 , 3 , NA , NA).
na.omit(match(x,y))=(1 , 3).

♣ Uso de paste
Sean u, v, ... objetos de R de igual longitud.
La orden
t=paste(u,v,...,sep=”c”)
crea un vector t de caracteres cuyo primer elemento es la unión de los primeros elementos de u, v, ...
(previamente convertidos a caracteres) separados por la cadena de caracteres especificada en c (si no se
usa esta opción R toma como c un espacio en blanco) y así sucesivamente.
Por ejemplo:
Si u=c(5,7) y v=(“a”,”b”) resulta que t=paste(u,v.sep=”.”) tiene como elementos “5.a” y “7.b”.
Si u=c(5,7) resulta que t=paste(“El primer número es”,c[1],”y el segundo”,c[2]) tiene como único
elemento la frase “El primer número es 5 y el segundo 7”.
Si u=c(5,7) y v=(“a”) resulta que t=paste(u,v.sep=”.”) tiene como elementos “5.a” y “7.a” (R se encargó
de que u y v tuvieran la misma longitud).

B – Factor

Creación de un factor

La palabra factor se usa en R para referirse a un vector (numérico o de caracteres) que se usa con el fin
de especificar una clasificación de los elementos de otro vector de igual longitud.
Para crear un factor se usa la orden factor(x,levels=y,labels=z,exclude=u), donde:
- x es un vector.
- y es un vector opcional con los posibles valores que x puede tomar, a los que se les llama niveles o
clases. Si no se usa esta opción, R toma como y el vector con los valores distintos de x ordenados en
forma creciente.
- z es un vector opcional con los nombres respectivos a cada valor de y o con un carácter. Si no se usa
esta opción, R toma como z el vector y.
- u es un vector opcional con los valores de y que R excluirá al construir el factor. Si no se usa esta
opción, R tomará todos los valores de y.

8
Incorporación de datos a un factor

Veremos dos formas de completar con datos un factor (la segunda crea el factor y simultáneamente lo
completa con datos).

♣ Uso de factor(x,levels=y,labels=z,exclude=u)
Al usar esta orden, cada elemento del factor es el nombre del correspondiente elemento de x (si tal
nombre no existiera, R pondrá allí NA).
Supongamos, por ejemplo, que deseamos clasificar los elementos del vector a = (7 , 6 , 14 , 20 , 22 , 8)
según el resto de dividirlos entre 3.
La orden
x=a%%3
crea el vector x=( 1 , 0 , 2 , 2 , 1 , 2) que es el vector de los restos que nos interesan.
La orden
z1=factor(x,levels=c(0,1,2),labels=c(“Resto 0”,”Resto 1”,”Resto 2”))
crea el vector z1=(Resto 1 , Resto 0 , Resto 2 , Resto 2 , Resto 1 , Resto 2).
La orden
z2=factor(x,levels=c(0,1,2),labels=”j“)
crea el vector z2=(j2 , j1 , j3 , j3 , j2 , j3).
La orden
z3=factor(x,levels=c(0,1),labels=c(“Resto 0”,”Resto 1”))
crea el vector z3=(Resto 1 , Resto 0 , <NA> , <NA> , Resto 1 , <NA>).
A continuación mostramos una aplicación interesante del ejemplo que acabamos de dar.
Ya sabemos cómo calcular la media y la cuasi varianza del vector a; si nos interesan esos cálculos en
cada una de las tres clases que hemos definido, podemos utilizar el factor z1 así:
♦ tapply(a,z1,mean) nos da la siguiente información:
Resto 0 Resto 1 Resto 2
6 14.5 14
♦ tapply(a,z1,var) nos da la siguiente información:
Resto 0 Resto 1 Resto 2
NA 112.5 36
El NA correspondiente a Resto 0 se debe a que hay sólo un elemento de a en esa clase.

♣ Uso de gl
La función gl (generador de niveles) tiene la forma gl(k,n,lenght=l,labels=z), donde:
- k es el número de niveles o clases.
- n es el número de réplicas de cada nivel.
- l es un número opcional de datos a producir. Si no se usa esta opción, R toma l =k.n.
- z es un vector opcional con los nombres respectivos de cada nivel o con un carácter. Si no se usa
esta opción, R toma como z el vector de elementos 1, 2, ..., k.
A continuación presentamos un par de ejemplos sobre esta forma de construir factores.
La orden
x1=gl(2,3,labels=c(“Hombre”,”Mujer”))
crea el vector x1=(Hombre , Hombre , Hombre , Mujer , Mujer , Mujer).
La orden
x2=gl(3,1,lenght=6,labels=”a”)
crea el vector x2=(a1 , a2 , a3 , a1 , a2 , a3).

C – Matriz

Creación de una matriz

La palabra matriz se usa en R con su significado habitual en matemática.
Se crea una matriz con la orden matrix(mode=”...”,data=x,nrow=m,ncol=n,byrow=p,dimnames=list(u,v)),
donde:
- “...” es el tipo de matriz (ver creación de un vector).
- x es un vector opcional. Si no se usa esta opción, R completa cada uno de los casilleros de la matriz
atento al tipo de matriz.
- m es el número de filas de la matriz y n el de sus columnas.
9
- p es FALSE o TRUE; en el caso de FALSE la matriz se llena por columnas y en el caso de TRUE, por
filas. Si no se usa esta opción, R toma p=FALSE.
- u y v son vectores opcionales de longitudes m y n con los nombres de las filas y las columnas
respectivamente. Si no se usa esta opción, R le asigna los nombres [1, ], ..., [m, ] a las filas y [ ,1], ...,
[ ,n] a las columnas.

Incorporación de datos a una matriz

A continuación veremos distintas formas de completar con datos una matriz (casi todas esas formas
crean la matriz y simultáneamente la completan con datos).

♣ Uso de data.entry
Para completar una matriz X que ya hemos creado (o para cambiar su contenido o ampliar cada una de
sus columnas) podemos usar la orden data.entry(X), con la cual obtenemos un editor para nuestro
trabajo.

♣ Uso de for
Supongamos que hemos definido la matriz U así:
U=matrix(nrow=3,ncol=2,dimnames=list(c(“F1”,”F2”,”F3”),c(“C1”,”C2”)))
Deseamos completar esa matriz U con el siguiente criterio: “En cada casillero colocamos la suma del
número de la fila y del número de la columna correspondientes al casillero”. Eso podemos lograrlo con
la orden
for (i in 1:3) for (j in 1:2) U[i,j]=i+j
El símbolo U[i,j] identifica al elemento de U que está en la fila i y en la columna j.
Con esa orden obtenemos la siguiente matriz U:
C1 C2
F1 2 3
F2 3 4
F3 4 5

♣ Uso de matrix(data=x,nrow=m,ncol=n,byrow=p,dimnames=list(u,v))
Supongamos que tenemos el siguiente vector de longitud 12: x=(2 , 4 , 5 , 7 , 8 , 1 , 3 , 1 , 6 , 9 , 2, 4).
La orden
V1=matrix(data=x,nrow=3,ncol=4,byrow=TRUE)
crea la siguiente matriz V1:
[ ,1] [ ,2] [ ,3] [ ,4]
[1, ] 2 4 5 7
[2, ] 8 1 3 1
[3, ] 6 9 2 4
La orden
V2=matrix(data=x^2,nrow=4,ncol=3)
crea la siguiente matriz V2:
[ ,1] [ ,2] [ ,3]
[1, ] 4 64 36
[2, ] 16 1 81
[3, ] 25 9 4
[4, ] 49 1 16

♣ Uso de dim
Aquí la idea es ver una matriz como un vector con un atributo adicional (dim) definido por otro vector
numérico de longitud 2 que indica el número de filas y el de columnas de la matriz.
Si nuevamente x=(2 , 4 , 5 , 7 , 8 , 1 , 3 , 1 , 6 , 9 , 2, 4), la orden
dim(x)=c(3,4)
transforman el vector x en la siguiente matriz x con tres filas y cuatro columnas:
[ ,1] [ ,2] [ ,3] [ ,4]
[1, ] 2 7 3 9
[2, ] 4 8 1 2
[3, ] 5 1 6 4

10
♣ Uso de cbind o rbind
Sean los vectores x1=(2 , 1 , 3) y x2=(5 , 9 , 8).
La orden
X=cbind(x1,x2)
crea la siguiente matriz X con tres filas y dos columnas:
x1 x2
[1, ] 2 5
[2, ] 1 9
[3, ] 3 8
Ese resultado también podemos obtenerlo así (con nombres [ ,1] y [ ,2] en vez de x1 y x2):
X=matrix(nrow=3,ncol=2) ; X[ ,1]=x1 ; X[ ,2]=x2
Los símbolos X[ ,1] y X[ ,2] identifican a la primera y a la segunda columna de X.
La orden
Y=rbind(x1,x2)
crea la siguiente matriz Y con dos filas y tres columnas:
[ ,1] [ ,2] [ ,3]
x1 2 1 3
x2 5 9 8

♣ Uso de diag
La función diag tiene distintos usos. Uno de ellos es la creación de matrices diagonales y en ese sentido
tiene la forma diag(x,nrow=m,ncol=n), donde:
- x es un vector.
- m es el número de filas de la matriz. Si no se usa esta opción, R toma como m la longitud de x.
- n es el número de columnas de la matriz. Si no se usa esta opción, R toma como n la longitud de x.
Veamos tres ejemplos sobre esta forma de construir matrices diagonales, eligiendo x= (8, 7 , 9).
La orden
D1=diag(x)
crea la siguiente matriz D1 con tres filas y tres columnas (al ser cuadrada podemos omitir m y n):
[ ,1] [ ,2] [ ,3]
[1, ] 8 0 0
[2, ] 0 7 0
[3, ] 0 0 9
La orden
D2=diag(x,nrow=3,ncol=4)
crea la siguiente matriz D2 con tres filas y cuatro columnas:
[ ,1] [ ,2] [ ,3] [ ,4]
[1, ] 8 0 0 0
[2, ] 0 7 0 0
[3, ] 0 0 9 0
La orden
D3=diag(x,nrow=4,ncol=3)
crea la siguiente matriz D3 con cuatro filas y tres columnas:
[ ,1] [ ,2] [ ,3]
[1, ] 8 0 0
[2, ] 0 7 0
[3, ] 0 0 9
[4, ] 0 0 0

Algunos números asociados a matrices numéricas

A partir de una matriz numérica podemos calcular números usando ciertas funciones.
En la próxima tabla, donde X es una matriz numérica, detallamos algunas de esas funciones (casi todas
son análogas a las que ya conocemos para vectores numéricos).

11
Función Resultado
sum(X) Suma de los elementos de X.
prod(X) Producto de los elementos de X.
max(X) Valor máximo en X.
min(X) Valor mínimo en X.
which.max(X) Primer casillero del máximo en X (*).
which.min(X) Primer casillero del mínimo en X (*).
range(X) Rango de X.
length(X) Longitud de X.
mean(X) Promedio de los elementos de X.
median(X) Mediana de los elementos de X.
det(X) Determinante de X.
sum(diag(X)) Traza de X.
eigen(X,only.values=TRUE) Valores propios de X.
(*) R usa la matriz X de m filas y n columnas como un vector de longitud m.n, poniendo cada columna a
continuación de la anterior. Los primeros índices correspondientes al máximo y al mínimo de ese vector
determinan unívocamente los respectivos casilleros de la matriz X.

Creación de matrices a partir de una o más matrices

♣ Uso de for e if o ifelse
Supongamos que a partir de la matriz X, de cinco filas y tres columnas, queremos formar otra matriz X1
que coincida con X en los casilleros donde los elementos de X son positivos y que en los restantes
casilleros esté el número 0. Eso podemos lograrlo así:
X1=X
for (i in 1:5) for (j in 1:3) if (X[i,j]>0) X1[i,j]=X[i,j] else X1[i,j]=0
Obtenemos el mismo resultado anterior con la orden
X1=ifelse(X>0,X,0)

♣ Uso de cbind o rbind
Sean X e Y matrices con el mismo número de filas.
La orden
A=cbind(X,Y)
crea una matriz A, agregando a la derecha de la matriz X la matriz Y.
Sean Y y Z matrices con el mismo número de columnas.
La orden
B=rbind(Y,Z)
,crea una matriz B, agregando debajo de la matriz Y la matriz Z.
⎛ 1 2 3⎞
⎛2 3⎞ ⎛7 8 1⎞ ⎜ ⎟ ⎛2 3 7 8 1⎞
Por ejemplo, si X = ⎜⎜ ⎟⎟ , Y = ⎜⎜ ⎟⎟ y Z = ⎜ 4 5 6 ⎟ resulta que A = ⎜⎜ ⎟⎟ y
⎝ 1 4 ⎠ ⎝ 5 9 3 ⎠ ⎜7 8 9⎟ ⎝1 4 5 9 3⎠
⎝ ⎠
⎛7 8 1⎞
⎜ ⎟
⎜5 9 3⎟
B = ⎜1 2 3 ⎟ .
⎜ ⎟
⎜4 5 6⎟
⎜ ⎟
⎝7 8 9⎠
Es interesante que notemos que la matriz A también puede obtenerse con la orden
A=matrix(data=c(X,Y),nrow=2,ncol=5)
donde c(X,Y) es el vector que R obtiene al poner las columnas de X e Y una a continuación de la otra.
Asimismo, la matriz B es el resultado de la orden
B=t(cbind(t(Y),t(Z)))
donde t(U) es la matriz traspuesta de U.
12
♣ Uso de diag
Sea X una matriz.
La orden
v=diag(X)
crea un vector v cuyos elementos son los de la diagonal de X.
La orden
Y=diag(diag(X))
crea una matriz diagonal Y cuya diagonal es la de X.

♣ Uso de vectores numéricos como índices
Sean X una matriz de m filas y n columnas, f un vector tal que sus elementos son un arreglo sin
repetición de los números 1, 2, 3, ... m y c un vector tal que sus elementos son un arreglo sin repetición
de los números 1, 2, 3, ... n.
La orden
X1=X[f,c]
crea una matriz X1 seleccionando las filas y las columnas de X indicadas por f y c.
La orden
X2=X[f, ]
crea una matriz X1 seleccionando las filas de X indicadas por f.
La orden
X3=X[ ,c]
crea una matriz X3 seleccionando las columnas de X indicadas por c.
⎛ 1 5 9 13 ⎞
⎜ ⎟
⎜ 2 6 10 14 ⎟
Por ejemplo, si X = ⎜ , f = (2 , 4) y c = (3 , 2) resulta que
3 7 11 15 ⎟
⎜ ⎟
⎜ 4 8 12 16 ⎟
⎝ ⎠
⎛ 9 5⎞
⎜ ⎟
⎛ 10 6 ⎞ ⎛ 2 6 10 14 ⎞ ⎜ 10 6 ⎟
X1 = ⎜⎜ ⎟⎟ , X2 = ⎜⎜ ⎟⎟ y X3 = ⎜ .
⎝ 12 8 ⎠ ⎝ 4 8 12 16 ⎠ 11 7 ⎟
⎜ ⎟
⎜ 12 8 ⎟
⎝ ⎠
La orden
Y1=X[‐f,c]
crea una matriz Y1 quitando las filas de X indicadas por f y seleccionando las columnas de X indicadas
por c.
La orden
Y2=X[‐f, ]
crea una matriz Y2 quitando las filas de X indicadas por f.
⎛ 9 5⎞ ⎛ 1 5 9 13 ⎞
Con la matriz X y el vector f del ejemplo anterior tenemos que Y1 = ⎜⎜ ⎟⎟ e Y2 = ⎜⎜ ⎟⎟ .
⎝ 11 7 ⎠ ⎝ 3 7 11 15 ⎠
A esta altura creemos que es claro el significado de las órdenes X[f,‐c], X[ ,‐c], X[‐f,‐c].
Sea, además, z un vector del mismo tipo que X y con longitud igual al producto de las longitudes de f y c.
La orden
X[f,c]=z
cambia los elementos de X que están en los lugares indicados por f y c por los respectivos elementos de
z.
⎛1 5 9 13 ⎞
⎜ ⎟
⎜2 −2 0 14 ⎟
Si X, f y c son los del ejemplo y z = (0 , ‐1 , ‐2 , ‐3) llegamos a que X queda así: X = ⎜ .
3 7 11 15 ⎟
⎜ ⎟
⎜ 4 − 3 − 1 16 ⎟
⎝ ⎠

13
♣ Uso de vectores lógicos como índices
Sean X y W matrices de m filas y n columnas tales que W es una matriz lógica y z un vector del mismo
tipo que X y con longitud igual al número de TRUE en W.
La orden
X[W]=z
cambia los elementos de X que están en los lugares donde aparece TRUE en W por los respectivos
elementos de z.
⎛2 4 ⎞ ⎛ TRUE TRUE ⎞ ⎛1 7⎞
Por ejemplo, si X = ⎜⎜ ⎟⎟ , W = ⎜⎜ ⎟⎟ y z = (1 , 7 , 6) llegamos a X = ⎜⎜ ⎟⎟ .
⎝3 5⎠ ⎝ FALSE TRUE ⎠ ⎝3 6⎠

♣ Uso de expresiones comparativas para construir matrices lógicas
Podemos construir matrices lógicas usando expresiones comparativas, tal como lo hicimos en el caso de
los vectores.
⎛2 4 ⎞ ⎛ TRUE TRUE ⎞
Por ejemplo, si X = ⎜⎜ ⎟⎟ llegamos a W = ⎜⎜ ⎟⎟ con la orden W=X!=3.
⎝3 5⎠ ⎝ FALSE TRUE ⎠

♣ Uso de operadores aritméticos
Con los operadores aritméticos que vimos en el caso de vectores podemos construir ahora nuevas
matrices a partir de matrices conocidas. A esos operadores le agregamos %*% para el producto habitual
de matrices.
⎛1 2 ⎞ ⎛5 1⎞
Por ejemplo, si X = ⎜⎜ ⎟⎟ e Y = ⎜⎜ ⎟⎟ tenemos que
⎝ 3 4 ⎠ ⎝2 8⎠
⎛ 6 3⎞ ⎛ 5 2⎞ ⎛ 9 17 ⎞ ⎛ 8 14 ⎞
X + Y = ⎜⎜ ⎟⎟ ; X * Y = ⎜⎜ ⎟⎟ = Y * X ; X% * %Y = ⎜⎜ ⎟⎟ ≠ Y% * %X = ⎜⎜ ⎟⎟ .
⎝ 5 12 ⎠ ⎝ 6 32 ⎠ ⎝ 23 35 ⎠ ⎝ 26 36 ⎠

♣ Uso de funciones
A partir de una o dos matrices numéricas podemos calcular otras usando funciones.
En la próxima tabla detallamos algunas de esas funciones (X e Y son matrices numéricas).

Función Resultado
t(X) Matriz traspuesta de X.
solve(X) Matriz inversa de X.
eigen(X) Matriz con los vectores propios de X normalizados; además los valores
propios de X.
svd(X) Descomposición en valores singulares de X.
round(X,n) Redondea los elementos de X a n cifras decimales.
cov(X) Matriz de cuasi covarianzas entre las columnas de X.
cor(X) Matriz de coeficientes de correlación lineal entre las columnas de X.
pmin(X,Y) (*) Matriz donde en el lugar i,j está el mínimo de X[i,j] e Y[i,j].
pmax(X,Y) (*) Matriz donde en el lugar i,j está el máximo de X[i,j] e Y[i,j].
cov(X,Y) Matriz de cuasi covarianzas entre las columnas de X e Y.
cor(X,Y) Matriz de coeficientes de correlación lineal entre las columnas de X e Y.
(*) Pueden ser más de dos matrices.

D – Arreglo

Creación de un arreglo

La palabra arreglo se usa en R como una generalización del concepto de matriz.
Una matriz es un cuadro de doble entrada (filas por un lado y columnas por otro) cuyos elementos se
identifican por un par de índices (los valores de uno de esos índices sirven para identificar las filas de la
matriz y los del otro para sus columnas).
Un arreglo es un cuadro de múltiples entradas cuyos elementos se identifican por tantos índices como
entradas (los vectores y las matrices son casos particulares de los arreglos).
14
Se crea un arreglo con la orden array(data=x,dim=y,dimnames=list(u,v,...)), donde:
- x es un vector opcional. Si no se usa esta opción, R le asigna NA a cada uno de los casilleros del
arreglo.
- y es un vector cuya longitud es el número de entradas del arreglo y cuyos elementos son los
máximos índices de cada entrada al arreglo.
- u es un vector opcional de longitud igual al mayor índice de la primera entrada al arreglo y cuyos
elementos son los respectivos nombres de esa entrada. Análogamente para v, ... Si no se usa esta
opción y por ejemplo el número de entradas es tres, R le asigna los nombres [1, , ], ... a la primera
entrada, [ ,1, ], ... a la segunda y [ , , 1], ... a la tercera.

Incorporación de datos a un arreglo

Veremos algunas formas de completar con datos un arreglo.

♣ Uso de for
Supongamos que hemos definido el arreglo U así:
U=array(dim=c(2,2,3)).
Deseamos completar ese arreglo U con el siguiente criterio: “En cada casillero colocamos la suma del
número de la primera entrada, del número de la segunda y del número de la tercera correspondientes al
casillero”. Eso podemos lograrlo con la orden
for (i in 1:2) for (j in 1:2) for (k in 1:3) U[i,j,k]=i+j+k
El símbolo U[i,j,k] identifica al elemento de U que está en el lugar i de la primera entrada, el lugar j de la
segunda y el lugar k de la tercera.
Con esa orden obtenemos el siguiente arreglo U:
, , 1 , , 2 , , 3
[ ,1] [ ,2] [ ,1] [ ,2] [ ,1] [ ,2]
[1, ] 3 4 [1, ] 4 5 [1, ] 5 6
[2, ] 4 5 [2, ] 5 6 [2, ] 6 7

♣ Uso de array(data=x,dim=y,dimnames=list(u,v,...))
Supongamos que tenemos el siguiente vector de longitud 12: x=(2 , 4 , 5 , 7 , 8 , 1 , 3 , 1 , 6 , 9 , 2, 4).
La orden
V1=array(data=x,dim=c(2,2,3))
crea el siguiente arreglo V1:
, , 1 , , 2 , , 3
[ ,1] [ ,2] [ ,1] [ ,2] [ ,1] [ ,2]
[1, ] 2 5 [1, ] 8 3 [1, ] 6 2
[2, ] 4 7 [2, ] 1 1 [2, ] 9 4
La orden
V2=array(data=x^2,dim=c(2,3,2)
crea el siguiente arreglo V2:
, , 1 , , 2
[ ,1] [ ,2] [ ,3] [ ,1] [ ,2] [ ,3]
[1, ] 4 25 64 [1, ] 9 36 4
[2, ] 16 49 1 [2, ] 1 81 16

♣ Uso de dim
Si nuevamente x=(2 , 4 , 5 , 7 , 8 , 1 , 3 , 1 , 6 , 9 , 2, 4), las órdenes
dim(x)=c(3,2,2) ; W=x
transforman el vector x en el siguiente arreglo W :
, , 1 , , 2
[ ,1] [ ,2] [ ,1] [ ,2]
[1, ] 2 7 [1, ] 3 9
[2, ] 4 8 [2, ] 1 2
[3, ] 5 1 [3, ] 6 4

15
Creación de arreglos a partir de un arreglo

A partir de un arreglo podemos crear otros usando vectores numéricos o lógicos como índices, en forma
similar a como lo hicimos con las matrices.

E – Lista

Creación de una lista e incorporación de datos a ella

La palabra lista se usa en R para referirse a una colección ordenada de objetos y nombres de los mismos.
A los objetos se los llama componentes de la lista. Las componentes de la lista, que R numera, pueden
ser objetos de clases y tipos diferentes. La longitud de una lista es el número de sus componentes.
Se crea una lista con la orden list(n1=x1,n2=x2, ...), donde x1, x2, ... son los objetos que integran la lista
(ya existentes o definidos en la orden list) y n1, n2, ... sus nombres opcionales. Si se omiten uno o varios
nombres, R toma como nombres los respectivos números de las componentes.
Por ejemplo, la orden
L=list(C1=c(1,2),C2=matrix(data=3:6,nrow=2,ncol=2),C3=c(TRUE,FALSE,TRUE,TRUE),C4=factor(c(1,2,
1),labels=c(“Hombre”,”Mujer”))
crea la misma lista que la orden
L=list(C1=a,C2=b,C3=c,C4=d)
si antes hubiéramos definido a=c(1,2), b=matrix(data=3:6,nrow=2,ncol=2), c=c(TRUE,FALSE,TRUE,TRUE)
y d=factor(c(1,2,1),labels=c(“Hombre”,”Mujer”)).
Con esas órdenes obtenemos la siguiente lista L:
$C1 y el vector (1 , 2).
⎛ 3 5⎞
$C2 y la matriz ⎜⎜ ⎟⎟ .
⎝4 6⎠
$C3 y el vector (TRUE , FALSE , TRUE , TRUE).
$C4 y el vector (Hombre , Mujer , Hombre).
Para seleccionar elementos de la lista, componentes de la lista o elementos de las componentes de la
lista debemos tener en cuenta lo que sigue.
La orden
L[1]
selecciona el primer elemento de la lista, o sea $C1 y el vector (1 , 2).
La orden
L[[2]]
⎛ 3 5⎞
selecciona el objeto del segundo elemento de la lista, o sea la matriz ⎜⎜ ⎟⎟ .
⎝4 6⎠
Esta orden produce el mismo resultado que L$C2 o L[[“C2”]].
La orden
L[[3]][2]
selecciona el segundo elemento del objeto del tercer elemento de la lista, o sea FALSE.

Creación de listas a partir de una o más listas

Las listas no son vectores pero se les parecen. Por lo tanto no debe sorprendernos que podamos crear
nuevas listas con algunos de los procedimientos que vimos para crear nuevos vectores: el uso de c, de
rep o de vectores numéricos o lógicos como índices.

F – Hoja de datos

Creación de una hoja de datos e incorporación de datos a ella

La denominación hoja de datos se usa en R para referirse a un tipo particular de lista que se concreta en
un cuadro bidimensional (filas y columnas) con datos de distintos objetos.
Para que una lista sea una hoja de datos deben cumplirse las siguientes condiciones:
1) Los vectores y los factores en la hoja de datos deben tener la misma longitud l.
2) Las matrices en la hoja de datos deben tener el mismo número de filas y este número debe ser l.
3) Las listas en las hojas de datos deben tener objetos que verifiquen 1) y 2).
16
Ese número l es el número de filas de la hoja de datos. En cuanto al número de columnas de la hoja de
datos, debemos tener en cuenta que cada vector aporta una y cada matriz tantas como columnas tenga.
En una hoja de datos puede haber vectores y matrices no numéricas pero R transforma tales vectores y
las columnas de tales matrices en factores cuyos niveles son los respectivos valores.
Se crea una hoja de datos con la orden data.frame(n1=x1,n2=x2, ...), donde x1, x2, ... son los objetos que
participan en la hoja de datos (ya existentes o definidos en la orden data.frame) y n1, n2, ... sus nombres
opcionales. Si se omiten uno o varios nombres, R los asigna.
A la orden data.frame(n1=x1,n2=x2, ...) se le pueden agregar algunas opciones:
- row.names=u, donde u es un vector de longitud l con los nombres de las filas (por defecto R le
asigna los nombres [1, ], ..., [l, ]).
- check.names=p donde p es FALSE o TRUE (por defecto TRUE, con lo que se controla que no haya
repetición de nombres de objetos y en caso que los hubiera, se los cambia).
H=data.frame(a=20:23,b=matrix(data=1:12,nrow=4,ncol=3),row.names=c(“F1”,”F2”,”F3”,”F4”))
crea la siguiente hoja de datos H:
a b.1 b.2 b.3
F1 20 1 5 9
F2 21 2 6 10
F3 22 3 7 11
F4 23 4 8 12
Es interesante que notemos cómo se ingenió R para poner nombre a las tres últimas columnas de H.
Para finalizar con la construcción de hojas de datos, señalemos que una forma simple de hacerlo es con
la función read.table( ) que se usa para leer datos desde un archivo del sistema operativo (esto lo
veremos cuando tratemos el tema de guardar y recuperar datos).

Creación de hojas de datos a partir de una o más hojas de datos

Las hojas de datos y las matrices son similares. Por lo tanto no debe sorprendernos que podamos crear
nuevas hojas de datos con algunos de los procedimientos que vimos para crear nuevas matrices: uso de
cbind o de vectores numéricos o lógicos como índices (rbind sirve cuando las hojas de datos tienen los
mismos nombres de columnas).

G – Serie de tiempo

Creación de una serie de tiempo e incorporación de datos a ella

La denominación serie de tiempo se usa en R para referirse a un vector o una matriz con datos
obtenidos en el transcurso del tiempo.
Se crea una serie de tiempo con la orden
ts(data=x,start=p,end=q,frequency=r,deltat=s,names=t), donde:
- x es un vector (serie univariada) o una matriz (serie multivariada). Si no se usa esta opción, R asume
que la serie es univariada y le asigna NA a cada uno de sus casilleros.
- p es un número natural o un vector con dos números naturales que indica el momento del primer
dato. Si p es un número y la frecuencia (frequency) es mayor que 1, R lo transforma en c(p,1).
- q es un número natural o un vector con dos números naturales que indica el momento del último
dato. Si no se usa esta opción, R calcula q a partir de p y la longitud de x.
- r es un número natural que indica el número de datos por unidad de tiempo. Si no se usa esta
opción, R le asigna el valor 1.
- s es un número que indica la fracción de la unidad de tiempo entre datos sucesivos (por ejemplo,
1/12 para datos mensuales cuando la unidad de tiempo es el año).
Sólo se debe especificar r o s.
- t es un vector opcional de tipo carácter con los nombres de cada serie. Si no se usa esta opción, R
toma como nombres los de las columnas de x o Series 1, Series 2, ... Sólo puede usarse esta opción
en el caso de series multivariadas.
Por ejemplo:
La orden
S1=ts(data=1:20,start=1985)
crea la siguiente serie de tiempo S1:
(1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11, 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20).
17
R nos informa, además, que Start = 1985, End = 2004 y Frequency = 1.
La orden
S2=ts(data=1:20,start=c(1985,3),frequency=4)
Qtr1 Qtr2 Qtr3 Qtr4
1985 1 2
1986 3 4 5 6
1987 7 8 9 10
1988 11 12 13 14
1989 15 16 17 18
1990 19 20
La orden
S3=ts(data=matrix(data=1:20,nrow=5,ncol=4),start=c(1985,3),frequency=12)
Series 1 Series 2 Series 3 Series 4
Mar 1985 1 6 11 16
Apr 1985 2 7 12 17
May 1985 3 8 13 18
Jun 1985 4 9 14 19
Jul 1985 5 10 15 20

Creación de series de tiempo a partir de una o más series de tiempo

Podemos crear nuevas series de tiempo con algunos de los procedimientos que vimos para crear nuevas
matrices: uso de cbind o de vectores numéricos o lógicos como índices. El uso de cbind requiere dos
series de tiempo con igual frecuencia.
Por ejemplo, siendo S3 la serie de tiempo que recién construimos :
Si S4=ts(data=matrix(data=21:32,nrow=6,ncol=2),start=c(1985,5),frequency=12), la orden
S5=cbind(S3,S4)
S3 Series 1 S3 Series 2 S3 Series 3 S3 Series 4 S4 Series 1 S4 Series 2
Mar 1985 1 6 11 16 NA NA
Apr 1985 2 7 12 17 NA NA
May 1985 3 8 13 18 21 27
Jun 1985 4 9 14 19 22 28
Jul 1985 5 10 15 20 23 29
Aug 1985 NA NA NA NA 24 30
Sep 1985 NA NA NA NA 25 31
Oct 1985 NA NA NA NA 26 32
Si S6=ts(data=rep(“A”,times=7),start=c(1985,5),frequency=12), la orden
S7=cbind(S3,S6)
S3 Series 1 S3 Series 2 S3 Series 3 S3 Series 4 S6
Mar 1985 1 6 11 16 <NA>
Apr 1985 2 7 12 17 <NA>
May 1985 3 8 13 18 A
Jun 1985 4 9 14 19 A
Jul 1985 5 10 15 20 A
Aug 1985 <NA> <NA> <NA> <NA> A
Sep 1985 <NA> <NA> <NA> <NA> A
Oct 1985 <NA> <NA> <NA> <NA> A
Nov 1985 <NA> <NA> <NA> <NA> A
Resulta interesante que notemos que hemos construido S7 con una matriz numérica y un vector de
caracteres.

III – CREACIÓN DE FUNCIONES

En la sección anterior hemos utilizado algunas de las múltiples funciones que incluye R para facilitar
nuestro trabajo. Aquí no nos ocuparemos de detallar las funciones construidas por R (una clasificación
18
de gran parte de ellas consta en la página 53 del libro “R para principiantes, Emmanuel Paradis”) sino de
dar ejemplos de cómo construir nuestras propias funciones.
Ya sabemos, por ejemplo, que la orden
a=rep(“b”,5)
crea un vector a cuyos elementos son los caracteres “b”, “b”, “b”, “b” y b”.
Hemos usado una función de R, la función rep. Si esa función no estuviera dentro de las que incluye R,
podríamos haberla creado de la siguiente manera:
Repite=function(x,y) { z=x ; for (i in 2:y) z=c(z,x) }
Nuestra función se llama Repite y tiene dos variables o argumentos: x es el vector que deseamos repetir
e y es el número de repeticiones de x; para obtener un valor de esa función debemos especificar x e y.
La orden
a=Repite(“b”,5)
crea un vector a cuyos elementos son los caracteres “b”, “b”, “b”, “b” y b”.
Si sólo hubiéramos escrito
Repite(“b”,5)
no tendríamos forma de saber el resultado obtenido por R pues las asignaciones realizadas dentro de la
función Repite se pierden al calcular un valor de ella (son asignaciones locales o transitorias).
Hay dos formas de solucionar ese inconveniente:
- Una de las formas nos permite ver en pantalla el resultado de un valor funcional aunque perdemos
ese valor.
Las órdenes
Repite2=function(x,y) { z=x ; for (i in 2:y) z=c(z,x) ; return(z) } ; Repite2(“b”,5)
nos muestran en pantalla el resultado “b” “b” “b” “b” “b”.
- La otra forma nos permite conservar el valor funcional calculado.
Las órdenes
Repite3=function(x,y) { z=x ; for (i in 2:y) z=c(z,x) ; a<<‐z } ; Repite3(“b”,5)
crea un vector a cuyos elementos son los caracteres “b”, “b”, “b”, “b” y b”; hemos hecho una
asignación global o permanente con la orden a<<‐z.

Para crear una función se usa la orden N=function(x1,x2,...) { ______ }, donde:
- N es el nombre de la función.
- x1, x2, ... son los nombres de las variables o argumentos de la función.
- ______ contiene las órdenes que R debe ejecutar para calcular el valor de la función. Hay que tener
en cuenta que el valor de la función es el de la última orden ejecutada siempre que no esté la orden
return (ésta es la que prevalece en caso de estar).

Veamos algunos ejemplos de construcción de funciones.

Ejemplo 1 ‐ Ubicación
Ya mencionamos que con una matriz A de m filas y n columnas podemos obtener un vector v de
longitud m.n usando la orden v=c(A). Y también que con un vector v de longitud m.n podemos formar
una matriz A de m filas y n columnas las ordenes dim(x)=c(m,n) ; A = x.
Ahora bien, si conocemos la fila y la columna que identifican a un casillero de A, ¿en qué lugar de v está
el correspondiente elemento de A? Y recíprocamente, si conocemos un lugar de v ¿en qué fila y en qué
columna de A está el correspondiente elemento de v?
Para contestar a esas preguntas podemos crear las siguientes dos funciones:
Ubenvector=function(m,n,i,j) {z=m*(j‐1)+i ; return(z)},donde
- m es el número de filas y n el de columnas de la matriz A.
- i y j son números que identifican, respectivamente, a la fila y la columna de la matriz A.
Ubenvector es una función de cuatro variables naturales cuyos valores son números naturales; cada
uno de esos valores contesta a la primera pregunta que planteamos.
Ubenmatriz=function(l,m,n) {z=c((l‐1)%%m+1,(l‐1)%/%m+1) ; return(z)} , donde
- l es un número que identifica un lugar en el vector v.
- m es el número de filas y n el de columnas de la matriz A.
Ubenmatriz es una función de tres variables naturales cuyos valores son parejas de números
naturales; cada uno de esos valores contesta a la segunda pregunta que planteamos .
Por ejemplo, si A es una matriz de 11 filas y 8 columnas y v es el respectivo vector de longitud 88 (o
viceversa), las órdenes
Ubenvector(11,8,7,6) ; Ubenmatriz(35,11,8)
19
nos muestran en pantalla, respectivamente, los resultados 62 y 2 4 que interpretamos así: el elemento
ubicado en la fila 7 y la columna 6 de la matriz A está en el lugar 62 del vector v y el elemento ubicado
en el lugar 35 del vector v está en la fila 2 y en la columna 4 de la matriz A.
Es claro que en el cálculo de los valores de las dos funciones que hemos definido no interviene n (el
número de columnas de A). Podemos ser algo más sutiles, haciendo participar n para prever algún error
al dar valores a las variables para calcular un valor funcional.
La orden
Ubenvector=function(m,n,i,j) {if (i<=m&j<=n) z=m*(j‐1)+i else z=”Error” ; return(z)}
nos alerta sobre valores incorrectos en el cuarteto (m,n,i,j).
Ubenmatriz=function(l,m,n) {if(l<=m*n) z=c((l‐1)%%m+1,(l‐1)%/%m+1 else z=”Error” ; return(z)}
nos alerta sobre valores incorrectos en la terna (l,m,n).

Ejemplo 2 – La sucesión de Fibonacci
La sucesión de Fibonacci es la siguiente: 1 1 2 3 5 8 13 21 ...
La orden
Fibo=function(t) {F=vector(“numeric”,t) ; F[1]=1 ; F[2]=1 ; for (i in 3:t) F[i]=F[i‐2]+F[i‐1] ; return(F)}
crea una función de nombre Fibo, de una variable natural t (t > 2), que nos informa sobre los t primeros
términos de la sucesión de Fibonacci.
La orden
Fibo(6)
nos muestra en pantalla los seis primeros términos de la sucesión de Fibonacci, o sea 1 1 2 3 5 8.
Otra forma de definir la función Fibo es la que sigue:
Fibo=function(t) {F=vector(“numeric”,t) ; F[1]=1 ; F[2]=1 ; i=3 ; while (i <=t) {F[i]=F[i‐2]+F[i‐1] ; i=i+1} ;
return(F)}
Creemos que es más claro escribir lo anterior de la siguiente manera (los ; que separan órdenes han sido
sustituidos por saltos de renglones):
Fibo=function(t) {
F=vector(“numeric”,t)
F[1]=1
F[2]=1
i=3
while (i <=t) {
F[i]=F[i‐2]+F[i‐1]
i=i+1}
return(F)}

Ejemplo 3 – Números primos
Supongamos que tenemos un número natural p mayor que 2 y deseamos saber si es o no un número
primo.
La orden
Primo=function(p) {
for (i in 2:(p‐1)) {
r=p%%i
if (r==0) a=”no es primo” else a=”es primo”
if (r==0) break }
z<<‐a
return(paste(p,a))}
crea una función de nombre Primo, de una variable natural p (p > 2), cuyo valor es una frase que nos
indica si p es o no un número primo.
Las órdenes
Primo(221) ; Primo(2311)
crean un vector z cuyo elemento es, respectivamente, “no es primo” y “es primo” y muestran en
pantalla los resultados “221 no es primo” y “2311 es primo”.
20
Otra forma de definir la función Primo es la siguiente:
Primo=function(p) {
I=2
while (i<p) {
r=p%%i
if (r==0) a=”no es primo” else a=”es primo”
if (r==0) i=p else i=i+1 }
z<<‐a
return(paste(p,a))}
Veamos ahora cómo usar la función Primo para construir un vector con los primeros k números primos,
donde k es un número natural mayor que 2.
La orden
Primerosprimos=function(k) {
P=vector(“numeric”,k)
P[1]=1 ; P[2]=2 ; i=3 ; j=3
while (j <k+1) {
q=Primo(i)
if (z==”es primo”) {P[j]=i ; i=i+1 ; j=j+1} else i=i+1}
c=paste(P[1]) ; for (i in 2:k) c=paste(c,P[i])
z<<‐P
return(paste(“Los primeros”,k, “números primos son:”,c))}
crea una función de nombre Primerosprimos, de una variable natural k (k > 2), cuyo valor es una frase
que nos informa sobre los primeros k números primos.
La orden
Primerosprimos(20)
crea un vector z cuyos elementos son los primeros veinte números primos y muestra en pantalla el
mensaje “Los primeros 20 números primos son: 1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53
59 61 67”.

Finalmente, usemos nuevamente la función Primo para saber si número natural p mayor que 2 es o no
un número primo y en caso que lo sea, determinar el lugar que ocupa en la sucesión creciente de
números primos.
La orden
Primoy lugar=function(p) {
q=Primo(p)
if (z=”no es primo”) {a=z ; l=”“} else{
l=2
for (i in 3:p) {
q=Primo(i) ; if (z=”es primo”) l=l+1}
a=”es primo y está en el lugar”}
return(paste(p,a,l))}
crea una función de nombre Primoylugar, de una variable natural p (p > 2), cuyo valor es una frase que
nos indica si p es o no un número primo y en caso de serlo el lugar que ocupa en la sucesión creciente
de números primos.
Las órdenes
Primoylugar(221) ; Primoylugar(2311)
muestran en pantalla, respectivamente, los mensajes “221 no es primo ” y “2311 es primo y está en el
lugar 345”.

Ejemplo 4 – Muestra de una distribución binomial
Supongamos que deseamos seleccionar una muestra de tamaño k de la binomial de parámetros n y p y
obtener las funciones de cuantía y de distribución de esa muestra.
La orden
Muesbino=function(k,n,p) {
x=rbinom(k,size=n,prob=p)
y=table(x)/k
z=cumsum(y)
print(“Función de cuantía de la muestra seleccionada”)
print(y)
21
print(“Función de distribución de la muestra seleccionada”)
print(z) }
crea una función de nombre Muesbino, de tres variables (k y n naturales y p real entre 0 y 1), que nos
informa sobre las funciones de cuantía y de distribución de la muestra de tamaño k que R seleccionó de
la binomial de parámetros n y p.
Al ejecutar por primera vez la orden
Muesbino(100,5,0.4)
obtuvimos los siguientes resultados:
“Función de cuantía de la muestra seleccionada”
0 1 2 3 4

0.05 0.30 0.32 0.28 0.05
“Función de distribución de la muestra seleccionada”
0 1 2 3 4

0.05 0.35 0.67 0.95 1
Es interesante que recordemos que la función de cuantía de la binomial de parámetros 5 y 0,4 es
0 1 2 3 4 5

0.0778 0.2592 0.3456 0.2304 0.0768 0.0102

IV – PROGRAMACIÓN

Un programa es una secuencia de órdenes. Con esa acepción del término “programa”, podemos afirmar
que ya hemos construido múltiples programas, en particular las funciones que definimos en la sección
anterior.
En la construcción de un programa suelen ser útiles las siguientes estructuras de control (ya las hemos
utilizado en algún momento):
- if
La orden
if (condición) expresión 1 else expresión 2
motiva que R ejecute la expresión 1 si la condición se cumple o la expresión 2 si la condición no se
cumple; la condición es un vector lógico de longitud 1.
Si la orden se reduce a
if (condición) expresión
R ejecuta la expresión si la condición se cumple.
Por ejemplo, las órdenes
k = 10 ; if (k>=5) print(“Grande”) else print(“Chico”)
muestra en pantalla el mensaje “Grande”.
- ifelse
La orden
z=ifelse((condición),sí,no)
crea un objeto z, de la misma clase, tipo y longitud de los objetos que están en la condición, cuyos
elementos se obtienen según se indica en sí (cuando la condición lleva a TRUE) o en no (cuando la
condición lleva a FALSE).
La condición es un objeto lógico construido con expresiones comparativas en las que intervienen
objetos de la misma clase, tipo y longitud (habitualmente vectores o matrices).
⎛1 9 4⎞ ⎛2 8 9⎞
Por ejemplo, si X = ⎜⎜ ⎟⎟ e Y = ⎜⎜ ⎟⎟ , la orden
⎝ 3 10 5 ⎠ ⎝ 1 12 3 ⎠
Z=ifelse((X<Y),X+Y,X*Y)
⎛ 3 72 13 ⎞
crea la matriz Z = ⎜⎜ ⎟⎟ .
⎝ 3 22 15 ⎠
- for
La orden
for (c in u) expresión
hace que R ejecute la expresión cada vez que c recorre u; c es un carácter y u un objeto
(habitualmente un vector).
22
for (i in c(“a”,”b”)) print(paste(“La letra es”,i))
muestra en pantalla los mensajes “La letra es a” y “La letra es b”.
- while
La orden
while (condición) expresión
lleva a que R ejecute la expresión mientras se cumpla la condición; la condición es un vector lógico
de longitud 1.
k = 1 ; while (k<=4) {print(k) ; k=k+1}
muestra en pantalla lo siguiente: 1 2 3 4 .
- repeat
La orden
repeat expresión
lleva a que R ejecute la expresión indefinidamente (se puede detener apretando la tecla Esc).
- break
break se usa en una estructura de control “anidada” (con for, while o repeat) para interrumpir algún
proceso.
for (i in 1:3) { j = 1 ; repeat { while (j<5) { print(c(i,j)) ; j=j+1} ; break } }
muestra en pantalla la siguiente secuencia de parejas: 11 12 13 14 21 22 23 24 31 32 33 34.
- next
next se usa en una estructura de control “anidada” para retornar a algún proceso.
Por ejemplo, si hemos creado un vector numérico x de longitud 20, las órdenes
x[1]=1 ; i=1 ; j = 2 ; while (j<=20) { i= i+1 ; if(i%%7==0) next else {x[j]=i ; j=j+1 } }
completa x con los primeros veinte números que no son múltiplos de siete.

V– GUARDAR Y RECUPERAR

Hasta ahora hemos supuesto que todo nuestro trabajo lo hacemos en la consola de R y que el mismo
desaparece cuando salimos de R, lo cual no es buena cosa. Es importante, por lo tanto, que sepamos
cómo guardar lo que nos interesa y cómo recuperarlo posteriormente. Asimismo, es de suma utilidad
que también conozcamos cómo importar archivos construidos con programas distintos a R. De todo ello
nos ocuparemos a continuación.

A – Guardar y recuperar programas

Supongamos que nos interesa guardar las funciones Primo, Primerosprimos y Primoylugar que
definimos en la Sección III. La forma de hacerlo depende de qué fue lo que usamos para redactar esas
funciones.
1) Si las funciones las redactamos en la consola de R:
La orden
save(“Primo”, file=”E:/R/Primo”)
guarda la función Primo en el directorio E:\R con el nombre Primo (notemos la diferencia entre / y
\). Para recuperar esa función usamos la orden load(“E:/R/Primo”).
La orden
save(“Primo”, “Primerosprimos”,”Primoylugar”,file=”E:/R/Númerosprimos”)
guarda la funciones Primo, Primerosprimos y Primoylugar en el directorio E:\R con el nombre
Númerosprimos (notemos la diferencia entre / y \). Para recuperar esas funciones usamos la orden
load(“E:/R/Númerosprimos”).
2) Si, por ejemplo, la función Primo la redactamos en el editor que R nos proporciona al elegir en su
menú las opciones Archivo y Nuevo script y luego marcamos el icono X en ese editor, R nos
preguntará dónde y con qué nombre deseamos guardar esa función; si nuestra elección se concretó
en E:\R\Primo, para recuperarla usamos la orden source(“E:/R/Primo”).
Lo anterior vale para cualquier programa que no sea una función, aunque en ese caso la orden
source motiva la ejecución del programa.
3) Si, por ejemplo, la función Primo la redactamos en un editor ajeno a R, debemos guardarla en
formato txt; si eso lo hicimos en E:\R\Primo.txt, su recuperación la logramos con la orden
source(“E:/R/Primo.txt”). Esto vale para cualquier programa.
23
Tanto en este punto como en el anterior, las opciones Archivo y Abrir script del menú de R nos
permiten modificar un programa ya existente.

B – Guardar y recuperar objetos creados en R

Para guardar objetos creados en una sesión de R (vectores, factores, matrices, arreglos, listas, hojas de
datos y series de tiempo) y para recuperarlos podemos usar las órdenes save y load tal como lo
indicamos en la conservación de un programa.
En relación con lo anterior, puede ser útil tener en cuenta que la orden save.image( ) guarda todos los
objetos en memoria creados durante una sesión de R en el directorio de trabajo, previa eliminación de
lo que allí hubiera; esos objetos son recuperados automáticamente al iniciar la siguiente sesión (la orden
getwd( ) nos informa sobre ese directorio y la orden setwd(“...”) nos permite cambiarlo al lugar indicado
en ...).
También podemos guardar objetos con la orden write.table, cuya forma y principales opciones son:
- write.table(x,file=”a”,append=b,sep=”c”,eol=”d”,na=”e”,dec=”f”,row.names=g,col.names=h).
- x es el nombre del objeto (una matriz o una hoja de datos; en caso contrario R convierte x a una
hoja de datos).
- a indica el lugar y el nombre del archivo donde se guardará x.
- b es TRUE (el objeto se incorpora al archivo sin borrar datos existentes en el mismo) o FALSE. Si no
se usa esta opción, R toma como b FALSE.
- c indica el separador de campo utilizado en el archivo. Si no se usa esta opción, R toma como c un
espacio en blanco.
- d indica el final de línea usado en el archivo. Si no se usa esta opción, R toma \n como d (retorno).
- e indica qué se usará para identificar datos faltantes. Si no se usa esta opción, R toma como e NA.
- f indica el carácter usado como separador de decimales. Si no se usa esta opción, R toma un punto
como f.
- g es TRUE (los nombres de las líneas de x se escriben en el archivo) o FALSE. Si no se usa esta
opción, R toma como g TRUE.
- h es similar a g para los nombres de las columnas de x.
La orden read.table, que veremos en el apartado que sigue, nos permite recuperar un objeto guardado
con la orden write.table.

C – Recuperar archivos de datos creados fuera de R

Podemos leer archivos de datos con formato de texto creados fuera de de R, transformándolos en una
hoja de datos de R, con la orden read.table. La forma y las principales opciones de esta orden son:
- read.table(file=”a”,header=b,sep=”c”,dec=”d”,row.names=e,col.names=f,as.is=g,na.strings=”h”,skip
=i,fill=j,blank.lines.skip=k,strip.white=l,comment.char=”m”).
- a indica el lugar y el nombre del archivo que se leerá (el nombre debe tener la extensión txt).
- b es TRUE (el archivo contiene el nombre de las variables en su primera fila) o FALSE. Si no se usa
esta opción, R toma como b FALSE.
- c indica el separador de campo utilizado en el archivo (por ejemplo, \t para una tabulación). Si no se
usa esta opción, R toma como c un espacio en blanco.
- d indica el carácter usado como separador de decimales en el archivo. Si no se usa esta opción, R
toma un punto como d.
- e es un vector con los nombres de las filas de la hoja de datos. Si no se usa esta opción, R toma
como nombres 1, 2, ...
- f es similar a e para los nombres de las columnas de la hoja de datos. Si no se usa esta opción, R
toma como nombres V1, V2, ...
- g es TRUE (se mantiene el tipo de las variables tipo carácter del archivo) o FALSE (se convierten las
variables tipo carácter del archivo a factores). Si no se usa esta opción, R toma como g FALSE.
- h indica qué se usará para identificar datos faltantes. Si no se usa esta opción, R toma como h NA.
- i es el número de las primeras filas del archivo que se ignorarán en la lectura. Si no se usa esta
opción, R toma 0 como i.
- j es TRUE (se agregan blancos cuando en el archivo hay variables de distinta longitud) o FALSE. Si no
se usa esta opción, R toma como j FALSE.
- k es TRUE (se ignoran líneas en blanco del archivo) o FALSE. Si no se usa esta opción, R toma como k
TRUE.
24
- l es TRUE (se borran espacios extras antes y después de variables tipo carácter en el archivo) o
FALSE. Si no se usa esta opción, R toma como l FALSE.
- m es el primer carácter en las líneas del archivo con comentarios, las cuales son ignoradas en la
lectura. Si no se usa esta opción, R toma m como # (l=”” desactiva esta asignación por defecto).

En la próxima tabla listamos algunas variantes de la orden read.table que son útiles pues tienen
incorporadas ciertas opciones por defecto.

Variante de read.table header sep dec fill
read.csv(file=”a”) TRUE “,” “.” TRUE
read.csv2(file=”a”) TRUE “;” “,” TRUE
read.delim(file=”a”) TRUE “\t” “.” TRUE
read.delim2(file=”a”) TRUE “\t” “,” TRUE

D – Recuperar archivos de datos que suministra R

R tiene una biblioteca que está dividida en paquetes, los cuales pueden contener archivos de datos.
La orden
library( )
muestra en pantalla los nombres de los paquetes que forman la biblioteca de R.
La orden
library(help=”p”), donde p es el nombre de un paquete,
lista en pantalla el contenido del paquete p.
La orden
data(package=”p”), donde p es el nombre de un paquete,
muestra en pantalla los nombres de los archivos de datos que están en el paquete p y una breve
descripción de los mismos.
La orden
data ( )
motiva que R asuma que nos interesa conocer los archivos de datos de todos los paquetes que están en
el directorio de trabajo (el paquete datasets se carga automáticamente al iniciar una sesión y para
cargar cualquier otro debemos usar la orden library(p), donde p es el nombre del paquete).
La orden
data(a,package=”p”), donde p es el nombre de un paquete y a el de un archivo de datos en p,
incorpora al directorio de trabajo el archivo a.
Si el paquete p está en el directorio de trabajo, alcanza con la orden data(a).
data(singer,package=”lattice”)
pone en el directorio de trabajo el archivo de datos llamado singer que informa sobre el peso y la voz de
cada integrante del coro de Nueva York.

VI ‐ GRÁFICOS

Hay tres paquetes en la biblioteca de R que tienen funciones que nos permiten construir gráficos (los
paquetes graphics, grid y lattice).
Importa que tengamos en cuenta que hay dos tipos de funciones gráficas en R (las de alto nivel que
crean gráficos y las de bajo nivel que agregan elementos a un gráfico ya existente) y que esas funciones
tienen asociadas ciertos parámetros gráficos que están definidos por defecto y pueden ser modificados.
El número de funciones gráficas es 66 en el paquete graphics, 72 en el paquete grid y 60 en el paquete
lattice; la orden library(help=”p”), donde p es el nombre del paquete, nos muestra el nombre y una
breve descripción de cada una de esas funciones.
El resultado de una función gráfica se envía a un dispositivo gráfico (una ventana gráfica o un archivo).
De aquí en adelante supondremos que el dispositivo gráfico es una ventana gráfica (desde ella podemos
copiar el gráfico creado o guardarlo como un archivo).
Debido a la amplitud y a la complejidad del tema (es realmente impactante lo que vemos al dar la orden
demo(graphics)), nos limitaremos a trabajar con algunas de las funciones gráficas del paquete graphics.

25
A – Gráficos de puntos, rectas, segmentos, flechas, rectángulos y polígonos

En esta sección nos ocuparemos de algunos gráficos en un plano.

1 – Puntos

Sean los vectores u = 10:20 y v = 1/u
La orden
plot(u,v)
crea un gráfico con once puntos en un plano, cuyas coordenadas son (u[i],v[i]) para cada i entre 10 y 20.
En esa orden hemos usado la función gráfica plot (de alto nivel) y con ella obtuvimos una representación
1
gráfica parcial de la sucesión real s tal que s(n) = . R nos muestra el resultado en una ventana gráfica.
n
0.10
0.09
0.08
v
0.07
0.06
0.05
10 12 14 16 18 20
u

Es claro que R ha tomado varias decisiones con el objetivo de mostrarnos un gráfico legible. Entre esas
decisiones destacamos las siguientes:
- Los puntos aparecen en el interior de un rectángulo, la caja del gráfico, y ellos están simbolizados
por circunferencias con un cierto tamaño.
- El nombre del eje horizontal del gráfico es u (el del primer vector que consta en la función plot ) y
en ese eje aparecen algunos de los valores de u (comenzando con el menor y terminando con el
mayor). Algo similar ocurre con el eje vertical del gráfico. Los segmentos unitarios elegidos para
esos ejes son diferentes.
- Los números y las letras tienen un cierto tipo, estilo y tamaño y aparecen ubicados en cierta forma.
- No aparece un título para el gráfico.
- No aparecen los habituales ejes de un sistema de coordenadas cartesianas ortogonales.
26
Ahora bien, ¿podemos cambiar ese gráfico de modo que se adapte mejor a lo que deseamos? Sí, eso es
posible agregando opciones a nuestra orden plot(u,v).
La orden
plot(u,v,pch=16,cex=0.75,xlim=c(‐1,21),ylim=c(‐0.05,0.15),cex.axis=0.75,xlab=”Valores de n”,
ylab=”Valores de s(n)”,cex.lab=0.75,main=”Gráfico parcial de una sucesión s”,cex.main=0.75)
nos muestra el siguiente gráfico:
Gráfico parcial de una sucesión s

0.15
0.10
Valores de s(n)
0.05
0.00
-0.05
0 5 10 15 20
Valores de n

Las opciones que agregamos a la orden plot(u,v) y sus consecuencias en relación con el primer gráfico
fueron:
- pch=16 y cex=0.75
Cambiamos el símbolo para representar los puntos y el tamaño de ese símbolo.
- xlim=c(‐1,21), ylim=c(‐0.05,0.15) y cex.axis=0.75
Cambiamos los límites de los ejes del gráfico y el tamaño de los números.
- xlab=”Valores de n”, ylab=”Valores de s(n)” y cex.lab=0.75
Cambiamos los títulos de los ejes del gráfico y el tamaño de esos títulos.
- main=”Gráfico parcial de una sucesión s” y cex.main=0.75
Agregamos un título al gráfico y establecimos su tamaño.

27
Después de crear el gráfico anterior, podemos agregarle elementos usando funciones gráficas de bajo
nivel.
arrows(‐1,0,21,0,length=0.10,angle=20, code=2)
arrows(0,‐0.05,0,0.15,length=0.10,angle=20, code=2)
text(10,0.13,expression(s(n)==over(1,n)),cex=0.75)
text(10,‐0.02,”¿Qué sugiere el dibujo sobre”,cex=0.75)
text(10,‐0.03,”el crecimiento o el decrecimiento de s?,cex=0.75)
motivan el siguiente gráfico:
Gráfico parcial de una sucesión s

0.15
1
s (n ) =
n
0.10
Valores de s(n)
0.05
0.00
¿Qué sugiere el dibujo sobre

el crecimiento o el decrecimiento de s?
-0.05
0 5 10 15 20
Valores de n

En las dos primeras órdenes anteriores usamos la función gráfica de bajo nivel arrows para agregar los
ejes de un sistema de coordenadas cartesianas ortogonales y en las tres últimas recurrimos a la función
gráfica de bajo nivel text para agregar textos (cada uno de esos textos está centrado en el punto cuya
abscisa y cuya ordenada aparecen al comienzo de la orden text).
Es útil que notemos lo que hizo R con expression(s(n)==over(1,n)): llevó esa expresión a la fórmula
1
matemática s(n) = .
n

2 – Rectas, segmentos, flechas, rectángulos y polígonos

Algunas funciones gráficas de bajo nivel llevan a la construcción de rectas, segmentos, flechas,
rectángulos y polígonos.
Debido a que las funciones gráficas de bajo nivel requieren la existencia previa de un gráfico creado con
una de alto nivel, comenzamos construyendo una caja gráfica cuyo interior esté en blanco con la orden
plot(1,1,type=”n”,xlim=c(0,20),ylim=c(0,20),asp=1,xlab=””,ylab=””,
main=”Rectas, segmentos, flechas, rectángulos y polígonos”)
28
La opción type=”n” motiva que el interior de la caja gráfica esté en blanco y la opción asp=1 lleva a que
R tome el mismo segmento unitario en los bordes de la caja gráfica.
A continuación agregamos tres rectas, un segmento, una flecha, un rectángulo y un polígono con las
siguientes órdenes:
abline(h=0) ; abline(v=0) ; abline(10,2,lty=3)
La tercera orden dibuja una recta punteada con ordenada en el origen 10 y coeficiente angular 2.
segments(4,2,6,1)
Segmento cuyos extremos son los puntos (4,2) y (6,1).
arrows(4,10,5,3,length=0.10,angle=20,code=2)
Flecha con origen en el punto (4,10) y extremo en (5,3). La punta de la flecha está en (5,3) y está
señalada con dos segmentos cuya longitud y ángulo con el asta constan en la orden.
rect(10,3,14,6,col=”darkgrey”)
Rectángulo de color gris oscuro, con un vértice en (10,3) y el opuesto en (14,6).
polygon(c(12,15,19,14),c(12,18,14,8),col=”grey”,lwd=3)
Polígono de color gris con vértices (12,12), (15,18), (19,14) y (14,8) y cuyos lados tienen un grosor
de línea que es tres veces el estándar.

Rectas, segmentos, flechas, rectángulos y polígonos

20
15
10
5
0
0 5 10 15 20

3 – Una sucesión interesante

Imaginemos la sucesión creciente de números primos y formemos a partir de ella otra sucesión cuyos
valores son los cocientes de primos consecutivos (segundo sobre primero, tercero sobre segundo y así
sucesivamente). A continuación mostramos dos posibles representaciones gráficas de los primeros 250
términos de esa sucesión.

29
Cociente de primos consecutivos

Valores de coprico(n)
2.0
1.0
0.0
0 50 100 150 200 250
Valores de n

2.0
1.0
0.0
0 50 100 150 200 250
Valores de n

Para obtener lo anterior trabajamos así:
1) Construimos un vector con los primeros 250 cocientes entre primos consecutivos, al que llamamos
coprico (nos apoyamos, claro está, en la función Primerosprimos que habíamos definido en el tercer
ejemplo de la sección III).
2) Dividimos la ventana gráfica de R en dos partes con la orden layout(matrix(data=1:2,nrow=2,ncol=1)
y visualizamos esa partición con la orden layout.show(2), donde 2 es el número de sub‐ventanas.
3) En la parte superior de la ventana construimos el primer gráfico, en el que aparecen 250 puntos.
4) Luego de terminar lo anterior, construimos el segundo gráfico en la parte inferior de la ventana,
trazando segmentos entre puntos consecutivos del primer gráfico. Con ese fin sólo tuvimos que
agregar la opción type=”l” a la orden plot que motivó el primer gráfico.
Debido a que las amplitudes de los intervalos que aparecen en los dos gráficos anteriores pueden llevar
a conclusiones apresuradas, decidimos restringir nuestra atención a una parte del vector coprico: desde
su componente 200 hasta la 250. Ello motivó que construyéramos dos nuevos gráficos, los cuales nos
sugirieron la siguiente pregunta: ¿es cierto que lim coprico (n) = 1 ?
n → +∞

30

1.04
1.02
1.00
200 210 220 230 240 250
Valores de n

1.04
1.02
1.00
200 210 220 230 240 250
Valores de n

B – Algunas funciones gráficas y algunos parámetros gráficos

Hasta el momento hemos usado sólo una función gráfica de alto nivel (plot), varias de bajo nivel (abline,
arrows, polygon, rect, segments y text) y algunos parámetros gráficos (cex, cex.axis, cex.lab, cex.main,
col, lty, lwd y pch).
Ya hemos mencionado que en el paquete graphics hay 66 funciones gráficas. En cuanto a los parámetros
gráficos, hay 71 (podemos ver la lista completa de ellos con la orden help(par)).
A continuación nos ocuparemos de algunas opciones que podemos agregar a plot, de las funciones
gráficas de bajo nivel más usadas y de los parámetros gráficos.

1 – Algunas opciones para plot

Las principales opciones de la función gráfica plot son:
- type
Establece el tipo de gráfico de acuerdo con lo que sigue:
type=”p” Puntos. Es el valor por defecto.
type=”l” Líneas.
type=”o” Puntos y líneas.
type=”s” Escalera que comienza con una línea horizontal.
type=”S” Escalera que comienza con una línea vertical.
type=”h” Líneas verticales hasta cada punto.
type=”n” Interior de la caja gráfica en blanco.
- xlim
Establece un intervalo para el eje horizontal del gráfico.
xlim=c(x1,x2), donde x1 y x2 son números. Si no se usa esta opción, R elige x1 y x2 .
31
- ylim
Establece un intervalo para el eje vertical del gráfico.
ylim=c(y1,y2), donde y1 e y2 son números. Si no se usa esta opción, R elige y1 e y2 .
- log
Establece si se usará o no escala logarítmica de acuerdo con lo que sigue:
log=”” No se usa escala logarítmica en ninguno de los ejes. Es el valor por defecto.
log=”x” Escala logarítmica sólo en el eje horizontal.
log=”y” Escala logarítmica sólo en el eje vertical.
log=”xy” Escala logarítmica en ambos ejes.
- main
Título principal del gráfico (entre comillas). El valor por defecto es NULL (sin título).
- sub
Subtítulo del gráfico (entre comillas). El valor por defecto es NULL (sin subtítulo).
- xlab
Un texto para el eje horizontal (entre comillas). Si no se usa esta opción, R elige el texto.
- ylab
Un texto para el eje vertical (entre comillas). Si no se usa esta opción, R elige el texto.
- axes
Establece si se dibujarán los ejes (axes=TRUE) o no (axes=FALSE). El valor por defecto es TRUE.
Para no dibujar sólo uno de los ejes se debe usar un parámetro gráfico (xaxt o yaxt).
- frame.plot
Establece si se dibujarán los bordes de la caja gráfica (frame.plot=TRUE) o no (frame.plot=FALSE). El
valor por defecto es el valor de axes.
- asp
Establece el valor del cociente entre el segmento unitario del eje vertical y el del eje horizontal. Si
no se usa esta opción, R elige un valor para ese cociente.
Por ejemplo, asp=1 lleva a que R tome el mismo segmento unitario en ambos ejes.

2 – Algunas funciones gráficas de bajo nivel

Las principales funciones gráficas de bajo nivel son:
- points(x,y)
x e y son vectores numéricos de igual longitud (n).
Agrega puntos en (x[i],y[i]) para i = 1, 2, ..., n.
- lines(x,y)
x e y son vectores numéricos de igual longitud (n).
Agrega líneas desde (x[i],y[i]) a (x[i+1],y[i+1]) para i = 1, 2, ..., (n‐1).
- polygon(x,y,border=”j”)
x e y son vectores numéricos de igual longitud (n) y j es un color.
Agrega un polígono cuyos vértices son (x[i],y[i]) para i = 1, 2, ..., n y cuyos lados tienen color j.
- segments(x0,y0,x1,y1)
x0, y0, x1 e y1 son vectores numéricos de igual longitud (n).
Agrega segmentos desde (x0[i],y0[i]) a (x1[i],y1[i]) para i = 1, 2, ..., n.
- arrows(x0,y0,x1,y1,length=l,angle=a,code=c)
x0, y0, x1 e y1 son vectores numéricos de igual longitud (n).
Agrega flechas desde (x0[i],y0[i]) a (x1[i],y1[i]) para i = 1, 2, ..., n.
Las puntas de la flechas están en (x0[i],y0[i]) si code=1, en (x1[i],y1[i]) si code=2 o en ambos si
code=3 (por defecto R toma code=2).
Las puntas de las flechas están señalada con dos segmentos cuya longitud y ángulo con el asta se
determinan según l y a (por defecto R toma l=0.25 y a=30).
- abline(v=a) y abline(h=b)
a y b son números.
Agregan una recta vertical en la abscisa a y una horizontal en la ordenada b.
- abline(n,m)
n y m son números.
Agrega una recta de ordenada en el origen n y coeficiente angular m.
- abline(lm(y ~ x))
x e y son vectores numéricos de igual longitud (el símbolo ~ se obtiene con Alt 126).
Agrega la recta de regresión de y sobre x.
32
- rect(a,b,c,d,border=”j”)
a, b, c y d son números y j es un color.
Agrega un rectángulo, uno de cuyos vértices es (a,b) y el opuesto (c,d). Los lados tienen color j.
- title(main=“t1”,sub=”t2”,xlab=”t3”,ylab=”t4”)
t1, t2, t3 y t4 son textos (hasta tres opcionales).
Agrega el título t1, el subtítulo t2 y las leyendas t3 y t4 para los ejes horizontal y vertical.
- text(a,b,”t”,vfont=v)
a y b son números, t es un texto y v es un vector de caracteres de longitud 2 (v es opcional).
Agrega el texto t eligiendo como punto de referencia el de abscisa a y ordenada b.
La primera componente de v indica el tipo de letra a usar y la segunda su estilo, de acuerdo con las
siguientes posibilidades:

Estilo de letra
Tipo de letra “plain” “bold” “italic” “bold‐italic”
“serif” Sí Sí Sí Sí
“sans serif” Sí Sí Sí Sí
“script” Sí Sí Sí No
“gothic” Sí No No No

Las órdenes help(Hershey) y demo(Hershey) nos informan sobre tipos y estilos de letras.

- axis(side=k,u)
k es 1, 2, 3 ó 4 y u es un vector numérico (u es opcional).
Agrega un eje en la parte inferior (side=1), izquierda (side=2), superior (side=3) o derecha (side=4).
u indica las abscisas u ordenadas donde se dibujarán las marcas del eje.

3 – Algunos parámetros gráficos

En R hay 71 parámetros gráficos, la mayoría de los cuales pueden ser agregados como opciones a las
funciones gráficas. En la próxima tabla listamos los 71 parámetros gráficos de R.

Los parámetros gráficos de R

Nombre del Valor por Nombre del Valor por Nombre del Valor por Nombre del Valor por
parámetro defecto parámetro defecto parámetro defecto parámetro Defecto
adj 0.5 csi (#) 0.2 ljoin “round” plt (*) (6)
ann TRUE cxy (#) (1) lmitre 10 ps (*) 12
ask (*) FALSE din (#) (2) lty “solid” pty (*) “m”
bg (*) “transparent” err 0 lwd 1 smo 1
bty “o” family “ ” mai (*) (3) srt 0
cex 1 fg “black” mar (*) (4) tck NA
cex.axis 1 fig (*) 0 1 0 1 mex (*) 1 tcl ‐0.5
cex.lab 1 fin (*) (2) mfcol (*) 1 1 usr (*) (7)
cex.main 1.2 font 1 mfg (*) 1 1 1 1 xaxp 1 5 4
cex.sub 1 font.axis 1 mfrow (*) 1 1 xaxs “r”
cin (#) 0.15 0.20 font.lab 1 mgp 3 1 0 xaxt “s”
col “black” font.main 2 mkh 0.001 xlog (*) FALSE
col.axis “black” font.sub 1 new (*) FALSE xpd FALSE
col.lab “black” gamma (#) 1 oma (*) 0 0 0 0 yaxp 11 15 4
col.main “black” lab 5 5 7 omd (*) 0 1 0 1 yaxs “r”
col.sub “black” las 0 omi (*) 0 0 0 0 yaxt “s”
cra (#) 14.4 19.2 lend “round” pch 1 ylog (*) FALSE
crt 0 lheight (*) 1 pin (*) (5)

La orden help(par) nos muestra una descripción de cada uno de los parámetros gráficos.

(#) Sólo de lectura.
(*) El cambio del valor por defecto no podemos hacerlo agregando una opción a las funciones gráficas.

(1) 0.1426920 0.2198007 (2) 5.781250 5.770833 (3) 1.02 0.82 0.82 0.42 (4) 5.1 4.1 4.1 2.1
(5) 4.541250 3.930833 (6) 0.1418378 0.9273514 0.1767509 0.8579061 (7) 0.84 5.16 10.84 15.16

33
A continuación presentamos algunos comentarios sobre los parámetros gráficos más usados.
- adj
Determina la forma en que se justifican los textos: 0 a la izquierda, 0.5 centrado y 1 a la derecha.
- bg
Determina el color del fondo de la ventana gráfica.
Podemos ver la lista de los 657 colores disponibles con la orden colors().
- bty
Determina el tipo de caja que se dibuja alrededor del gráfico: “o”, “1”, 7”, “c”, “u”, “[“ ,”]” (la caja se
parece al carácter puesto como valor de bty) o “n” (no se dibuja la caja).
- cex, cex.axis,cex.lab, cex.main y cex.sub
Determinan el tamaño de textos y símbolos, multiplicando el correspondiente valor por defecto por
el que se asigna al parámetro.
- col, col.axis,col.lab, col.main y col.sub
Determinan el color de textos y símbolos.
- family
Determina el tipo de letra: “serif”, “sans serif”, “script”, “gothic” o “mono”.
El valor por defecto es “ ” que motiva que R tome como tipo de letra el de la ventana gráfica.
- fg
Determina el color de los ejes y de la caja.
- font, font.axis,font.lab, font.main y font.sub
Determinan el estilo de letra: 1 para normal (plain), 2 para cursiva (bold), 3 para negrilla (italic) y 4
para negrilla cursiva (bold italic).
- las
Determina la orientación de los caracteres en los ejes: 0 para paralelos a los ejes, 1 para horizontal,
2 para perpendicular a los ejes y 3 para vertical.
- lty
Determina el tipo de las líneas: 1 para sólida, 2 para quebrada, 3 para punteada, 4 para punto
seguido de línea, 5 para línea larga seguida de línea corta y 6 para dos líneas cortas.
- lwd
Determina el grosor de las líneas. El valor de lwd debe ser un entero positivo.
- mai
Determina el espacio en pulgadas entre los ejes y el borde de la gráfica.
El valor de mai es un vector numérico de longitud cuatro con el que se especifican los márgenes
inferior, izquierdo, superior y derecho.
- mar
Determina el espacio en número de líneas entre los ejes y el borde de la gráfica.
El valor de mar es un vector numérico de longitud cuatro con el que se especifican los márgenes
- mfcol y mfrow
Determina una partición de la ventana gráfica que gráficos sucesivos recorren por columnas (mfcol)
o por filas (mfrow).
El valor de mfcol o mfrow es un vector numérico de dos componentes tal que la primera indica el
número de filas y la segunda el de columnas.
- mgp
Determina el espacio entre cada borde de la caja gráfica y el título, las anotaciones y la línea del
respectivo eje.
El valor de mgp es un vector numérico de longitud 3.
- new
Determina si un nuevo gráfico se agrega a uno ya existente (TRUE) o si lo elimina (FALSE).
- oma
Determina el tamaño en número de líneas de los márgenes exteriores.
El valor de oma es un vector numérico de longitud cuatro con el que se especifican los márgenes
- omi
Determina el tamaño en pulgadas de los márgenes exteriores.
El valor de omi es un vector numérico de longitud cuatro con el que se especifican los márgenes
34
- pch
Determina el símbolo usado para representar puntos.
El valor de pch es un número entre 1 y 25 (los respectivos símbolos están en la página 37 del libro
“R para principiantes, Emmanuel Paradis”) o un carácter entre comillas.
- pin
Determina las dimensiones en pulgadas del largo y el ancho de la región donde se dibuja el gráfico.
- plt
Determina las dimensiones de la región donde se dibuja el gráfico como fracciones de las de la caja
del gráfico.
El valor de plt es un vector numérico de longitud cuatro.
- ps
Determina el tamaño en puntos de los textos (la unidad del tamaño en puntos suele ser 1/72 de una
pulgada).
El valor de ps es un entero positivo.
- pty
Determina el tipo de región donde se dibuja el gráfico: ”s” para cuadrada y “m” para máxima.
- tck
Determina la longitud de las marcas en los ejes como una fracción de la altura o anchura máxima de
la región donde se dibuja el gráfico.
El valor de tck es un número positivo que no supera a 1 (si es 1 se obtiene una rejilla).
El valor por defecto de tck (NA) lleva a que R tome el valor de tcl para decidir sobre la longitud de
las marcas en los ejes.
- tcl
Determina la longitud de las marcas en los ejes como una fracción de la altura de una línea de texto.
El valor de tcl es un número entre –1 y 1 (los números negativos motivan que las marcas en los ejes
aparezcan por debajo del eje horizontal y a la izquierda del vertical y los números positivos que esas
marcas se ubiquen por encima del eje horizontal y a la derecha del vertical).
- xaxp e yaxp
Determina las coordenadas de las marcas extremas en el eje horizontal (xaxp) o en el vertical (yaxp)
y el número de intervalos entre esas marcas (en el caso que en el eje no se use escala logarítmica).
El valor de cada uno de esos parámetros es un vector numérico de longitud tres: las dos primeras
componentes especifican las coordenadas de las marcas extremas y la tercera el número de
intervalos entre ellas.
- xaxt e yaxt
Determina si el eje se dibuja (“s”) o no (“n”).
El valor “n” es útil cuando optamos por dibujar los ejes con axis (función gráfica de bajo nivel).

Para terminar con los parámetros gráficos, importa que indiquemos cómo proceder con aquellos cuyos
valores por defecto no podemos cambiarlos agregando una opción a las funciones gráficas (los
marcados con (*) en la tabla de parámetros gráficos de R). Veamos dos casos:
1) Si nos interesa que el fondo de la ventana gráfica tenga color amarillo y no transparente,
comenzamos con la orden par(bg=”yellow”) que abrirá una ventana gráfica. Todos los gráficos que
construyamos después de esa orden se mostrarán con un fondo amarillo, siempre que no cerremos
la ventana gráfica (si la cerramos el valor de bg vuelve a “transparent”).
2) Si deseamos obtener más de un gráfico en una misma ventana gráfica, empezamos con el primero,
luego damos la orden par(new=TRUE), seguimos con el segundo gráfico, reiteramos la orden
par(new=TRUE) y así sucesivamente (debemos estar atentos a los extremos de los intervalos de los
ejes y a los textos de ellos). Al cerrar la ventana gráfica, el valor de new vuelve a FALSE.

C – Gráficos de funciones reales de una variable real

En R están las tradicionales funciones reales de una variable real : abs (valor absoluto), ceiling (ceiling(x)
es el menor entero mayor o igual que x) floor (floor(x) es el mayor entero menor o igual que x), sign
(signo), sqrt (raíz cuadrada), exp (exponencial), log (logaritmo en base e), logb (logaritmo en base b),
funciones hiperbólicas y sus inversas (cosh, sinh, tanh, acosh, asinh y atanh) y funciones trigonométricas
y sus inversas (cos, sin, tan, acos, asin y atan).
35
Podemos obtener el gráfico de esas funciones o de combinaciones de ellas con la orden
curve(e,from=a,to=b,n=c,add=d), donde
- e es una expresión que indica la función a dibujar (x es la variable de la función).
- a y b son dos números que fijan los extremos del intervalo en el eje horizontal. Si no se usa esta
opción, R elige a = 0 y b = 1 cuando add=FALSE o los valores de a y b del gráfico anterior cuando
add=TRUE.
Puede usarse la opción xlim en vez de las opciones from y to.
- n es el número de valores de x para los que se calcula el valor de la función. Si no se usa esta
opción, R toma n = 101.
- d indica si un nuevo gráfico se agrega a uno ya existente (TRUE) o si lo elimina (FALSE). Si no se
usa esta opción, R toma d = FALSE.
Además de lo anterior, podemos usar en la función curve las opciones que detallamos para la función
plot y parámetros gráficos. Es importante que tengamos en cuenta que si no usamos la opción type, R
toma type=”l” (esto puede producir un gráfico incorrecto para funciones discontinuas) .
A continuación mostramos el resultado de construir cuatro gráficos en una ventana gráfica.
f(x) = sgn(x) con type="l" f(x) = sgn(x) con type="p"

1.0
1.0
0.5
0.5
f(x)
f(x)
0.0
0.0
-0.5
-0.5
-1.0
-1.0
-2 -1 0 1 2 -2 -1 0 1 2
x x
Dos funciones: f y g f(x) = sen(x) + cos(x)

1.5
10
0.5 1.0
f (x ) = x + 1
2
8
f(x) y g(x)
f (x) = x + 3
f(x)
-0.5
4
2
-1.5
-3 -2 -1 0 1 2 3 -6 -4 -2 0 2 4 6
x x

Para obtener lo anterior procedimos así:
1) Usamos la orden par(mfrow=c(2,2)) para abrir una ventana gráfica partida en cuatro zonas.
2) Para el primer gráfico usamos la orden curve(sign,from= ‐2,to=2) a la que agregamos las siguientes
opciones: ylab=”f(x)”, cex=0.75, cex.main=0.75, cex.lab=0.75, cex.axis=0.75, main=’f(x) = sgn(x) con
type=”l”’.
3) Para el segundo gráfico usamos la orden anterior con dos cambios: agregamos la opción type=”p” y
modificamos la opción main.
4) Para el tercer gráfico comenzamos con la orden curve(x^2+1,from= ‐3,to=3) a la que agregamos las
siguientes opciones: ylab=”f(x) y g(x)”, cex=0.75, cex.main=0.75, cex.lab=0.75, cex.axis=0.75,
36
main=”Dos funciones: f y g”. Luego dimos la orden curve(x+3,add=TRUE) y finalmente agregamos

dos textos con text(0,8,expression(f(x)==x^2 + 1),cex=0.75) y text(0,6,”f(x) = x + 3”,cex=0.75).
5) Para el cuarto gráfico usamos la orden curve(sin(x)+cos(x),from=‐2*pi,to=2*pi) con el agregado de:
ylab=”f(x)”, cex=0.75, cex.main=0.75, cex.lab=0.75, cex.axis=0.75, main=”f(x) = sen(x) + cos(x)”.

D – Gráficos de funciones reales de dos variables reales

Para dibujar el gráfico de una función f real de dos variables reales usamos la orden
persp(x,y,z), donde x e y son vectores numéricos con componentes en orden creciente y z es una
matriz, cuyos números de filas y columnas son respectivamente las longitudes de x e y, tal que z[i,j]
es el valor de la función f en el punto de abscisa x[i] y ordenada y[j]. Para construir la matriz z, una
vez que se tienen x e y, suele ser útil usar la orden z=outer(x,y,function(x,y) {...}).
Las principales opciones de la función persp son:
- xlim, ylim, zlim
Establecen intervalos para los tres ejes del gráfico (sus valores se especifican igual que en plot).
Si no se usa esta opción, R elige los intervalos.
- xlab, ylab, zlab
Establecen textos para los tres ejes del gráfico (sus valores se especifican igual que en plot).
Si no se usa esta opción, R elige los textos.
- main, sub
Establecen el título principal y el subtítulo del gráfico (sus valores se especifican igual que en plot).
El valor por defecto es NULL (sin título).
- box
Establece si se dibujarán los bordes de la caja gráfica (box=TRUE) o no (box=FALSE). El valor por
defecto es TRUE.
- axes
Establece si se dibujarán los ejes del gráfico (axes=TRUE) o no (axes=FALSE). El valor por defecto es
TRUE. En el caso que box=FALSE, R asume que axes=FALSE.
- ticktype
Establece si se dibujará sólo una flecha paralela a cada eje del gráfico indicando su sentido positivo
(ticktype=”simple”) o si se procederá como en plot (ticktype=”detailed”). El valor por defecto es
“simple”.
- nticks
Establece el número (aproximado) de marcas a dibujar en los ejes del gráfico. El valor por defecto es
5. Esta opción es irrelevante cuando ticktype=”simple”.
- col
Establece el color de la superficie a dibujar. El valor por defecto es “white”.
- border
Establece el color de las líneas de la superficie a dibujar o la ausencia de tales líneas (border=NA). El
valor por defecto es NULL que motiva que R tome el color de par(“fg”).
- theta, phi
Establecen (en grados) el acimut y la latitud. Los valores por defecto son theta=0 y phi=15.
- r
Establece la distancia entre el centro de la caja gráfica y el ojo del observador. El valor por defecto
es 3 .
- expand
Establece un factor de ajuste para los valores en el eje de las cotas. El valor por defecto es 1.
También podemos usar parámetros gráficos en la función persp.
A modo de ejemplo, veamos cómo dibujar una función cuyo gráfico es una “silla de montar”:
1) Definimos los vectores x= ‐5:5, y=x y la matriz z=outer(x,y,function(x,y) {x^2‐y^2}).
2) Usamos la orden persp(x,y,z) a la que agregamos las siguientes opciones: zlab=”f(x,y)”, cex=0.75,
cex.main=0.75, cex.lab=0.75, cex.axis=0.75, main=expression(f(x,y)==x^2‐y^2), ticktype=”detailed”,
col=”grey”, theta=30, phi=30.

37
f(x, y) = x − y
2 2
20
10
f(x, y)
-10
4
-20
2
-4 0
y
-2
0 -2
x
2
-4
4

Para obtener curvas de nivel de una función real de dos variables reales usamos la orden
contour(x,y,z), donde x, y, z tienen el mismo significado que en persp.
Las principales opciones de la función contour son:
- xlim, ylim, zlim
Establecen intervalos para los dos ejes del gráfico y para los valores de la función (sus valores se
especifican igual que en plot).
Si no se usa esta opción, R elige los intervalos.
- main, sub
- axes
Establece si se dibujarán los ejes (axes=TRUE) o no (axes=FALSE). El valor por defecto es TRUE.
- frame.plot
- nlevels
Establece el número de curvas de nivel que se dibujarán. El valor por defecto es 10.
- col
Establece el color de las curvas de nivel. Si no se usa esta opción, R toma el color de par(“fg”).
- labcex
Establece el tamaño del texto en las curvas de nivel, el cual no es un factor a aplicar a par(“cex”) . El
valor por defecto es 0.6.
- add
Establece si el nuevo gráfico se agrega a uno ya existente (TRUE) o si lo elimina (FALSE). El valor por
defecto es FALSE.
38
También podemos usar parámetros gráficos tales como: cex.main, cex.sub, cex.axis, col.main, col.sub,

col.axis, family, font.main, font.sub, font.axis, lty y lwd.
En el caso de la función f(x , y) = x 2 − y 2 , obtuvimos el gráfico de algunas de sus curvas de nivel usando
la orden contour(x,y,z), con el agregado de: main=expression(f(x,y)==x^2‐y^2), sub=”Curvas de nivel”,
cex.main=0.75, cex.sub=0.75 y cex.axis=0.75.
f(x, y) = x − y
2 2
-20 -10
4
-15
-5
2
0
20
20
0
15
15
-2
0
10
10
-5
-4
-15
5 5
- 10 -20
-4 -2 0 2 4
Curvas de nivel

E – Gráficos de series de tiempo

Para dibujar series de tiempo R cuenta con dos funciones gráficas de alto nivel: plot.ts y ts.plot. La
primera de esas funciones(plot.ts) es útil para una serie de tiempo multivariada y la segunda (ts.plot)
para una o más series de tiempo con igual frecuencia (pueden abarcar distintos períodos).
La orden
plot.ts(s) , donde s es una serie de tiempo multivariada,
tiene como principales opciones:
- main, sub
- plot.type
Establece si se dibujará un único gráfico con las distintas series de tiempo univariadas de s (“single”)
o si se dibujará un gráfico para cada una de esas series de tiempo univariadas (“multiple”). El valor
por defecto es “multiple”.
39
- nc
Establece el número de columnas en que se partirá la caja gráfica cuando plot.type=”multiple”. El
valor por defecto es 1 cuando el número de series de tiempo univariadas de s no supera a cuatro y 2
en caso contrario.
- yax.flip
Establece, cuando plot.type=”multiple” si los nombres de las series, las marcas y los números en el
eje vertical se ubicarán a la izquierda de ese eje (FALSE) o alternativamente a la izquierda y a la
derecha (TRUE). El valor por defecto es FALSE.
- axes
Establece si se dibujarán los ejes del gráfico (axes=TRUE) o no (axes=FALSE). El valor por defecto es
TRUE.
- frame.plot
También podemos usar parámetros gráficos tales como: cex.main, cex.sub, col.main, col.sub, font.main
y font.sub. En el caso que plot.type=”single” es interesante que tengamos en cuenta la posibilidad de
establecer un color (col), un tipo de línea (lty) y un grosor de línea (lwd) para cada serie de tiempo
univariada de s; eso lo logramos asignando un vector numérico a cada uno de esos tres parámetros .

Los parámetros gráficos col y lty en la orden plot.ts con plot.type=”single”

col Lty
Número Color Número Tipo de línea
1 Negro. 1 Sólida.
2 Rojo. 2 Quebrada.
3 Verde. 3 Punteada.
4 Azul. 4 Punto seguido de línea.
5 Celeste. 5 Línea larga seguida de línea corta.
6 Violeta. 6 Dos líneas cortas.
7 Amarillo.
8 Gris.

Series 1 Series 2 Series 3 Series 4
1 5 3 3 8
2 6 6 8 5
3 6 0 5 6
4 6 4 2 5
En las próximas dos páginas construiremos dos 5 4 5 4 4
gráficos a partir de la serie multivariada s que 6 3 2 5 5
consta a la derecha. Esa serie está formada por 7 1 4 5 4
cuatro series univariadas, cada una de las cuales es 8 5 6 7 3
aleatoria pues la obtuvimos al seleccionar una 9 6 5 2 3
muestra de tamaño 20 de la distribución binomial
10 8 7 8 2
de parámetros n = 10 y p = 0,5.
11 5 5 3 5
Para llegar a los dos gráficos usamos la función
12 4 5 7 2
plot.ps con una diferencia significativa:
13 4 3 7 4
1) En el primero, plot.type=”multiple”.
2) En el segundo, plot.type=”single”. 14 4 5 4 4
Señalemos, además, que plot.ts puede abreviarse a 15 5 6 6 2
plot. 16 2 5 5 7
17 4 6 4 4
18 4 2 5 5
19 1 3 5 5
20 5 3 6 3

40
Cuatro series de tiempo; plot.ts con plot.type="multiple"
8
7
7
6
6
Series 1
Series 3
5
5
4
4
3
3
2
1
2
7
8
6
7
5
6
Series 2
Series 4
4
5
3
4
2
3
1
0
2
5 10 15 20 5 10 15 20
Time Time
Para obtener el gráfico anterior usamos la orden plot.ts(s) a la que agregamos las siguientes opciones:
- main=’Cuatro series de tiempo; plot.ts con plot.type=”multiple”’
- nc=2
- yax.flip=TRUE
- cex.main=0.75.
En lo que se refiere al gráfico de la próxima página, también usamos la orden plot.ts(s) pero ahora con
las siguientes opciones:
- plot.type=”single”.
- main=’Cuatro series de tiempo. Uso de plot.ts con plot.type=”single”’.
- sub=”Series: 1 punteada negra; 2 sólida gris; 3 punteada gris; 4 sólida negra”.
- cex.main=0.75 y cex.sub=0.75.
- lty=c(3,1,3,1) y col=c(1,8,8,1).

41
Cuatro series de tiempo. Uso de plot.ts con plot.type="single"
8
6
4
s
2
0
5 10 15 20
Time
Series: 1 punteada negra; 2 sólida gris; 3 punteada gris; 4 sólida negra

Pasemos a la orden
ts.plot(s1,s2,...), donde s1, s2, ... son series de tiempo con igual frecuencia tales que cada una de
ellas puede ser univariada o multivariada.
A esta orden podemos agregarle los parámetros gráficos col, lty y lwd en la forma que indicamos para la
orden plot.ts.
A modo de ejemplo, construimos el gráfico que aparece en la próxima página con la orden ts.plot(s) a la
que le agregamos las siguientes opciones:
- main=”Cuatro series de tiempo. Uso de ts.plot”.
- sub=”Series: 1 punteada negra; 2 sólida gris; 3 punteada gris; 4 sólida negra”.
- lty=c(3,1,3,1) y col=c(1,8,8,1).
Nos reencontramos con el gráfico que habíamos obtenido con plot.ts y plot.type=”single”. Sin embargo,
no pudimos reducir el tamaño ni del título ni del subtítulo. ¿Hay algo, entonces, que nos lleve a optar
por ts.plot en vez de plot.ts y plot.type=”single”? La respuesta es afirmativa cuando estamos ante series
que abarcan distintos períodos (en ese caso no podemos usar plot.ts).

42
Cuatro series de tiempo. Uso de ts.plot
8
6
4
2
0
5 10 15 20
Time
Series: 1 punteada negra; 2 sólida gris; 3 punteada gris; 4 sólida negra

43
F – Gráficos de símbolos

A esta altura es bueno algún pasatiempo estético. Con ese fin nos ocuparemos de la función de alto
nivel symbols.
Podemos obtener el gráfico de ciertos símbolos con la orden
symbols(x,y,Símbolo=a,inches=b,add=c,fg=d,bg=e), donde
- x e y son números que fijan la abscisa y la ordenada del centro del símbolo (también pueden
ser vectores de igual longitud, pero no consideraremos esa posibilidad).
- Símbolo y a son los que detallamos a continuación:

Símbolo a
circles Un número que es el radio del círculo.
squares Un número que es la longitud del lado del cuadrado.
rectangles Una matriz numérica de una fila y dos columnas cuyos números son las longitudes de la base y de
la altura del rectángulo.
stars Una matriz numérica de una fila y tres o más columnas cuyos números son las longitudes de los
rayos desde el centro de la estrella.
thermometers Una matriz numérica de una fila y tres o cuatro columnas cuyos dos primeros números son las
longitudes de la base y de la altura del termómetro; el tercer número (entre 0 y 1) indica, cuando
no hay un cuarto número, qué parte del termómetro, desde la base, será coloreada con lo
establecido en fg (ese número afecta a la altura del termómetro). Si hay un cuarto número (mayor
que el tercero y menor que 1) este número y el tercero indican qué parte del termómetro será
coloreada con lo establecido en fg (esos números afectan a la altura del termómetro). El resto del
termómetro será coloreado con lo establecido en bg.
boxplots Una matriz numérica de una fila y cinco columnas: los dos primeros números son las longitudes de
la base y de la altura de la caja, el tercero (menor que el primero) y el cuarto (mayor que el
segundo) indican los extremos del mango de la caja y el quinto (entre 0 y 1) se aplica a la altura de
la caja para fijar la posición de una línea intermedia en ella.

- b indica la unidad de medida usada en el símbolo: una pulgada para la mayor de las longitudes
del símbolo (TRUE) o la unidad del eje que corresponda (FALSE). El valor por defecto es TRUE.
Para evitar sorpresas, recomendamos usar inches=FALSE y la opción as=1 en la orden symbols.
- c indica si un nuevo gráfico se agrega a uno ya existente (TRUE) o si lo elimina (FALSE). Si no se
usa esta opción, R toma d = FALSE.
- d indica el color del símbolo y de las partes destacadas del termómetro. Si no se usa esta
opción, R toma el color de par(“col”).
- e indica el color del interior del símbolo. El valor por defecto es NA que lleva a que no se
coloree el interior del símbolo.
Además de lo anterior, podemos usar en la función symbols las opciones que detallamos para la función
plot (salvo type) y parámetros gráficos.
La siguiente secuencia de órdenes motivan el gráfico que está en la próxima página:
1) plot(0:30, 0:30, type=”n”, main=”Círculos, cuadrados, rectángulos, estrellas, termómetros y cajas”,
xlab=”Abscisas del centro”, ylab=”Ordenadas del centro”, as=1, cex.main=0.75, cex.lab=0.75,
cex.axis=0.75).
2) symbols(3,12,circles=2,inches=FALSE,add=TRUE,bg=”grey”).
3) symbols(2,20,squares=4,inches=FALSE,add=TRUE,bg=” dark grey”).
4) symbols(25,6,rectangles=matrix(c(4,3),ncol=2),inches=FALSE,add=TRUE,bg=”grey”).
5) symbols(15,25,stars=matrix(c(2,2,2,2,2,2),ncol=6),inches=FALSE,add=TRUE,bg=” dark grey”).
6) symbols(15,15,stars=matrix(c(1,2,3,4),ncol=4),inches=FALSE,add=TRUE,bg=” grey”).
7) symbols(22,23,thermometers=matrix(c(4,6,0.3),ncol=3),inches=FALSE,add=TRUE,bg=” dark grey”).
8) symbols(27,15,thermometers=matrix(c(4,6,0.3,0.7),ncol=4),inches=FALSE,add=TRUE,bg=”grey”).
9) symbols(9,5,boxplots=matrix(c(4,2,1,6,0.8),ncol=5),inches=FALSE,add=TRUE,bg=” dark grey”).

44
Círculos, cuadrados, rectángulos, estrellas, termómetros y cajas
30
25
Ordenadas de los centros
20
15
10
5
0
0 5 10 15 20 25 30
Abscisas de los centros

45
REFERENCIAS BIBLIOGRÁFICAS

♣ R Development Core Team
Introducción a R. Notas sobre R: Un entorno de programación para Análisis de Datos y Gráficos.
Año 2000 (Disponible en Internet)

♣ Emmanuel Paradis
R para Principiantes
Año 2003 (Disponible en internet)

♣ Sebastián Castro
Álgebra Lineal con R
Año 2009 (scastro.uy@gmail.com)
46

INDICE
I Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
II Los objetos de R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
A Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
B Factor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
C Matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
D Arreglo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
E Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
F Hoja de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
G Serie de tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
III Creación de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
IV Programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
V Guardar y recuperar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
A Guardar y recuperar programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
B Guardar y recuperar objetos creados en R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
C Recuperar archivos de datos creados fuera de R . . . . . . . . . . . . . . . . . . . . . . . . 23
D Recuperar archivos de datos que suministra R . . . . . . . . . . . . . . . . . . . . . . . . . . 24
VI Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
A Gráficos de puntos, rectas, segmentos, flechas, rectángulos y polígonos . . . . 25
B Algunas funciones gráficas y algunos parámetros gráficos . . . . . . . . . . . . . . . . 30
C Gráficos de funciones reales de una variable real . . . . . . . . . . . . . . . . . . . . . . . 34
D Gráficos de funciones reales de dos variables reales . . . . . . . . . . . . . . . . . . . . . 36
E Gráficos de series de tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
F Gráficos de símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Referencias bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45


R para Novatos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

R para Novatos

Enviado por

Direitos autorais:

Formatos disponíveis

para novatos

Notas escritas por uno de ellos

Gráfico parcial de una sucesión s

Gráfico parcial de una sucesión s

¿Qué sugiere el dibujo sobre

Rectas, segmentos, flechas, rectángulos y polígonos

Cociente de primos consecutivos

0 50 100 150 200 250

Cociente de primos consecutivos

0 50 100 150 200 250

Cociente de primos consecutivos

200 210 220 230 240 250

Cociente de primos consecutivos

200 210 220 230 240 250

f(x) = sgn(x) con type="l" f(x) = sgn(x) con type="p"

Dos funciones: f y g f(x) = sen(x) + cos(x)

main=”Dos funciones: f y g”. Luego dimos la orden curve(x+3,add=TRUE) y finalmente agregamos

También podemos usar parámetros gráficos tales como: cex.main, cex.sub, cex.axis, col.main, col.sub,

Cuatro series de tiempo; plot.ts con plot.type="multiple"

Cuatro series de tiempo. Uso de plot.ts con plot.type="single"

Cuatro series de tiempo. Uso de ts.plot

Círculos, cuadrados, rectángulos, estrellas, termómetros y cajas

Abscisas de los centros

Você também pode gostar