Practica 2 G

1 | Práctica 2: Simulación con R
Objetivos
Asignar nombres a los elementos de un vector.
Trabajar con ı́ndices lógicos.
Trabajar con matrices.
Realizar simulaciones de experimentos aleatorios.
Trabajar con funciones de probabilidad y de densidad.
Generar datos correspondientes a los modelos de distribución de probabilidad

más usuales.
1.1. Otros tipos de datos en R

Como vimos en la Práctica 1, la forma más sencilla de definir un vector con datos
es usar la función c():
> x<-c(3.141592, 2.718281, 1.618034)

> x
[1] 3.141592 2.718281 1.618034
La forma de acceder a los elementos del vector era la siguiente:
> x[2]
[1] 2.718281
> x[3]
[1] 1.618034
Se pueden asignar nombres a los elementos de un vector mediante la función

names():
1
2 1.2 Variables lógicas en R
> names(x)<-c("pi", "e", "phi")

> x
pi e phi
3.141592 2.718281 1.618034
Los valores de π y e se pueden obtener en R con
> pi
[1] 3.141593
> exp(1)
[1] 2.718282
phi es también conocido como el número áureo y es igual a
> (1+sqrt(5))/2
[1] 1.618034
Ahora, si queremos referirnos at tercer elemento, podemos optar por x[3] o, dado
que hemos asignado nombres a los elementos del vector, podemos hacer
> x["phi"]
phi
1.618034
1.2. Variables lógicas en R

1.2.1. Índices lógicos
Supongamos ahora que tenemos el vector
> x<-1:5
podemos ver qué elementos son iguales a 4 utilizando el operador ==:
> x==4
[1] FALSE FALSE FALSE TRUE FALSE
La instrucción anterior devuelve un vector de valores lógicos (o booleanos). FALSE

indica que la condición anterior (es decir, ser igual a cuatro) no se cumple mientras
que TRUE indica que sı́ se cumple.
De manera análoga podemos hacer comparaciones con <, >, <= y >=:
Práctica 2: Simulación con R 3
> x<4
[1] TRUE TRUE TRUE FALSE FALSE
> x>=4
[1] FALSE FALSE FALSE TRUE TRUE
Si aplicamos la función sum() al vector lógico resultante, R fuerza TRUE al valor

numérico 1 y FALSE al 0, de manera que tenemos el número de elementos del vector
x que cumplen la condición impuesta:
> sum(x<4)
[1] 3
> sum(x>=4)
[1] 2
Generaremos un vector aleatorio de 100 números entre 0 y 1 de manera similar a

como hicimos en la Práctica 1.
> set.seed(111)
> y<-runif(100)
La media de este vector es
> mean(y)
[1] 0.4895239
Contamos cuántos valores están por debajo de la media:
> sum(y<mean(y))
[1] 51
o cuántos por debajo de la mediana
> sum( y<median(y) )
[1] 50
Veamos ahora el efecto que tiene colocar un vector lógico entre los corchetes de
ı́ndice de un vector:
> z<-1:5
> z[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
4 1.2.2 Condiciones lógicas compuestas
[1] 1 3 5
donde el vector lógico c(TRUE, FALSE, TRUE, FALSE, TRUE) es uno de igual longi-
tud que x y donde TRUE y FALSE representan verdadero y falso, respectivamente.
El efecto de la instrucción es el de devolver únicamente aquellos valores de x cuyo
ı́ndice valga TRUE.
La instrucción y[y<0.1] devuelve no cuántos, sino cuáles son los valores que
cumplen la condición de estar por debajo de 0.1:
> y[y<0.1]
[1] 0.0106578451 0.0936815199 0.0671411434 0.0475478533 0.0585964625

[6] 0.0327716474 0.0965785654 0.0009253006 0.0525656715 0.0117258150
[11] 0.0533223320 0.0951241532 0.0866140136
1.2.2. Condiciones lógicas compuestas

Podemos utilizar otros operadores lógicos dentro de los corchetes, con condiciones
compuestas. La instrucción siguiente, en la que | es el operador lógico o, devuelve
aquellos valores de y que están por debajo de 0.05 o por encima de 0.95:
> y[(y<0.05)|(y>0.95)]
[1] 0.0106578451 0.0475478533 0.9665342933 0.9675274789 0.0327716474

[6] 0.9967166614 0.0009253006 0.0117258150 0.9837744189 0.9935344572
[11] 0.9750010339
Veamos que son 11. Si quisiéramos contarlos solamente, pondrı́amos:
> sum( (y<0.05)|(y>0.95) )
[1] 11
Pero si queremos sumar los valores que cumplen la condición anterior:
> sum(y[ (y<0.05)|(y>0.95) ] )
[1] 5.986717
Podrı́amos desear los valores de y que están por encima de 0.45 y por debajo de
0.55:
> y[(y>0.45)&(y<0.55)]
[1] 0.5149238 0.5322952 0.5098999 0.4657924 0.4693591 0.5482734

[7] 0.4563152 0.4667440 0.4537648 0.5110990
donde & es el operador lógico y.

La función which devuelve las posiciones en el vector de aquellos valores que
cumplen la condición:
> which( (y>0.45)&(y<0.55) )
[1] 4 8 32 33 34 56 58 62 73 91
Estas son las posiciones que ocupan los 89 valores que obtuvimos anteriormente.
En resumen, en este apartado hemos visto cuáles, cuántos y qué posiciones ocupan
los valores que cumplen con determinadas condiciones impuestas.
Poner un ejemplo de detección de valores anómalos usando el diagrama
de cajas
1.2.3. Exclusión de valores

Sea
> z<-3:10
la instrucción z[-1] devuelve un vector igual al original de que se ha eliminado el

primer elemento:
> z[-1]
[1] 4 5 6 7 8 9 10
Si lo que deseamos es eliminar los tres primeros elementos, entonces debemos

hacer
> z[-(1:3)]
[1] 6 7 8 9 10
O los tres últimos
> z[-((length(z)-2):length(z))]
[1] 3 4 5 6 7
Si bien puede parecer más natural, para el mismo objetivo podemos usar
> rev(z)[-(1:3)]
[1] 7 6 5 4 3
que nos da un vector resultante en orden inverso al original, aspecto que se puede
corregir con
6 1.3 Matrices en R
> rev(rev(z)[-(1:3)])
[1] 3 4 5 6 7
si, por lo que fuera, nos interesa conservar el orden.

Con
> z[-which(z<6)]
[1] 6 7 8 9 10
excluimos aquellos valores menores que 6.

Si queremos recortar los dos valores extremos menores y los dos mayores del vector,
podemos hacer:
> w<-c(5,2,8,5,4,6,9,9)
> w
[1] 5 2 8 5 4 6 9 9
> rev(sort(w)[-c(1,2)])[-c(1,2)]
[1] 8 6 5 5
Expresión en la que, primero, hemos ordenado el vector original con sort, luego,
excluido los valores menores, a continuación, hemos invertido el vector resultante con
rev y, finalmente, hemos suprimido los dos primeros valores, que son los dos mayores
del vector original.
1.3. Matrices en R
Además de los objetos vistos hasta aquı́, introducimos ahora este nuevo tipo para
crear matrices con el comando matrix(). Podemos crear una matriz a partir de un
vector
> x<-1:12
> y<-matrix(x,nrow=3)
> y
[,1] [,2] [,3] [,4]

[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
Con matrix, se crea una matriz de tres filas (nrow=3) a partir de un vector (x) de
longitud 12. Nótese que los valores del vector se introducen, por defecto, por columnas.
El mismo efecto podrı́a haberse conseguido con
> y<-matrix(x,ncol=4)
> y
[,1] [,2] [,3] [,4]

[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
y se crea la misma matriz con 4 columnas y, por lo tanto, tres filas, pues ncol=4
obliga a que ası́ sea. Si queremos que se introduzcan por filas, se ha de proceder ası́:
> y<-matrix(x,nrow=3, byrow=TRUE)

> y
[,1] [,2] [,3] [,4]

[1,] 1 2 3 4
[2,] 5 6 7 8
[3,] 9 10 11 12
Véase el efecto de
> y<-matrix(x,ncol=3, byrow=TRUE)

> y
[,1] [,2] [,3]

[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
con lo que se ha construido una matriz de tres columnas, con los datos introducidos
por filas. Podemos, también, convertir directamente el vector original en una matriz
redefiniendo las dimensiones del vector.
Véase
> class(x)
[1] "integer"
que nos muestra que x es un vector de enteros y el efecto que tiene el redimensionar
x con la función dim
> dim(x)<-c(3,4)
> x
[,1] [,2] [,3] [,4]

[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
8 1.3 Matrices en R
> class(x)
[1] "matrix"
que nos muestra que, ahora, x ya no es más un vector y que ha pasado a ser una
matriz. Se pueden asignar nombres a filas y columnas con rownames y colnames
> rownames(x)<-c("lunes","martes","miércoles")
> x
[,1] [,2] [,3] [,4]

lunes 1 4 7 10
martes 2 5 8 11
miércoles 3 6 9 12
Podemos referirnos a los elementos de una matriz indicando la posición (de la fila
y la columna) con corchetes:
> x[1,2]
lunes
4
o bien por medio de los nombres de la fila y columna, si los tiene
> colnames(x)<-c("marzo","abril","mayo","junio")
> x["lunes","abril"]
[1] 4
Podemos referir una columna de esta manera
> x[,2]
lunes martes miércoles

4 5 6
que nos muestra los elementos de la columna 2 (aunque mostrados en forma de fila).
O bien la fila 3
> x[3,]
marzo abril mayo junio

3 6 9 12
Nótese cómo, tanto en un caso como en otro, la ausencia de número en la fila

o columna se puede leer como “para todas las filas” y “para todas las columnas”,
respectivamente. Podemos seleccionar las dos primeras filas de la matriz ası́:
> x[1:2,]

lunes 1 4 7 10
martes 2 5 8 11
O bien, excluirlas
> x[-(1:2),]

3 6 9 12
1.3.1. Operaciones con matrices

Calcular la suma de todos los elementos de la matriz
> sum(x)
[1] 78
o bien, la media de todos los elementos
> mean(x)
[1] 6.5
o bien, la matriz de varianzas/covarianzas
> var(x)

marzo 1 1 1 1
abril 1 1 1 1
mayo 1 1 1 1
junio 1 1 1 1
matriz en la que el elemento x[i,i] representa la varianza de la columna x[,i], y

el x[i,j], con i 6= j, la covarianza de las columnas x[,i] y x[,j].
Calcular la media de valores de la segunda columna
> mean(x[,2])
[1] 5
o, bien la varianza de la segunda fila
> var(x[2,])
10 1.3.1 Operaciones con matrices
[1] 15
Calcular las sumas de los elementos dentro de cada columna
> colSums(x)

6 15 24 33
o las medias de las mismas
> colMeans(x)

2 5 8 11
o las sumas de los elementos dentro de cada fila
> rowSums(x)

22 26 30
Con summary, función que es sensible al contexto
> summary(x)

Min. :1.0 Min. :4.0 Min. :7.0 Min. :10.0
1st Qu.:1.5 1st Qu.:4.5 1st Qu.:7.5 1st Qu.:10.5
Median :2.0 Median :5.0 Median :8.0 Median :11.0
Mean :2.0 Mean :5.0 Mean :8.0 Mean :11.0
3rd Qu.:2.5 3rd Qu.:5.5 3rd Qu.:8.5 3rd Qu.:11.5
Max. :3.0 Max. :6.0 Max. :9.0 Max. :12.0
obtenemos resúmenes por columnas.

Con apply podemos aplicar funciones como var para calcular las varianzas de los
elementos de cada una de las filas
> apply(x,1,var)

15 15 15
donde el parámetro 1 indica que trabajamos por filas y podrı́amos añadir una nueva
columna a la matriz x con estas varianzas, mediante cbind:
> xx<-cbind(x,apply(x,1,var))
> xx

lunes 1 4 7 10 15
martes 2 5 8 11 15
miércoles 3 6 9 12 15
y podrı́amos nombrar “varianzas” a la última columna añadida:
> colnames(xx)<-c(colnames(x),"varianzas")
> xx
marzo abril mayo junio varianzas

lunes 1 4 7 10 15
martes 2 5 8 11 15
miércoles 3 6 9 12 15
Análogamente, podemos trabajar por columnas con
> apply(x,2,var)

1 1 1 1
donde el parámetro 2 indica que trabajamos por columnas y podrı́amos añadir esta
fila a la matriz:
> xxx<-rbind(x,apply(x,2,var))
> xxx

lunes 1 4 7 10
martes 2 5 8 11
1 1 1 1
y darle nombre a la nueva fila:
> rownames(xxx)<-c(rownames(xx),"varfil")
> xxx

lunes 1 4 7 10
martes 2 5 8 11
varfil 1 1 1 1
12 1.3.1 Operaciones con matrices
Producto de matrices:
> x<-matrix(1:4,nrow=2)
> y<-matrix(2:5,nrow=2)
> x
[,1] [,2]
[1,] 1 3
[2,] 2 4
> y
[,1] [,2]
[1,] 2 4
[2,] 3 5
> x%*%y
[,1] [,2]
[1,] 11 19
[2,] 16 28
Producto por un escalar:
> 2*x
[,1] [,2]
[1,] 2 6
[2,] 4 8
Suma y resta de matrices:
> x+y
[,1] [,2]
[1,] 3 7
[2,] 5 9
> x-y
[,1] [,2]
[1,] -1 -1
[2,] -1 -1
Crear una matriz diagonal:
> z<-diag(c(2,-1,3))
> z
[,1] [,2] [,3]

[1,] 2 0 0
[2,] 0 -1 0
[3,] 0 0 3
Modificar la diagonal:
> diag(z)<-c(4,3,3)
> z
[,1] [,2] [,3]

[1,] 4 0 0
[2,] 0 3 0
[3,] 0 0 3
Hallar un determinante:
> det(x)
[1] -2
Hallar la inversa de una matriz:
> solve(x)
[,1] [,2]
[1,] -2 1.5
[2,] 1 -0.5
y comprobamos que la matriz por su inversa es la identidad:
> x%*%solve(x)
[,1] [,2]
[1,] 1 0
[2,] 0 1
No confundir el producto %* % con el producto *.

Producto Hadamard (es decir, elemento a elemento) de dos matrices:
> x*y
[,1] [,2]
[1,] 2 12
[2,] 6 20
es la matriz cuyos elementos son el producto de los elementos homónimos de las

matrices que se multiplican.
14 1.4 Simulaciones
1.4. Simulaciones
La función sample es muy útil para efectuar simulaciones
> sample(1:10,6)
[1] 6 2 8 9 5 1
extrae del vector 1:10, seis elementos al azar sin repetición.
> sample(1:10,6,rep=TRUE)
[1] 7 3 6 10 2 7
extrae del mismo vector 6 elementos en los que se admite repetición.
1.4.1. Dados
Para simular la tirada de un dado podemos utilizar
> sample(1:6,1)
[1] 6
Para simular la tirada de 4 dados, o de un mismo dado 4 veces, podemos utilizar
> sample(1:6,4,rep=TRUE)
[1] 6 6 4 4
admitiendo repetición.
Si queremos simular la distribución de la suma de los números que salen al tirar
4 dados
> t<-sapply(1:10000,function(x){sum(sample(1:6,4,rep=TRUE))})
donde la función sapply aplica a un vector de tamaño 10000 (el que va de 1 a 10000)
una función sin nombre, generando a su vez un vector de tamaño 10000. La función
obtiene muestras con repetición de tamaño 4 y, a continuación, suma los números de la
muestra. Este proceso se repite 10000 veces. Lo mismo se podrı́a haber conseguido con
un ciclo for, pero el procedimiento utilizado es más rápido. Para garantizar que los
resultados son los mismos que los de esta práctica, nos servimos de set.seed(111).
> set.seed(111)
y tabulamos los resultados con

> table(t)
t
4 5 6 7 8 9 10 11 12 13 14 15 16 17
11 31 82 170 263 417 633 773 976 1086 1121 1131 971 754
18 19 20 21 22 23 24
598 467 230 154 75 49 8
y podemos representar los resultados con un diagrama de barras con
> barplot(table(t))
tal y como aparece en la Figura 1.1.

1000
800
600
400
200
0
4 6 8 10 12 14 16 18 20 22 24
Figura 1.1: Diagrama de barras de las frecuencias obtenidas del lanzamiento de cuatro
dados.
Se podrı́a haber procedido similarmente ası́:
> x<-runif(4,0,6)
> x
16 1.4.1 Dados
[1] 5.02819982 1.82267011 5.95054520 0.05559562
genera 4 números aleatorios uniformemente distribuidos entre 0 y 6.

La función
> ceiling(x)
[1] 6 2 6 1
transforma los valores anteriores en el menor entero no inferior al número (digamos

que el número siempre se redondea por arriba).
Combinando las dos instrucciones, se pueden generar números aleatorios entre 1
y 6.
> ceiling(runif(4,0,6))
[1] 1 4 6 1
Con la siguiente instrucción
> t<-sapply(1:10000,function(x){sum(ceiling(runif(4,0,6)))})
podrı́amos conseguir lo mismo que anteriormente con
Si lo que se quiere es simular el número de veces que sale, digamos, un seis, en,
por ejemplo, 10 tiradas, como el número de seises sigue una distribución binomial
de n=10 y p=1/6, podemos utilizar la función de R rbinom para generar números
aleatorios según esta distribución y realizar la simulación más cómodamente.
Con la siguiente expresión se generan 12 números aleatorios en las condiciones
antedichas
> xx<-rbinom(12,10,1/6)
> xx
[1] 4 2 3 3 1 2 1 0 2 1 1 3
que se interpreta ası́: en la primera tirada de 10 dados salieron 4 seises; en la segunda,

2; en la tercera, 3; etc.
Podemos generar 10000 números aleatorios con
> set.seed(111)
> t <- rbinom(10000, 10, 1/6)
que tabulamos con
> table(t)
t
0 1 2 3 4 5 6 7
1634 3209 2898 1572 537 127 20 3
y representamos con
> barplot(table(t))
según se puede ver en la Figura 1.2. Nótese que obtenemos un diagrama similar al
anteriormente obtenido en la Figura 1.1.
3000
2500
2000
1500
1000
500
0
0 1 2 3 4 5 6 7
Figura 1.2: Diagrama de barras de los éxitos obtenidos al simular de una Binomial.
1.4.2. Urnas
Tenemos una urna con 3 bolas blancas y 5 negras. Queremos simular la extracción
de una bola. El número 1 representa blanca y 0, negra. Podemos hacerlo con:
> bola<-sample(c(1,0),1,prob=c(3,5))
> bola
18 1.4.2 Urnas
[1] 0
En este caso, habrı́a salido negra.

Si queremos simular 10 extracciones con reposición podrı́amos escribir:
> bolas<-sample(c(1,0), 10 ,rep=TRUE,prob=c(3,5))

> bolas
[1] 0 1 0 1 0 0 0 1 0 0
En este caso, habrı́amos obtenido 3 bolas blancas en las 8 extracciones. Si lo que nos
interesa es sólo el número de bolas blancas, como este sigue una distribución binomial
con n=8 y p=3/8 podrı́amos escribir:
> rbinom(1,8,3/8)
[1] 2
Podemos simular 10000 extracciones de 8 bolas con reposición ası́:
> set.seed(111)
> t<-rbinom(10000,8,3/8)
y presentarlos en una tabla:
> table(t)
t
0 1 2 3 4 5 6 7 8
232 1168 2288 2797 2174 984 299 54 4
También podrı́amos hacer un diagrama de barras con los resultados usando
> barplot(table(t))
tal y como se ve en la Figura 1.3.

Los valores exactos de las probabilidades los da la función
> dbinom(0:8,8,3/8)
[1] 0.0232830644 0.1117587090 0.2346932888 0.2816319466 0.2112239599

[6] 0.1013875008 0.0304162502 0.0052142143 0.0003910661
donde 0:8 es el vector de 9 valores cuya probabilidad se calcula. Compárense estas

probabilidades con los valores aproximados en diezmilésimas obtenidos con table(t)
anteriormente.
2500
2000
1500
1000
500
0
0 1 2 3 4 5 6 7 8
Figura 1.3: Diagrama de barras con el número de bolas blancas extraı́das.
1.4.3. Barajas
Si estamos interesados en los oros que salen en una extracción de 12 cartas con
reposición, se trata de una distribución binomial con n=12 y p=10/40, ya que tenemos
10 cartas de oros de un total de 40 cartas en la baraja. Si repetimos el experimento
10000 veces obtenemos:
> t<-rbinom(10000,12,10/40)
> table(t)
t
0 1 2 3 4 5 6 7 8 9
307 1313 2287 2578 1907 1041 420 123 20 4
Si estuviésemos interesados en las figuras que salen en las mismas 12 extracciones

con reposición, se tratarı́a de una distribución binomial con n=12 y p=16/40.
20 1.4.4 Cola de espera para el autobús
1.4.4. Cola de espera para el autobús

Si suponemos que el número de personas en la cola de espera del autobús sigue
una distribución de Poisson de media 15 personas, la función
> t<-rpois(10000,15)
genera 10000 repeticiones de este experimento, que tabulamos con
> table(t)
t
2 4 5 6 7 8 9 10 11 12 13 14 15 16
1 11 19 63 98 217 344 489 661 805 938 1005 998 933
17 18 19 20 21 22 23 24 25 26 27 28 29 30
864 696 536 459 317 210 135 87 54 27 16 10 2 1
31
4
y representamos con
> barplot(table(t))
El resultado aparece en la Figura 1.4.

Los valores exactos de las probabilidades los da la función
> dpois(0:31,15)
[1] 3.059023e-07 4.588535e-06 3.441401e-05 1.720701e-04 6.452627e-04

[6] 1.935788e-03 4.839470e-03 1.037029e-02 1.944430e-02 3.240717e-02
[11] 4.861075e-02 6.628739e-02 8.285923e-02 9.560681e-02 1.024359e-01
[16] 1.024359e-01 9.603362e-02 8.473555e-02 7.061296e-02 5.574707e-02
[21] 4.181031e-02 2.986450e-02 2.036216e-02 1.327967e-02 8.299794e-03
[26] 4.979876e-03 2.873006e-03 1.596114e-03 8.550612e-04 4.422730e-04
[31] 2.211365e-04 1.070015e-04
con que obtenemos las probabilidades de los valores de 0 a 31, para una media de 15.
1.5. Funciones de densidad y probabilidad

1.5.1. Variables aleatorias discretas
Hasta aquı́ se han mencionado las funciones: rbinom(), rpois() y otras en las que
la r inicial se ha sustituido por d, relativas a la distribución binomial y de Poisson,
respectivamente. Todas ellas, desde el punto de vista del lenguaje R, responden al
mismo patrón. Lo vemos con la binomial. Para ésta, disponemos de 4 funciones, que
empiezan por las letras: d, p, q, y r.
1000
800
600
400
200
0
2 5 7 9 11 14 17 20 23 26 29
Figura 1.4: Diagrama de barras con el número de personas en la cola de espera del
autobús.
> dbinom(5,10,.3)
[1] 0.1029193
devuelve la probabilidad P (X = 5), es decir, que una variable aleatoria X con distri-
bución binomial (n=10 y p=0.3) tome el valor 5.
> pbinom(5,10,.3)
[1] 0.952651
devuelve P (X <= 5), con n=10 y p=0.3.
> pbinom(5,10,.3,lower.tail=FALSE)
[1] 0.04734899
devuelve P (X > 5), con n=10 y p=0.3.

22 1.5.2 Variables aleatorias continuas
> qbinom(0.952651,10,.3)
[1] 5
devuelve el cuantil 5, correspondiente a una probabilidad acumulada de 0.952651. Es

decir, que se cumple la relación P (X <= 5) = 0,952651.
> qbinom(0.04734899,10,.3, lower.tail=FALSE)
[1] 5
muestra el valor 5, que deja por encima de sı́ a 0.04734899 del total. O lo que es lo
mismo, P (X > 5) = 0,04734899.
> rbinom(5,10,.3)
[1] 2 4 5 2 1
genera 5 números aleatorios para una distribución binomial con n=10 y p=0.3.
Las restantes distribuciones rigen de modo análogo. Para saber qué parámetros
han de introducirse y en qué orden, se puede consultar la información disponible en
la ayuda. Por ejemplo ?dpois nos da la información correspondiente a las funciones
disponibles para la distribución de Poisson.
1.5.2. Variables aleatorias continuas

Ya hemos visto runif() de la familia de la distribución uniforme. Por ejemplo,
> runif(5, 0, 10)
[1] 7.307061 5.414401 3.165564 2.123067 4.071096
ha generado 5 valores al azar entre 0 y 10.

El código
> dunif(5,0,6)
[1] 0.1666667
devuelve el valor de la función de densidad en el 5 de la distribución uniforme entre

0 y 6.
De manera similar,
> punif(3,0,6)
[1] 0.5
devuelve P (X <= 3) en una uniforme entre 0 y 6

> punif(4,0,6,lower.tail=FALSE)
[1] 0.3333333
devuelve P (X > 4) en una uniforme entre 0 y 6.
> qunif(0.3,0,6)
[1] 1.8
devuelve el cuantil correspondiente a 0.3.
> qunif(0.6,0,6,lower.tail=FALSE)
[1] 2.4
devuelve el valor que deja por encima de sı́ a 0.6 del total. Es decir, P (X ≥ 2,4) = 0,6.
Por otro lado,
> runif(1,0,6)
[1] 1.518849
devuelve un número aleatorio para la distribución uniforme entre 0 y 6
Para las otras dos familias de funciones que nos interesan, la normal y la expo-
nencial, véase la información correspondiente en la ayuda. Por ejemplo con ?dnorm
o ?dexp podemos obtener información sobres cómo calcular sus respectivas funciones
de densidad. En la distribución exponencial, ha de tenerse en cuenta que el parámetro
rate coincide con la ordenada en el origen de la función de densidad y es igual al
inverso de la media. Para saber de qué distribuciones dispone R podemos escribir
> help.search("distribution")
y el resultado se puede ver en la Figura 1.5.
1.5.3. Simulación de una distribución normal

El código de R
> set.seed(111)
> t<-rnorm(100,3,2)
genera 100 valores aleatorios que siguen una distribución normal de media 3 y des-
viación tı́pica 2
> hist(t,freq=FALSE)
representa el histograma, donde frec=FALSE obliga a representar densidades. En una
densidad, la suma de las áreas de las barras debe sumar uno, mientras que cuando
se trabaja con frecuencias la suma de las áreas de las barras es el número de datos
observado.
> curve(dnorm(x,3,2),-4,10,add=TRUE)
representa la curva normal de media 3 y desviación tı́pica 2, para comparar. El pará-
metro add=TRUE tiene el efecto de superponer la curva al histograma. Si no se pone,
se borrarı́a éste. El resultado final puede verse en la Figura 1.6.
24 1.5.4 Suma de variables aleatorias normales
Figura 1.5: Resultado de ejecutar el comando de ayuda

help.search("distribution")
1.5.4. Suma de variables aleatorias normales

Veamos el efecto que tiene sumar dos distribuciones normales, una de media 3
y desviación tı́pica 2, y otra de media 5 y desviación tı́pica 3. Sabemos que la dis-
tribución normal es reproductiva respecto de la media y la varianza, es decir, que
la distribución resultante de sumar dos distribuciones normales es también normal,
con media la suma de medias y varianza la suma de varianzas de las distribuciones
sumadas. Con
> set.seed(111)
> t<-sapply(1:10000,function(x){rnorm(1,3,2)+rnorm(1,5,3)})
generamos 10000 números aleatorios para la suma. Con media
> mean(t)
Histogram of t
0.20
0.15
Density
0.10
0.05
0.00
−4 −2 0 2 4 6 8 10
Figura 1.6: Histograma de datos simulados de una Normal junto con su función de
densidad de probabilidad.
[1] 7.998157
de manera que se cumple 7,998157 ' 3 + 5 (suma de medias). Algo similar ocurra
con las varianzas ya que
> var(t)
[1] 13.02742
13,02742 ' 22 + 32 (suma de varianzas).

Vemos qué bien se aproxima lo obtenido a lo esperado. Con
> hist(t,freq=FALSE)
> curve(dnorm(x,8,sqrt(13)),-5,20,add=TRUE)
constatamos gráficamente la normalidad de la suma, como puede verse en la Figura

1.7.
26 1.5.5 Constatación de la “falta de memoria”de la distribución exponencial
Histogram of t
0.10
0.08
0.06
Density
0.04
0.02
0.00
−5 0 5 10 15 20
Figura 1.7: Histograma de la suma de dos variables normales junto con la función de
densidad correspondiente.
1.5.5. Constatación de la “falta de memoria”de la distribu-

ción exponencial
Tenemos una distribución exponencial de media 5. Determinamos la probabilidad
P (X > 4) con
> pexp(4,.2,lower.tail=FALSE)
[1] 0.449329
y P (X > 3) con
> pexp(3,.2,lower.tail=FALSE)
[1] 0.5488116
Finalmente P (X > 4 + 3|X > 4) es

> pexp(4+3,.2,lower.tail=FALSE)/ pexp(4,.2,lower.tail=FALSE)
[1] 0.5488116
que, como vemos, coincide con P (X > 3) sin condiciones.

Practica 2 G

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica 2 G

Cargado por

Copyright:

Formatos disponibles

1 | Práctica 2: Simulación con R

Trabajar con ı́ndices lógicos.

Trabajar con matrices.

Realizar simulaciones de experimentos aleatorios.

Trabajar con funciones de probabilidad y de densidad.

Generar datos correspondientes a los modelos de distribución de probabilidad

1.1. Otros tipos de datos en R

> x<-c(3.141592, 2.718281, 1.618034)

[1] 3.141592 2.718281 1.618034

La forma de acceder a los elementos del vector era la siguiente:

Se pueden asignar nombres a los elementos de un vector mediante la función

> names(x)<-c("pi", "e", "phi")

Los valores de π y e se pueden obtener en R con

phi es también conocido como el número áureo y es igual a

1.2. Variables lógicas en R

podemos ver qué elementos son iguales a 4 utilizando el operador ==:

[1] FALSE FALSE FALSE TRUE FALSE

La instrucción anterior devuelve un vector de valores lógicos (o booleanos). FALSE

[1] TRUE TRUE TRUE FALSE FALSE

[1] FALSE FALSE FALSE TRUE TRUE

Si aplicamos la función sum() al vector lógico resultante, R fuerza TRUE al valor

Generaremos un vector aleatorio de 100 números entre 0 y 1 de manera similar a

La media de este vector es

Contamos cuántos valores están por debajo de la media:

o cuántos por debajo de la mediana

> sum( y<median(y) )

[1] 0.0106578451 0.0936815199 0.0671411434 0.0475478533 0.0585964625

1.2.2. Condiciones lógicas compuestas

[1] 0.0106578451 0.0475478533 0.9665342933 0.9675274789 0.0327716474

Veamos que son 11. Si quisiéramos contarlos solamente, pondrı́amos:

> sum( (y<0.05)|(y>0.95) )

Pero si queremos sumar los valores que cumplen la condición anterior:

> sum(y[ (y<0.05)|(y>0.95) ] )

[1] 0.5149238 0.5322952 0.5098999 0.4657924 0.4693591 0.5482734

donde & es el operador lógico y.

> which( (y>0.45)&(y<0.55) )

1.2.3. Exclusión de valores

la instrucción z[-1] devuelve un vector igual al original de que se ha eliminado el

Si lo que deseamos es eliminar los tres primeros elementos, entonces debemos

O los tres últimos

si, por lo que fuera, nos interesa conservar el orden.

excluimos aquellos valores menores que 6.

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

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

> y<-matrix(x,nrow=3, byrow=TRUE)

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

> y<-matrix(x,ncol=3, byrow=TRUE)

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

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

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

o bien por medio de los nombres de la fila y columna, si los tiene

Podemos referir una columna de esta manera

lunes martes miércoles

marzo abril mayo junio

Nótese cómo, tanto en un caso como en otro, la ausencia de número en la fila

marzo abril mayo junio

marzo abril mayo junio

1.3.1. Operaciones con matrices

o bien, la media de todos los elementos

o bien, la matriz de varianzas/covarianzas

marzo abril mayo junio

matriz en la que el elemento x[i,i] representa la varianza de la columna x[,i], y

o, bien la varianza de la segunda fila