R como un ambiente de cálculo

Transcripción

1 R como un ambiente de cálculo R puede ser usado como una potente calculadora ya que permite realizar un conjunto amplio de operaciones. Aritmética R usa los símbolos usuales de adición +, sustracción, multiplicación *, división / y potencia ^. Los paréntesis ( ), pueden ser usados para especificar el orden de las operaciones. R también proporciona %% para tomar el módulo y %/% para la división entera. > (1+1/100)^100 [1] > 17/5 [1] 3.4 > 17%%5 [1] 2 > 17%/%5 [1] 3 R tiene un conjunto de funciones predefinidas, por ejemplo sin(x), cos(x), tan(x), todas en radianes, exp(x), log(x) y sqrt(x). Algunas constantes especiales como pi también están predefinidas. > exp(1) [1] > options(digits=16) > exp(1) [1] > pi [1] > sin(pi/6) [1] 0.5 > floor(pi) [1] 3 > ceiling(pi) [1] 4 > floor(exp(1)) [1] 2 > ceiling(exp(1)) [1] 3

2 Variables Una variable es como un fólder con un nombre en el frente. Es posible almacenar algo dentro del fólder, mirar dentro, reemplazar el algo por otro manteniendo el nombre inalterable. > options(digits=6) > x <- 100 > x [1] 100 > (1+1/x)^x [1] > x <- 200 > (1+1/x)^x [1] > y <- (1+1/x)^x > y [1] > (y <- (1+1/x)^x) [1] > n <- 1 > n <- n+1 > n [1] 2 Funciones En matemáticas una función toma uno o más argumentos (inputs) y produce una o más salidas (outputs) o valores. Las funciones en R trabajan de una manera análoga. La forma de invocar una función de R o una definida por el usuario escribiendo el nombre de la función seguido de los valores para sus argumentos entre comillas y separados por comas. > seq(from=1,to=9,by=2) [1] > seq(from=1,to=9) [1] > seq(1,9,2) [1] > seq(to=9,from=1) [1]

3 > seq(by=-2,9,1) [1] > x <- 9 > seq(1,x,x/3) [1] Vectores Un vector es una lista indexada de variables. Al igual que las variables, los vectores son creados al mismo tiempo en que se le asignan valores. Existen tres funciones básicas para construir vectores: c(), seq(from,to,by) y rep(x,times). > (x <- seq(1,20,by=2)) [1] > (y <- rep(3,4)) [1] > (z <- c(y,x)) [1] Para referirnos al elemento i del vector x, se usa x[i]. Si los elementos de i son negativos, entonces los valores correspondientes del vector son omitidos. > (x <- 100:110) [1] > i <- c(1,3,2) > x[i] [1] > j <- c(-1,-2,-3) > x[j] [1] Las operaciones algebraicas sobre vectores actúan sobre cada elemento separadamente, es decir elemento por elemento. > x <- c(1,2,3) > y <- c(4,5,6) > x*y [1] > x+y [1] > y^x [1]

4 Cuando se realiza una operación algebraica con dos vectores de diferente longitud, R automáticamente repite el vector más pequeño hasta que tenga la misma longitud del otro vector. > c(1,2,3,4)+c(1,2) [1] > (1:10)^c(1,2) [1] > 2+c(1,2,3) [1] > 2*c(1,2,3) [1] > (1:10)^2 [1] > c(1,2,3)+c(1,2) [1] Mensajes de aviso perdidos In c(1, 2, 3) + c(1, 2) : longitud de objeto mayor no es múltiplo de la longitud de uno menor En R existe un conjunto de funciones útiles que usan como argumentos vectores: sum(), prod(), max(), min(), sqrt(), mean() y var(). > sqrt(1:6) [1] > mean(1:6) [1] 3.5 > sort(c(5,1,3,4,2)) [1] > x <- c(1.2,0.9,0.8,1,1.2) > media.x <- sum(x)/length(x) > media.x-mean(x) > var.x <- sum((x-media.x)^2)/(length(x)-1) > var.x-var(x) [1] 0 > x <- seq(10,200,by=10) > y <- (1+1/x)^x > plot(x,y)

5 Datos perdidos (missing data) En experimentos reales, por alguna razón u otra, se tienen observaciones perdidas o faltantes. Dependiendo del análisis estadístico utilizado las observaciones perdidas pueden ignorarse o estimarse (un proceso llamado imputación). R representa las observaciones faltantes con el valor NA. > a <- NA > is.na(a) [1] TRUE > a <- c(11,na,13) > is.na(a) [1] FALSE TRUE FALSE > mean(a) [1] NA > mean(a,na.rm=true) [1] 12

6 Expresiones y asignaciones Los siguientes son ejemplos de expresiones. > seq(10,20,by=3) [1] > 4 [1] 4 > mean(c(1:3)) [1] 2 > 1>2 [1] FALSE Si la evaluación de una expresión se guarda, usando el operador <- entonces la combinación es llamada una asignación. Los siguientes son ejemplos de asignaciones. > x1 <- seq(10,20,by=3) > x2 <- 4 > x3 <- mean(c(1:3)) > x4 <- 1>2 Expresiones lógicas Una expresión logica se forma usando los operadores de comparación <, >, <=, >=, == (igual a), = (diferente a); y! (no). El orden de las operaciones puede controlarse usando paréntesis (). El valor de una expresión lógica es TRUE o FALSE. Los enteros 0 y 1 también pueden usarse para representar TRUE y FALSE respectivamente (lo cual es un ejemplo de lo llamado coarción) Notar que A B es TRUE si A o B o ambos son TRUE. Si se desea la disyunción exclusiva, es decir A o B son TRUE pero no ambos, entonces se usa xor(a,b). > c(0,0,1,1) c(0,1,0,1) [1] FALSE TRUE TRUE TRUE > xor(c(0,0,1,1),c(0,1,0,1)) [1] FALSE TRUE TRUE FALSE > x <- 1:20 > x%%4==0 [1] FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE > (y <- x[x%%4==0]) [1] 4 8

7 > x <- c(1,na,3,4) > x>2 [1] FALSE NA TRUE TRUE > x[x>2] [1] NA 3 4 > subset(x,subset=x>2) [1] Si se desea saber la posición de los elementos TRUE de un vector lógico x se usa wich(x). > x <- c(1,1,2,3,5,8,13) > which(x%%2==0) [1] 3 6 Los operadores lógicos && y son versiones secuenciales de evaluación de & y respectivamente. Suponga que x e y son expresiones lógicas. Si se evalúa x & y, R muestra TRUE si ambos son TRUE y FALSE en caso contrario. Al evaluar x && y, R primero evalúa x. Si x es FALSE entonces R muestra FALSE sin evaluar y. Si x es TRUE entonces R evalúa y luego muestra TRUE si y es TRUE y FALSE en caso contrario. Matrices Una matriz es creada a partir de un vector usando la función matrix, la cual tiene la forma matrix(data, nrow = 1, ncol = 1, byrow = FALSE) > (A <- matrix(1:6, nrow = 2,ncol = 3)) [,3] [1,] [2,] > (A <- matrix(1:6, nrow = 2,ncol = 3, byrow = TRUE)) [,3] [1,] [2,] > A[1, 3] <- 0 > A [,3] [1,] [2,] > A[, 2:3] [1,] 2 0 [2,] 5 6

8 > (B <- diag(c(1, 2, 3))) [,3] [1,] [2,] [3,] Las operaciones usuales, incluyendo *, actúan elemento por elemento sobre las matrices, pero si se desea multiplicar una matriz por otra se usa el operador %*%. Se tienen además algunas funciones sobre matrices como por ejemplo nrow(x), ncol(x), det(x), t(x) y solve(a,b) que da como resultado x tal que A%*%x == B. Si A es invertible entonces solve(a) permite obtener la matriz inversa de A. > (A <- matrix(c(3, 5, 2, 3), nrow = 2, ncol = 2)) [1,] 3 2 [2,] 5 3 > (B <- matrix(c(1, 1, 0, 1), nrow = 2, ncol = 2)) [1,] 1 0 [2,] 1 1 > A*B [1,] 3 0 [2,] 5 3 > A%*%B [1,] 5 2 [2,] 8 3 > (A.inv <- solve(a)) [1,] -3 2 [2,] 5-3 > A%*%A.inv [1,] e-16 [2,] e+00 > A^(-1) [1,] [2,] Observe el pequeño error en A%*%A.inv. Los errores numéricos de este tipo son el resultado de tener que almacenar números reales en un formato binario con un número finito de bits y son llamados errores de redondeo.

9 El workspace Los objetos que fueron creados en R permanecen en existencia hasta que uno decida eliminarlos. Para listar los objetos definidos se usa ls() u objects(). Para eliminar el objeto se usa remove(x). Para remover todos los objetos definidos se usa rm(list=ls()). Para guardar todos los objetos existentes en una archivo llamado fname en el directorio de trabajo actual se usa save.image(file = fname ). Para guardar objetos específicos (digamos x e y) se usa save(x, y, file = fname ). Para cargar un conjunto de objetos guardados se usa load(file = fname ). R permite guardar todos los comandos usados. Para guardar la historia en el archivo fname se usa savehistory(file = fname ) y para cargar esta historia se usa loadhistory(file = fname ).

10 Programación básica El siguiente es un ejemplo de un programa para calcular las raíces reales de una ecuación cuadrática. Note el uso de # para los comentarios sobre el código. Ejemplo 1: Se presenta programa para calcular las raíces reales de una ecuación cuadrática: cuad1.r # Programa: cuad1.r # Encuentra las raices de a2*x^2 + a1*x + a0 = 0 # Limpia el workspace rm(list=ls()) # Entradas a2 <- 1 a1 <- 4 a0 <- 2 # Calculos raiz1 <- (-a1 + sqrt(a1^2-4*a2*a0))/(2*a2) raiz2 <- (-a1 - sqrt(a1^2-4*a2*a0))/(2*a2) # Salida show(c(raiz1, raiz2)) > source("c:/documents and Settings/PCUSER/Escritorio/Est Comp/cuad1") [1] Ramificando con if Es útil cuando se desea forzar la ejecución de la totalidad o parte de un programa en base a alguna condición. El comando if tiene la forma if (expresión_lógica) { expresión_1 Una extensión natural del comando if incluye else if (expresión_lógica) { expresión_1 else { expresión_2

11 Ejemplo 2: Se presenta una versión mejorada para encontrar las raíces de la función cuadrática: cuad2.r # Programa: cuad2.r # Encuentra las raices de a2*x^2 + a1*x + a0 = 0 # Limpia el workspace rm(list=ls()) # Entradas a2 <- 1 a1 <- 4 a0 <- 5 # Calculo del discriminante discrim <- a1^2-4*a2*a0 # Calculo de las raices dependiendo del valor del discriminante if (discrim > 0) { raices <- c( (-a1 + sqrt(a1^2-4*a2*a0))/(2*a2), (-a1 - sqrt(a1^2-4*a2*a0))/(2*a2) ) else { if (discrim == 0) { raices <- -a1/(2*a2) else { raices <- c() # Salida show(raices) > source("c:/documents and Settings/PCUSER/Escritorio/Est Comp/cuad2") NULL Las expresiones agrupadas usando { son vistas por R como una expresión simple, por ejemplo el comando if. El siguiente código if (expresión_lógica_1) { expresión_1 else { if (expresión_lógica_2) { expresión_2 else { expresión_3

12 puede escribirse de forma equivalente como if (expresión_lógica_1) { expresión_1 else if (expresión_lógica_2) { expresión_2 else { expresión_3 Bucle con for El comando for tiene la siguiente forma, donde x es una variable simple y vector es un vector. for (x in vector) { expresión_1 Usando el comando for se ejecuta el conjunto de expresiones entre { para cada elemento de vector. Ejemplo 3: El siguiente ejemplo hace un bucle para sumar los elementos de un vector > (x_list <- seq(1, 9, by = 2)) [1] sum_x <- 0 for (x in x_list) { sum_x <- sum_x + x cat("el elemento actual del bucle es", x, "\n") cat("el total acumulado es", sum_x, "\n") El elemento actual del bucle es 1 El total acumulado es 1 El elemento actual del bucle es 3 El total acumulado es 4 El elemento actual del bucle es 5 El total acumulado es 9 El elemento actual del bucle es 7 El total acumulado es 16 El elemento actual del bucle es 9 El total acumulado es 25 > sum(x_list) [1] 25

13 Ejemplo 4: El programa nfact1.r calcula el factorial de un número. # Programa: nfact1.r # Calcula el factorial de n # Limpia el workspace rm(list=ls()) # Entrada n <- 6 # Calculos n_factorial <- 1 for (i in 1:n) { n_factorial <- n_factorial * i # Salida show(n_factorial) > source("c:/documents and Settings/PCUSER/Escritorio/Est Comp/nfact1") [1] 720 Ejemplo 5: Los siguientes dos programas producen el mismo resultado pero el primero es más rápido. Programa 1 n < x <- rep(0, n) for (i in 1:n) { x[i] <- i Programa 2 n < x <- 1 for (i in 2:n) { x[i] <- i Bucle con while A menudo no se sabe de antemano cuantas veces se necesita utilizar un bucle. Es decir cada vez que se utiliza el bucle se chequean algunas condiciones para determinar si ya es necesario continuar. En esta situación se usa un bucle while que tiene la forma while (expresiones_lógicas) { expresión_1

14 Cuando se ejecuta el comando while primero son evaluadas las expresiones_lógicas. Si estas son TRUE entonces el grupo de expresiones entre { son ejecutadas. Claramente, para que el bucle se detenga al menos una de las expresiones_lógicas debería ser FALSE. Ejemplo 6: Considere los número de Fibonacci F 1, F 2, los cuales son deducidos inductivamente usando las reglas F 1 = 1, F 2 = 1 y F n = Fn 1 + Fn 2 para n 2. Suponga que se quiere conocer el primer número de Fibonacci mayor que 100. # Programa: fibonacci.r # Calcula el primer numero de Fibonacci mayor a 100 # Limpia el workspace rm(list=ls()) # Inicializando las variables F <- c(1, 1) # lista de numeros de Fibonacci n <- 2 # longitud de F # Calculo iterativo de los nuevos numeros de Fibonacci while (F[n] <= 100) { # cat("n =", n, " F[n] =", F[n], "\n") n <- n + 1 F[n] <- F[n-1] + F[n-2] #Salida cat("el primer numero de Fibonacci > 100 is F(", n, ") =", F[n], "\n") > source("c:/documents and Settings/PCUSER/Escritorio/Est Comp/fibonacci") El primer numero de Fibonacci > 100 is F( 12 ) = 144 > F [1]