Taller 3 Uso de R

Rut:19.474.068-9

Link:http://rpubs.com/JoseTapiaJara/387595

Primera parte: Generar y lanzar 2 dados

Para lograr generar dos lanzamientos de dados, cuyos resultados sean dos números aleatorios ente 1 y 6 utilizaremos el comando:

lanzamientodado1=sample(c(1,2,3,4,5,6),n,T) #generacion dado 1
lanzamientodado2=sample(c(1,2,3,4,5,6),n,T) #generacion dado 2

Donde el comando sample nos servirá para obtener un número aleatorio entre el vector dado, y los parámetros determinarán el comportamiento de los números(por ejemplo si queremos que los números se repitan,etc).

Segunda parte: Crear variable aleatoria

Para este punto es implementaremos el código de la primera parte en la siguiente función:

Definiremos la variable aleatoria X como la suma de las caras de los dados

n<-5 #numero de veces que se lanzan los dados

SumaCaras<-function(n){ #funcion que genera lanzamiento de dos dados
  lanzamientodado1=sample(c(1,2,3,4,5,6),n,T) #generacion dado 1
  lanzamientodado2=sample(c(1,2,3,4,5,6),n,T) #generacion dado 2
  suma=c(1:n) #genera un vector de long n
  for(i in suma){ #suma las caras de los dados y las asigna a la posicion i de suma
    suma[i]=lanzamientodado1[i]+lanzamientodado2[i]
  }
  return(suma)
}
print(SumaCaras(n))

## [1]  9  5 10  9  7

En este caso nuestra variable aleatoria viene siendo la suma de las caras de ambos dados.

Valor Esperado:

O tambien representado como E(x) es la suma de cada posible valor aleatorio por el valor de dicho suceso. En pocas palabras es el valor que se esperaría que tome en un elevado número de repeticiones.Para esto utilizaremos la siguiente función que nos permite calcular la frecuencia con que sale cada dato:

Además esta función nos servirá para realizar el apartado 3, para comprobar la distribución de probabilidad

n=10000
ContadorRep<-function(n){
  dos=0
  tres=0
  cuatro=0
  cinco=0
  seis=0
  siete=0
  ocho=0
  nueve=0
  diez=0
  once=0
  doce=0
  for(i in 1:n){
    num=sample(SumaCaras(n),1,T)
    if(num==2){
      dos=dos+1}
    if(num==3){
      tres=tres+1}
    if(num==4){
      cuatro=cuatro+1}
    if(num==5){
      cinco=cinco+1}
    if(num==6){
      seis=seis+1}
    if(num==7){
      siete=siete+1}
    if(num==8){
      ocho=ocho+1}
    if(num==9){
      nueve=nueve+1}
    if(num==10){
      diez=diez+1}
    if(num==11){
      once=once+1}
    if(num==12){
      doce=doce+1}
  }

  return(frecuencia<-(c(dos,tres,cuatro,cinco,seis,siete,ocho,nueve,diez,once,doce)))
}
print(ContadorRep(n))

##  [1]  275  577  851 1097 1394 1648 1347 1121  835  575  280

Y ahora que programamos una función que determine la frecuencia con la que estos datos son generados podemos programar la función encargada del valor esperado o esperanza de x:

Si multiplicamos estos números por 1/10000 obtendremos la distribución de probabilidad para cada caso.

xx=1000
ValorEsperado<-function(x){
  frecuencia<-ContadorRep(x)
  suma=2*frecuencia[1]+3*frecuencia[2]+4*frecuencia[3]+5*frecuencia[4]+6*frecuencia[5]+7*frecuencia[6]+8*frecuencia[7]+9*frecuencia[8]+10*frecuencia[9]+11*frecuencia[10]+12*frecuencia[11]
  return(Valor=(suma/sum(frecuencia)))
}
print(ValorEsperado(xx))

## [1] 7.019

Graficando:

 #graficando valor esperado 10.000 datos
ejex<-seq(0,10000,by=10)
ejey<-c(rep(0,1001))
for (j in 1:length(ejey)) {
  ejey[j]=ValorEsperado(j)
}
plot(ejex,ejey,type = "l")

Calcular la Varianza

Para realizar este cálculo y graficarlo, utilizaremos la función ya implementada del valor esperado, lo cual quedaría de esta forma:

zz=10

Varianza<-function(x){
  diferencia<-1:x-1
  for (i in 1:x) {
    diferencia[i]=ValorEsperado(i^2)-(ValorEsperado(i)^2)
  }
  Varianza=sum(diferencia)
  return(Varianza)
}
print(Varianza(zz))

## [1] -450.8048

Luego hacer un grafico para 10000 valores de n:

 #Graficando varianza
ejex1<-seq(0,10000,by=250)
ejey1<-c(rep(0:40))
for (k in 1:length(ejey1)) {
  ejey1[k]=Varianza(k)
}
plot(ejex1,ejey1,type = "l")

En este caso se intentó modelar el comportamiento de la varianza con 40 datos debido a que con la complejidad polinomial del algoritmo explota de un momento a otro el tiempo de ejecución con la cantidad de datos.