Introducción
R puede ser utilizado como una calculadora.
> 5+2
[1] 7
Nótese que la prioridad de los operadores no es la misma, la multiplicación y división tienen preferencia sobre la suma y resta. Si no estamos seguros mejor siempre utilizar los paréntesis para obtener el resultado deseado.
> 2+4+5*2
[1] 16
> 2+(4+5)*2 #Esto es un comentario.
[1] 20
Con el operador # todo lo que siga después será ignorado por el intérprete de comandos y se considera comentario. Si quieres repetir o modificar una operación anterior siempre puedes pulsar la flecha del teclado de arriba. Al igual que en los sistemas operativos tipo UNIX recorrerás las instrucciones anteriormente introducidas en orden de última a primera. Con la flecha hacia abajo lo harías al revés.
Para almacenar el resultado de una operación en una variable se utiliza el operador de asignación <-, precedido del nombre de la variable. ¡Ojo, R es sensible al caso y diferencia entre minúsculas y mayúsculas!
> A <- 5*2 #Esto hace que la variable A tome el valor 10.
> a <- 5*2 #La variable a vale 10 también, pero es independiente de la variable A.
Con este operacor también se puede copiar el valor de una variable a otra:
> B <- A
> B
[1] 10
Pero al trabajar con variables, ¿cómo sé el valor que tiene asignado una en un instante determinado? Pues muy fácil, basta con escribirla y R te devuelve su valor.
> A [1] 10
> a [1] 10
> print(A)#La función print también se puede usar.
[1] 10
Si quieres nada más realizar una operación de asignación visualizar el resultado por pantalla basta que la encierres entre paréntesis.
> (A <- 5*3) #La variable A ahora vale 15.
[1] 15
Si intentamos crear una variable nueva llamada 1x:
> 1x <- 8+2
Error: inesperado símbolo en «1x»
Esto pasa porque las variables en R siempre empiezan por una letra, seguidas de números y/o letras, pero nunca se pueden utilizar caracteres especiales.
> (x1 <- 8+2) #Ahora hemos creado la nueva variable en memoria sin ningún problema.
[1] 10
Llegados a este punto, ni nos acordamos de cuántas variables tenemos en memoria. Para listarlas existe la función ls().
> ls() [1] «a» «A» «x1»
Ahora resulta que no vamos a utilizar más estas variables y están ocupando espacio en memoria. Podemos eliminar las variables que no volvamos a usar con rm(variable1, [variable 2], …, [variableN]).
> rm(a)
> ls()
[1] «A» «x1»
Si hay dos variables ir una a una aún bueno, pero si tenemos un chorizo de ellas es mejor utilizar rm conjuntamente con ls:
> rm(list=ls()) #Elimina todas las variables en memoria.
> ls()
character(0)
Si tienes cualquier duda y deseas acceder a la ayuda del programa puedes hacerlo mediante help([función]) o ?nombreFunción<función style=»color: rgb(153, 153, 153);»><función></función></función>.
> help() #Al no pasarle ningún parámetro R nos muestra la ayuda genérica.
help package:utils R Documentation
Documentation
Description:
‘help’ is the primary interface to the help systems.
Usage:
help(topic, package = NULL, lib.loc = NULL,
verbose = getOption(«verbose»),
try.all.packages = getOption(«help.try.all.packages»),
help_type = getOption(«help_type»))
Arguments:
topic: usually, a name or character string specifying the topic for
which help is sought. A character string (enclosed in
explicit single or double quotes) is always taken as naming a
topic.
If the value of ‘topic’ is a length-one character vector the […]
Si ya te cansaste de trabajar con R puedes salir mediante la sentencia q() en la que R te preguntarás si deseas guardar tu imagen de área de trabajo. Si la guardas, conservarás todas tus variables/objetos que en memoria tienes ahora la próxima vez que ejecutes una instancia del programa.
Tipos de datos básicos en R
En R existen los siguientes cuatro tipos básicos de datos:
- Numérico: Valores numéricos tanto positivos y negativos con o sin parte decimal.
- Complejo: Valores que son suma de un número real y uno imaginario.
- Lógico: Puede tomar dos valores binarios: TRUE o FALSE.
- Carácter: Un carácter o cadena de caracteres.
Los datos sean de cualquier tipo se almacenan en variables con el operador de asignación aunque no sean números:
> (boolean <- TRUE)
[1] TRUE
> (char <- «lol»)
[1] «lol»
Si no sabes de qué tipo es un dato puedes utilizar la función is.tipo(variable) dónde tipo es numeric, logical, character o complex.
> is.complex(char)
[1] FALSE
> is.character(char)
[1] TRUE
Y puedes convertir tipos de datos almacenados en variables entre si con as.tipo(variable):
> as.numeric(boolean)
[1] 1
Nótese que sólo convierte el lógico a 1 (verdadero) y que muestra el resultado por pantalla. Si quisiésemos guardar el resultado tendríamos que crear otra variable y utilizar el operador de asignación.
Tipos de datos complejos en R
En R existen las listas, las sucesiones, los vectores, las matrices y los data frames.
Listas
Una lista es una colección de datos que pueden ser o no del mismo tipo. Suelen identificarse con un nombre. Se emplea la función list([nombre1]=dato1, [nombre2]=dato2, …, [nombreN]=datoN) en la que los nombres son opcionales y cada elemento de la lista se separa mediante comas.
> lista <- list(placa=»ASUS P5N-T Deluxe»,precio=204.23,reservada=TRUE)
> lista$placa
[1] «ASUS P5N-T Deluxe»
$precio
[1] 204.23
$reservada
[1] TRUE
Si no utilizásemos nombres, R te indicaría al consultar el contenido de la variable de tipo lista la posición de cada elemento de la misma:
> lista2 <- list(«ASUS P5N-T Deluxe», 204.23, TRUE)
> lista2
[[1]]
[1] «ASUS P5N-T Deluxe»
[[2]]
[1] 204.23
[[3]]
[1] TRUE
Para acceder a un elemento concreto de la lista basta con utilizar el operador $ y el nombre de ese elemento:
> lista$placa
[1] «ASUS P5N-T Deluxe»
¿Y si la lista no tiene nombres para designar los elementos? Pues se indica el lugar que ocupa el elemento en la lista entre corchetes:
> lista2 [1]
[[1]]
[1] «ASUS P5N-T Deluxe»
Suceciones
Una sucesión es un conjunto finito de elementos ordenados. Dicho orden suele ser creciente. Para crear una sucesión se utiliza el operador dos puntos : .
> suc <- 1:5 #Cada término de la sucesión se obtiene incrementando en una unidad al anterior desde el uno hasta el cinco.
> suc
[1] 1 2 3 4 5
> suc <- 5:1 #La sucesión anterior con los mismos elementos pero decreciente.
> suc
[1] 5 4 3 2 1
> suc <- (1:2.5) #Se pueden utilizar decimales, pero se incrementa en una unidad cada elemento.
> suc
[1] 1 2
> suc <- (0.5:2.5)
> suc
[1] 0.5 1.5 2.5
La sucesión generada con el operador : se puede encerrar entre paréntesis para aplicar a cada uno de los elementos de la misma una determinada operación. Por ejemplo, podemos decrementar todos los elementos de la sucesión en una unidad.
> suc <- (1:5)-1
> suc
[1] 0 1 2 3 4
Para bien o para mal, no todos los elementos que difieren en una unidad conforman una sucesión, normalmente el cálculo del siguiente elemento a partir de su predecesor es más complejo. Para realizar estas tareas R nos proporciona las funciones seq y rep.
- seq(from, to, by, lenght): genera sucesiones regulares a partir de los parámetros from (primer elemento de la sucesión), to (último elemento de la sucesión), lenght (número de elementos que componen la sucesión) y by (diferencia entre cada uno de los elementos).
- rep(elemento, numeroRepeticiones): los elementos en una sucesión pueden repetirse y seguirán estando ordenados. Esta función permite crear sucesiones de números que se repitan un número determinado de veces. También puede trabajar con vectores.
> lista <- seq(from=0,to=1,by=1/10) #De cero a uno incrementando en una décima.
> lista
[1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
> lista <- seq(from=0,to=1,length=20) #De cero a uno obteniendo una lista creciente con 20 elementos.
> lista
[1] 0.00000000 0.05263158 0.10526316 0.15789474 0.21052632 0.26315789
[7] 0.31578947 0.36842105 0.42105263 0.47368421 0.52631579 0.57894737
[13] 0.63157895 0.68421053 0.73684211 0.78947368 0.84210526 0.89473684
[19] 0.94736842 1.00000000
> lista <- rep(3,5*2) #Lista de diez elementos dónde todos son 3.
> lista
[1] 3 3 3 3 3 3 3 3 3 3
Vectores
Un vector es un conjunto de elementos del mismo tipo dónde tiene relevancia la posición que ocupa cada uno. Para trabajar con vectores tenemos que ver la función c(elemento1, elemento2, …,elementoN) que nos permite concatenar elementos para formar un vector. Esta función también puede trabajar concatenando listas.
> vector <- c(0,1,2,3)
> vector
[1] 0 1 2 3
> vector2 <- c(4,5)
> vector2
[1] 4 5
> vector3 <- c(vector,vector2) #Se pueden concatenar vectores o listas entre sí.
> vector3
[1] 0 1 2 3 4 5
Como todos los elementos de un vector tienen que ser del mismo tipo, al meter uno diferente se R lo convierte al tipo de este último implícitamente.
> vector <- c(0,1,2,3)
> (c(vector,»4″)) #Al introducir un elemento de tipo carácter, el resto de tipo numeric se convierten.
[1] «0» «1» «2» «3» «4»
Con los vectores pueden realizarse operaciones:
> v1 <- c(0,1,2)
> (v1*2) #Multiplicamos cada elemento del vector por 2.
[1] 0 2 4
> v2 <- c(3,4)
> (v2+1) #Incrementamos en una unidad cada elemento.
[1] 4 5
> (v1+v2)
[1] 3 5 5
Mensajes de aviso perdidos
In v1 + v2 :
longitud de objeto mayor no es múltiplo de la longitud de uno menor
Es decir, R solo opera con vectores si uno es igual en longitud al otro o si una de las longitudes de los dos es múltiplo del otro. En el primer caso opera cada posición de ambos vectores entre sí, y si uno es mayor que el otro, pues duplica el vector más pequeño hasta igualar la longitud del mayor y luego opera elemento a elemento.
> (v1+c(v2,5))
[1] 3 5 7
> (v1/c(v2,5))
[1] 0.00 0.25 0.40
> (v1+c(v2,5,6,7,8))
[1] 3 5 7 6 8 10
Hay un tipo de vector característico llamado vector lógico. Los vectores lógicos se obtienen al utilizar operadores de comparación que devuelven un valor booleano en vez de los aritméticos anteriormente mencionados. Por ejemplo:
> (v1>=2)
[1] FALSE FALSE TRUE
Por último, a veces es útil obtener un subvector de un vector concreto, seleccionando los elementos del mismo que nos interesen a través de la posición que ocupen utilizando los corchetes.
> v1[1] #Los vectores en R empiezan por la posición 1 y no en 0 como en otros lenguajes de programación.
[1] 0
> v1[1:2] #Seleccionamos el subvector formado por los 2 primeros.
[1] 0 1
> -v1[1:2] #Seleccionamos los 2 primeros y les cambiamos el signo.
[1] 0 -1
> v1[-(1:2)] #Seleccionamos los elementos que no están en las dos primeras posiciones.
[1] 2
Matrices
Una matriz es un vector con dos dimensiones, denominadas filas y columnas. Para construir una matriz en R es necesario un vector que contenga los elementos y el número de filas y columnas. La función es matrix(vector,nrow=númeroFilas,ncol=númeroColumnas). R rellenará los elementos cubriendo primero la primera columna, luego la segunda y así hasta que complete de copiar los elementos del vector. Si quedan posiciones libres se rellenarán recorriendo de nuevo el vector desde el principio (lo que alguna gente denomina «reciclar»).
> matriz <- matrix((0:3),nrow=3,ncol=4)
> matriz
[,1] [,2] [,3] [,4]
[1,] 0 3 2 1
[2,] 1 0 3 2
[3,] 2 1 0 3
> matriz <- matrix((0:3),nrow=4) #Matriz con una única columna.
> matriz
[,1]
[1,] 0
[2,] 1
[3,] 2
[4,] 3
> matriz <- matrix((0:3),nrow=2) #Rellena con las columnas que hagan falta.
> matriz
[,1] [,2]
[1,] 0 2
[2,] 1 3
> matriz <- matrix((0:3),nrow=2,ncol=1) #Si el tamaño de la matriz es submúltiplo del tamaño del vector, los últimos elementos del vector se truncarán.
> matriz
[,1]
[1,] 0
[2,] 1
A veces, conviene rellenar las matrices desde el vector fuente por filas y no por columnas. Para ello basta con utilizar el parámetro byrow=TRUE en la función matrix.
> print(matriz <- matrix((0:3),nrow=3,ncol=4,byrow=TRUE))
[,1] [,2] [,3] [,4]
[1,] 0 1 2 3
[2,] 0 1 2 3
[3,] 0 1 2 3
Si os fijais, las filas las indica de la forma [índiceFila, ] y las columnas [, índiceColumna], por lo que para acceder a un elemento concreto de la matriz usamos la instrucción variableMatriz[índiceFila, índiceColumna].
> matriz[2,] #Devuelve los elementos de la segunda fila.
[1] 0 1 2 3
> matriz[,3] #Devuelve la tercera columna de la matriz.
[1] 2 2 2
> matriz[2,3] #Accedemos a un elemento concreto.
[1] 2
Si desconocemos las dimensiones de una matriz, su número de columnas o de filas siempre podremos saberlo:
> dim(matriz) #La matriz es 3×4: 3 filas y 4 columnas.
[1] 3 4
> nrow(matriz) #Número de filas de la matriz.
[1] 3
> ncol(matriz) #Número de columnas.
[1] 4
A veces compensa ponerle un nombre o alias a cada fila y/o columna mediante las funciones rownames(variableMatriz) y colnames(variableMatriz):
> rownames(matriz) #Las filas no poseen alias.
NULL
> rownames(matriz) <- c(«fila1″,»fila2″,»fila3») #Asignamos los alias. > rownames(matriz) #Comprobamos ahora los nombres.
[1] «fila1» «fila2» «fila3»
> colnames(matriz) #Las columnas no poseen alias.
NULL
> colnames(matriz) <- c(«columna1″,»columna2″,»columna3″,»columna4») #Asignamos los nombres a las columnas. > colnames(matriz) #Nos aseguramos de que fueron asignados.
[1] «columna1» «columna2» «columna3» «columna4»
> matriz[fila2,columna2] #Como los alias fueron de tipo character si no los metemos entre comillas no funcionan.
Error: objeto ‘fila2’ no encontrado
> matriz[«fila2″,»columna2»] #¡Eureka!
[1] 1
> matriz[2,2] #Los elementos siguen siendo accesibles por los índices directamente aunque haya alias.
[1] 1
Con las matrices se puede operar:
> m1 <- matrix(0:3,nrow=2) > m2 <- matrix(1:4,nrow=2) > m3 <- matrix(1:6,nrow=2,ncol=3) > (m1+m2) #Suma de los elementos de dos matrices de igual dimensión.
[,1] [,2]
[1,] 1 5
[2,] 3 7
> (m2-m1) #Diferencia entre los elementos de matrices de misma dimensión.
[,1] [,2]
[1,] 1 1
[2,] 1 1
> (m1*m2) #Producto de elementos entre sí en matrices de igual dimensión. ¡NO confundir con el PRODUCTO DE MATRICES!
[,1] [,2]
[1,] 0 6
[2,] 2 12
> (m1%*%m3) #El típico producto de matrices. Las dimensiones tienen que ser nxm y mxp.
[,1] [,2] [,3]
[1,] 4 8 12
[2,] 7 15 23
> print(t(m1)) #Matriz traspuesta fruto de intercambiar filas por columnas.
[,1] [,2]
[1,] 0 1
[2,] 2 3
> det(m1) #Calcula el determinante de una matriz.
[1] -2
La función diag trabaja con las diagonales de las matrices para concedernos diferentes resultados.
Con sintaxis diag(matriz):
> print(diag(m1)) #Transformó la diagonal de la matriz m1 en un vector.
[1] 0 3
Con sintaxis diag(vector):
> print(diag(0:5)) #Crea la matriz diagonal dónde los elementos de ella son los del vector.
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 0 0 0 0 0 0
[2,] 0 1 0 0 0 0
[3,] 0 0 2 0 0 0
[4,] 0 0 0 3 0 0
[5,] 0 0 0 0 4 0
[6,] 0 0 0 0 0 5
Y con diag(numeric) crea la matriz identidad (matriz cuadrada) de dimensión igual al parámetro que le pasemos:
> print(diag(4))
[,1] [,2] [,3] [,4]
[1,] 1 0 0 0
[2,] 0 1 0 0
[3,] 0 0 1 0
[4,] 0 0 0 1
Data frames (marcos de datos)
Un data frame o marco de datos es una matriz en que se organizan elementos (datos) en que las columnas pueden ser datos de diferente tipo. Tienen utilidad en la estadística y se crean con la función data.frame().
La forma más fácil de crear un marco de datos es partiendo de las columnas.
# Creamos las columnas:
> Formato <- c(«CD», «CD», «DVD»)
> Instalador <- c(«Script»,»Gráfico ncurses»,»Gráfico»)
> Gestor <- c(TRUE,TRUE,TRUE)
> Kernel <- c(2.6,2.4,2.5)
# Creamos del data frame:
> df <- data.frame(Formato,Instalador,Gestor,Kernel)
# Esta es la estructura matricial del marco de datos.
> df
Formato Instalador Gestor Kernel
1 CD Script TRUE 2.6
2 CD Gráfico ncurses TRUE 2.4
3 DVD Gráfico TRUE 2.5
# Podemos asignar nombres identificativos a las filas:
> rownames(df) <- c(«Arch»,»Debian»,»Mandrake»)
# Lo comprobamos:
> df
Formato Instalador Gestor Kernel
Arch CD Script TRUE 2.6
Debian CD Gráfico ncurses TRUE 2.4
Mandrake DVD Gráfico TRUE 2.5
# Accedemos a un elemento del data set.
> df[«Debian»,»Kernel»]
[1] 2.4
# Debido a la estructura matricial del data set podemos utilizar índices numéricos también:
> df[2,4]
[1] 2.4
# Para obtener una fila del data set.
> df[«Arch»,]
Formato Instalador Gestor Kernel
Arch CD Script TRUE 2.6
Distribuciones de probabilidad
Para generar valores aleatorios que sigan una distribución normal se utiliza la función rnorm(númeroDeValores,[mean=media],[sd=desviaciónTípica]). Tanto la media como la desviación típica son parámetros opcionales.
> rnorm(8) #Generamos una muestra de 8 valores que siguen una distribución normal.
[1] 0.2027880 0.1275381 -1.4555397 1.3670443 0.3967219 1.0126435 -0.6664920
[8] 0.7511331
> rnorm(8,mean=5) #Idem pero con media igual a 5.
[1] 4.128926 4.505363 5.579947 4.708918 4.604123 4.766508 3.613146 4.226559
> rnorm(8,mean=5,sd=0.5) #Ahora incluímos la desviación típica.
[1] 4.544075 5.026834 4.755976 5.305303 5.421456 5.401411 3.860596 4.57663
Para aplicar la función de densidad de una distribución normal necesitas un vector y opcionalmente la media y/o la desviación típica: dnorm(vector, [mean=media], [sd=desviaciónTípica]).
> dnorm(8:12)
[1] 5.052271e-15 1.027977e-18 7.694599e-23 2.118819e-27 2.146384e-32
> dnorm(8:12,sd=0.5)
[1] 2.052326e-56 3.517499e-71 1.104190e-87 6.348563e-106 6.685429e-126
> dnorm(8:12,sd=0.5,mean=9)
[1] 1.079819e-01 7.978846e-01 1.079819e-01 2.676605e-04 1.215177e-08
Para la función de distribución se utiliza la función pnorm se utiliza un vector de cuantiles, la media y la desviación típica son opcionales. Destaca el parámetro lower.tail=FALSE para calcular P(X>a) ya que por defecto valdrá TRUE y sólo permite calcular probabilidades P tal que P(X<a).></a).><a).
<a).>> pnorm(0) #Probabilidad P(X<0).
[1] 0.5</a).>
> pnorm(0,lower.tail=FALSE) #P(X>0).
[1] 0.5
Si lo que queremos es calcular los cuantiles, tenemos la función qnorm(cuantil, [mean=media], [sd=desviaciónTípica], [lower.tail=FALSE]) :
> qnorm(0.5) # Valor x tal que P(X<x)=0.5<a).><x)=0.5></x)=0.5>
[1] 0</a).>
> qnorm(0.5,lower.tail=FALSE) #Valor x tal que P(X>x)=0.5
[1] 0
NOTA: puedes trabajar con otras distribuciones que no sean la normal. Otras disponibles son beta, binom, chisq, geom, exp, t, pois, unif, etc… Puede ser necesario instalar algún paquete adicional a R para trabajar con estas distribuciones, como es el caso de RLab.
Instrucciones de decisión y bucles
R no deja de ser un lenguaje de programación, por lo que proporciona estructuras de decisión y bucles para dirigir y controlar el flujo de ejecución de nuestro programas o scripts.
Sintaxis bloque if-else: if (expresión) { instrucciones } [else { instrucciones }]
> if (1==1){ print («hola mundo»)}
[1] «hola mundo»
> if (1==2) { print («hola mundo»)} else { print(«R»)}
[1] «R»
Sintaxis bucle for: for ( índice in vector) { instrucciones }
> for (cont in 1:5) { print(«hola mundo») }
[1] «hola mundo»
[1] «hola mundo»
[1] «hola mundo»
[1] «hola mundo»
[1] «hola mundo»
Sintaxis bucle while: while ( condición) { instrucciones }
> while (cont <>
+ print(cont)
+ cont <- cont+1
+ }
[1] 0
[1] 1
[1] 2
[1] 3
[1] 4
Para finalizar la ejecución de un bucle disponemos también de la instrucción break. Terminará la ejecución del bucle y se ejecutará la siguiente instrucción fuera de él. Cuánto menos se utilicen este tipo de instrucciones mejor, ya que siempre que la condición de iterado del bucle sea correcta, no necesitaremos instrucciones como esta salvo en la instrucción repeat para romper el flujo del programa conjuntamente con un if:
> repeat { print(«hola mundo»); print(5*2/3); if (1>0) break } #Se pueden separar instrucciones por ;
[1] «hola mundo»
[1] 3.333333
El bucle repeat tiene la sintaxis repeat { instrucciones }
Por úlimo, en todo este tipo de estructuras de control se utilizan los operadores lógicos para definir las condiciones . Estos operadores son los siguientes:
- == es el operador de comparación de igualdad. El resultado de comparar dos valores o expresiones será TRUE o verdadero si valen lo mismo.
- != es el operador que se utiliza para comparar dos valores o expresiones que devuelve TRUE si son diferentes y FALSE si son iguales.
- < es el operador de comparación menor que. Si la expresión que precede al operador es menor que la segunda el operador devuelve verdadero.
- <= similar al anterior, pero devuelve verdadero si la expresión primera es menor o igual en valor a la segunda.
- > devuelve TRUE si la primera expresión es mayor que la segunda.
- >= devuelve TRUE si la primera expresión es mayor o igual a la segunda.
- || es un operador que denota el OR lógico. Para conseguir que la expresión conjunta sea verdadera al menos una de las dos expresiones que acompañen al operador tienen que serlo.
- && devuelve TRUE sí y solo si las dos expresiones que lo acompañan son verdaderas. Devuelve falso en cualquier otro caso.
Funciones
R incorpora funciones como mean para calcular la media o scan para obtener valores introducidos por el usuario a través del teclado para almacenarlos en un vector.
> x<-scan(nmax=1); print(x) #Con nmax=1 le indicamos a R que el vector solo poseerá un elemento.
1: 3
Read 1 item
[1] 3
Esto está muy bien, pero la auténtica flexibilidad y el potencial de R se encuentran en que permite al usuario crear sus propias funciones. Esto es:
nombreFunción <- function ([parámetro1], [parámetro2], … , [parámetroN]) {
instruccionesDeLaFunción
[return (valor1)]
}
En una función tanto los parámetros como la variable o valor de retornos son opcionales.
> promedioMuestraAleatoria <- function (tamaño,media,desv){
+ muestraAleatoria <- rnorm(tamaño,mean=media,sd=desv) #Generamos la muestra.
+ promedio <- 0
+ for (i in 1:tamaño){ #Recorremos la muestra
+ promedio <- promedio+muestraAleatoria[i]
+ }
+ promedio <- promedio/tamaño
+ print(«El promedio de la muestra aleatoria normal generada es «)
+ (promedio)
+ return(promedio)
+ }
Para llamar a la función podemos hacerlo con
> promedioMuestraAleatoria(10000,3,0.9)
[1] «El promedio de la muestra aleatoria normal generada es »
[1] 3.005858
Como veis, combinando todo lo anterior, junto con los conocimientos estadísticos pertinentes y algo de experiencia, conseguireis afrontar cualquier problema que se os presente.
Por último citar que también son útiles (aunque no las haya incluído en el manual) las funciones plot() y fplot(). Estas funciones permiten dibujar gráficos en pantalla y representarlos mediante líneas o nubes de puntos para comprobar gráficamente los comportamientos de las diferentes muestras o distribuciones.
