Introducción

R es un Lenguaje estadístico basado en el software S creado por John Chambers a finales de los 70’s. Es una versión didáctica creada por Ross Ihaka y Robert Gentlman quienes la lanzaron como open source 1995.

R es un ambiente y lenguaje estadístico con un sinnúmero de funciones estadísticas y capacidades gráficas de alta calidad.

Al se un open source ofrece la gran ventaja de ser gratuito.

Para descargarlo basta entrar al sitio www.r-project.org y elegir la opción adecuada de acuerdo al sistema operativo que se va a utilizar (Windows, iOS o Linux).

R tiene amplias capacidades aritméticas.

#Suma
5 + 4

[1] 9

#Resta
5 - 4

[1] 1

#Multiplicación
5 * 4

[1] 20

#División
144/12

[1] 12

#Exponencial
12^2

[1] 144

#Logaritmo natural
log(10)

[1] 2.302585

#Antilogaritmo
exp(10)

[1] 22026.47

#Raíz cuadrada
sqrt(36)

[1] 6

#Números factoriales
factorial(4)

[1] 24

#Redondeo
round(pi, 2)

[1] 3.14

POO

R trabaja bajo el enfoque de programación orientada a objetos en los cuales se almacena información, lo cual es una gran ventaja ya que una vez obtenida o cargada la información puede llamarse fácilmente para realizar un análisis o agregar la información con otra.

Asignación

La asignación de datos a un objeto se realiza mediante el símbolo <- aunque también puede realizarse mediante el signo de igual. El código de R es sensible a las mayúsculas y minúsculas por lo que utilizarlas implica diferencias de forma que R no es lo mismo que r.

x <- 2
2 + x

[1] 4

Existen diferentes tipos de objetos en R.

Funciones

Uno de los componentes principales para trabajar en R son las funciones, estos son comandos que realizan una acción en el programa. Las funciones tienen un esquema general como el siguiente: nombre.funcion(argumentos). Como R es un lenguaje nos permite crear nuestras propias funciones.

print("Bienvenidos al curso")

[1] "Bienvenidos al curso"

Los argumentos son fragmentos de información que le indican a la función cómo realizar su tarea.

str(plot)

function (x, y, ...)

Todas las funciones (y operadores) incluidas en R cuentan con documentación que ofrece información sobre que se puede realizar con la función, cuáles son los argumentos que incluye y ejemplos sobre su funcionamiento.

Para consultar esta documentación se puede utilizar la función help() o el operador ?.

help(print)
#o
?print

Al ser un lenguaje de programación, R permite al usuario crear sus propias funciones.

mi_edad <- function(nacimiento, fecha) {
    cat("Tienes ", edad <- fecha - nacimiento, " años")
}
mi_edad(1998, 2021)

Tienes  23  años

Vectores

Son la unidad funcional de R, los vectores son objetos que tienen una sola dimensión y almacenan elementos de una sola clase: numérico -lógico, complejo, entero, doble-, caracter, etc.)

numeros <- c(1:4)  #Vector numérico
class(numeros)

[1] "integer"

numeros

[1] 1 2 3 4

letras <- letters[1:4]  #Vector de caracteres
class(letras)

[1] "character"

Si queremos obtener un elemento de un vector podemos utilizar el operador [].

letras[3]

[1] "c"

R puede realizar operaciones con vectores, por ejemplo:

a<-1:5
b<-10:6
a+b

[1] 11 11 11 11 11

a-b

[1] -9 -7 -5 -3 -1

a*b

[1] 10 18 24 28 30

a/b

[1] 0.1000000 0.2222222 0.3750000 0.5714286 0.8333333

Cuando los vectores no tienen la misma longitud, R tiene una propiedad recursiva.

c<-1:3
a+c

Warning in a + c: longitud de objeto mayor no es múltiplo de la longitud de uno
menor

[1] 2 4 6 5 7

a*c

Warning in a * c: longitud de objeto mayor no es múltiplo de la longitud de uno
menor

[1]  1  4  9  4 10

Factores

Los factores son vectores en los que asigna los valores que son válidos en nuestro vector, estos valores se conocen como niveles del factor.

fletras <- factor(letras)
class(fletras)

[1] "factor"

Los factores pueden ser ordenados lo que indica al programa que es una variable categórica en la que existe un orden en los niveles.

fletras_ord<- factor(letras, ordered = T)
fletras

[1] a b c d
Levels: a b c d

fletras_ord

[1] a b c d
Levels: a < b < c < d

Arreglos

Los arreglos son objetos que tienen al menos dos dimensiones y que solo pueden contener elementos de una misma clase.

arreglo <- array(1:12, dim = c(2, 3, 2))
dim(arreglo)

[1] 2 3 2

arreglo

, , 1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

Matrices

Son arreglos con forma rectangular, es decir, solo tienen dos dimensiones.

matriz <- matrix(1:4, nrow = 2, ncol = 2)  #Matriz de 2X2
inversa <- solve(matriz)  #Matriz inversa de la matriz
matriz

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

inversa

     [,1] [,2]
[1,]   -2  1.5
[2,]    1 -0.5

Los elementos de una matriz pueden ubicarse de forma similar a las coordenadas, por ejemplo, martiz[1,2] ubica el elemento en la fila uno y la columna dos.

matriz[1, 2]

[1] 3

En R también podemos realizar operaciones con matrices:

X<-matrix(1:4,nrow = 2);X

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

Y<-matrix(2:5,nrow=2);Y

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

X+Y

     [,1] [,2]
[1,]    3    7
[2,]    5    9

X*Y

     [,1] [,2]
[1,]    2   12
[2,]    6   20

colnames(X)<-c("a","b")
rownames(X)<-c("c","d")
colnames(Y)<-c("A","B")
rownames(Y)<-c("C","D")
#Multiplicación de matrices
X%*%Y

   A  B
c 11 19
d 16 28

#Producto exterior de matrices
X%o%Y

, , C, A

  a b
c 2 6
d 4 8

, , D, A

  a  b
c 3  9
d 6 12

, , C, B

  a  b
c 4 12
d 8 16

, , D, B

   a  b
c  5 15
d 10 20

#Diagonal
diag(X)

[1] 1 4

#Matriz inversa
solve(X)

   c    d
a -2  1.5
b  1 -0.5

#Matriz de identidad
X%*%solve(X)

  c d
c 1 0
d 0 1

#Descomposición de valores singulares
svd(X)

$d
[1] 5.4649857 0.3659662

$u
           [,1]       [,2]
[1,] -0.5760484 -0.8174156
[2,] -0.8174156  0.5760484

$v
           [,1]       [,2]
[1,] -0.4045536  0.9145143
[2,] -0.9145143 -0.4045536

Listas

Las listas son objetos que nos permiten almacenar otros objetos de distinta clase.

lista <- list(numeros, letras, arreglo, matriz)
lista

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

[[2]]
[1] "a" "b" "c" "d"

[[3]]
, , 1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12


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

Los elementos de una lista pueden extraerse con [[]] o cuando se asigna un nombre con $.

names(lista) <- c("numeros", "letras", "arreglo", "matriz")
lista[[1]]

[1] 1 2 3 4

lista$letras

[1] "a" "b" "c" "d"

Bases de datos

Las bases de datos son una variación de las listas, permiten almacenar vectores de objetos de diferente tipo (numéricas, lógicas, etc.) pero todos estos objetos deben ser de la misma longitud. Generalmente en las bases de datos tenemos variables en las columnas y observaciones en las filas.

df <- data.frame(nombre = c("Ana", "Luis", "Juan", "Mary"), num.list = numeros, 
    calificacion = letras, stringsAsFactors = T)
df

  nombre num.list calificacion
1    Ana        1            a
2   Luis        2            b
3   Juan        3            c
4   Mary        4            d

Para extraer un dato de una base de datos indicamos entre corchetes la fila y la columna que corresponden:

df[1, 2]

[1] 1

O podemos extraer el vector de una columna con el operador $.

df$nombre

[1] Ana  Luis Juan Mary
Levels: Ana Juan Luis Mary

La función str nos da un resumen de qué contiene información importante de la base de datos.

str(df)

'data.frame':   4 obs. of  3 variables:
 $ nombre      : Factor w/ 4 levels "Ana","Juan","Luis",..: 1 3 2 4
 $ num.list    : int  1 2 3 4
 $ calificacion: Factor w/ 4 levels "a","b","c","d": 1 2 3 4

O podemos obtener un resumen de cada variable en la base de datos con la función summary().

summary(df)

  nombre     num.list    calificacion
 Ana :1   Min.   :1.00   a:1         
 Juan:1   1st Qu.:1.75   b:1         
 Luis:1   Median :2.50   c:1         
 Mary:1   Mean   :2.50   d:1         
          3rd Qu.:3.25               
          Max.   :4.00

Sesión 1