R

Explicamos con ejemplos algunos comandos de R. Iremos completando este archivo durante el curso.

Tipos de Datos Básicos

• Numeric:

num <- 1.2
print(num)

[1] 1.2

Se puede chequear el tipo de dato con el comando class()

class(num)

[1] "numeric"

• Integer:

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

[1] "integer"

Tener en cuenta que el tipo integer no se asigna directamente

a <- 2
class(a)

[1] "numeric"

• Character:

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

[1] "character"

char <- "1234"
class(char)

[1] "character"

• Logical:

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

[1] "logical"

Para acceder a todas las variables u objetos que están definidos en el workspace se puede usar el comando ls()

ls()

[1] "a"        "char"     "int"      "log_true" "num"     

Más tipos de datos

• Listas: es una colección ordenada de valores, que pueden ser de varios tipos

lis1 <- 1:5  # Integer Vector
lis1

[1] 1 2 3 4 5

class(lis1)

[1] "integer"

lis2 <- letters[1:5]
class(lis2)

[1] "character"

combined_list <- list(lis1,lis2)
combined_list

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

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

Para acceder a un elemento particular de una lista, usar

lis1[[2]]

[1] 2

combined_list[[1]]

[1] 1 2 3 4 5

combined_list[[2]][3]

[1] "c"

Podemos convertir combined_list en una lista plana

flat_list <- unlist(combined_list)
flat_list

 [1] "1" "2" "3" "4" "5" "a" "b" "c" "d" "e"

flat_list[[5]]

[1] "5"

class(flat_list)

[1] "character"

• Vectores: almacenan múltiples valores del mismo tipo. Los podemos construir con la función c() (c de combinar o concatenar)

marks <- c(88,65,90,40,65)
marks

[1] 88 65 90 40 65

class(marks)

[1] "numeric"

Para obtener la longitud de un vector

length(marks)

[1] 5

y para acceder a una o varias componente usamos

marks[4]

[1] 40

marks[2:4]

[1] 65 90 40

También podemos crear un vector con enteros de 1001 a 2000 así

vec <- c(1000:1999)
length(vec)

[1] 1000

vec[length(vec)/2 + 1]

[1] 1500

Si queremos solo números impares, podemos usar la función seq() que tiene tres parámetros: start, end y el paso

seq(1,10,by = 2)

[1] 1 3 5 7 9

Veamos la diferencia entre un vector y una lista

v1 <- c(1,"2")
v1

[1] "1" "2"

class(v1)

[1] "character"

l1 <- list(1,"2")
l1

[[1]]
[1] 1

[[2]]
[1] "2"

class(l1)

[1] "list"

• Matrix: almacena datos de un mismo tipo en forma de matriz

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Podemos acceder a una entrada o a una submatriz, a una fila o a una columna

M[1,3]

[1] "DL"

M[1:2,2:3]

     [,1]      [,2]   
[1,] "ML"      "DL"   
[2,] "Pytorch" "Keras"

M[2,]

[1] "Tensorflow" "Pytorch"    "Keras"     

M[,3]

[1] "DL"    "Keras"

Algunos comandos útiles

nrow(M)

[1] 2

ncol(M)

[1] 3

length(M)

[1] 6

• DataFrames: es una matriz generalizada, o tabla, en la que cada columna puede tener diferentes tipos de datos. Cada columna corresponde a una característica o variable observada. Se crea con la función data.frame()

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)
print(dataset)

Podemos combinar DataFrames por filas o columnas

df1 <- rbind(dataset,dataset)
df1

df2 <- cbind(dataset,dataset)
df2

Para ver solo algunas filas, las dos primeras o las dos últimas

head(df1,2)

tail(dataset,2)

Para ver algunas estadísticas de la tabla

summary(dataset)

    Person               Age            Weight     
 Length:3           Min.   :26.00   Min.   :81.00  
 Class :character   1st Qu.:26.00   1st Qu.:83.00  
 Mode  :character   Median :26.00   Median :85.00  
                    Mean   :26.33   Mean   :85.33  
                    3rd Qu.:26.50   3rd Qu.:87.50  
                    Max.   :27.00   Max.   :90.00  
     Height        Salary      
 Min.   :5.8   Min.   : 50000  
 1st Qu.:5.9   1st Qu.: 65000  
 Median :6.0   Median : 80000  
 Mean   :6.0   Mean   : 76667  
 3rd Qu.:6.1   3rd Qu.: 90000  
 Max.   :6.2   Max.   :100000  

Loops

Veamos algunos ejemplos de loops en R

• for loop

 # Create a vector filled with random normal values
u1 <- rnorm(30)
print(u1)

 [1] -0.08355241  0.12287755  0.41484391 -0.45175587  0.31656793
 [6] -0.78208086 -0.96967252 -0.60717833  0.80946710 -0.66751340
[11] -0.18284893  0.18866932 -0.40542095 -2.01813661  0.63311748
[16]  0.45466150  0.86487274  0.59858002 -0.80370830 -0.69154357
[21]  1.51927394 -0.13430134  1.33450035 -0.17345346 -1.28554066
[26] -1.07423761  0.19504794 -0.10920017  0.91206408 -0.02167046

print("This loop calculates the square of the first 10 elements of vector u1")

[1] "This loop calculates the square of the first 10 elements of vector u1"

usq <- 0
for(i in 1:10) {
  # i-th element of `u1` squared into `i`-th position of `usq`
  usq[i] <- u1[i]*u1[i]
}

print(usq)

 [1] 0.006981005 0.015098893 0.172095470 0.204083369 0.100215251
 [6] 0.611650464 0.940264791 0.368665518 0.655236978 0.445574146

• While loop

# cuántos números aleatorios uniformes entre 0 y 9 tenemos que generar hasta obtener un 5?
n <- as.integer(runif(1)*10)
instancias <- 1
while(n!=0){
  n <- as.integer(runif(1)*10)
  instancias <- instancias+1
}
print(instancias)

[1] 24

• Repeat loop

# idem anterior
instancias <- 0
repeat{
  x <- as.integer(runif(1)*10)
  instancias <- instancias+1
  if(x==5) break()
}
print(instancias)

[1] 2

• Saliendo de un loop: break

La función break sale del loop y ejecuta la instrucción siguiente al mismo. En el caso de loops anidados, break solo sale del loop interno

# Make a lower triangular matrix (zeroes in upper right corner)
m=10 
n=10

# A counter to count the assignment
ctr=0

# Create a 10 x 10 matrix with zeroes 
mymat = matrix(0,m,n)

for(i in 1:m) {
  for(j in 1:n) {   
    if(i==j) { 
      break;
    } else {
       # you assign the values only when i<>j
      mymat[i,j] = i*j
      ctr=ctr+1
      }
  }
}

# Print how many matrix cells were assigned
print(mymat)

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]    0    0    0    0    0    0    0    0    0     0
 [2,]    2    0    0    0    0    0    0    0    0     0
 [3,]    3    6    0    0    0    0    0    0    0     0
 [4,]    4    8   12    0    0    0    0    0    0     0
 [5,]    5   10   15   20    0    0    0    0    0     0
 [6,]    6   12   18   24   30    0    0    0    0     0
 [7,]    7   14   21   28   35   42    0    0    0     0
 [8,]    8   16   24   32   40   48   56    0    0     0
 [9,]    9   18   27   36   45   54   63   72    0     0
[10,]   10   20   30   40   50   60   70   80   90     0

Evitando loops

Cuando es posible, conviene evitar los loops. Aquí algunas herramientas

# construimos una matriz de 4x5, que contiene números de 1 a 5
mymat<-matrix(rep(seq(5), 4), ncol = 5)

# aplicamos la función `sum` a las filas de `mymat` (observar el '1') 
apply(mymat, 1, sum)

[1] 15 15 15 15

# aplicamos la función `sum` a las columnas de `mymat` (observar el '2')
apply(mymat, 2, sum)

[1] 10 11 12 13 14

# Podemos aplicar una función definida por el usuario alas filas o columnas. en este caso sumamos `y=4.5` a la 'sum' de cada fila de `mymat` 
apply(mymat, 1, function(x, y) sum(x) + y, y=4.5)

[1] 19.5 19.5 19.5 19.5

# Aplicamos la función `summary` a cada columna
apply(mymat, 2, function(x) summary(x))

        [,1] [,2] [,3] [,4] [,5]
Min.    1.00 1.00 1.00 1.00 2.00
1st Qu. 1.75 1.75 1.75 2.50 2.75
Median  2.50 2.50 3.00 3.50 3.50
Mean    2.50 2.75 3.00 3.25 3.50
3rd Qu. 3.25 3.50 4.25 4.25 4.25
Max.    4.00 5.00 5.00 5.00 5.00

Gráficos sencillos con Plot

Plot

x <- seq(-pi,pi,0.1)
plot(x, sin(x))

Agregando título y nombre a los ejes

plot(x, sin(x),
main="La función seno",
ylab="sin(x)")

Cambiando el color y tipo

El color se puede cambiar con el parámetro col, como col="blue", y el tipo con el parámetro type, que acepta los siguientes valores

• “p” - points
• “l” - lines
• “b” - both points and lines
• “c” - empty points joined by lines
• “o” - overplotted points and lines
• “s” and “S” - stair steps
• “h” - histogram-like vertical lines
• “n” - does not produce any points or lines

plot(x, sin(x),
main="The Sine Function",
ylab="sin(x)",
type="l",
col="blue")

Superponiendo gráficos y la función legend()

plot(x, sin(x),
main="Overlaying Graphs",
ylab="",
type="l",
col="blue")
lines(x,cos(x), col="red")

legend("topleft",
c("sin(x)","cos(x)"),
fill=c("blue","red")
)

Múltiples plots

par(mfrow=c(1,2))
plot(x, sin(x),
     main="Función seno",
     ylab="",
     type="l",
     col="blue")
plot(x,cos(x), 
     main="Función coseno",
     ylab="",
     type="l",
     col="red")

Resolviendo problemas de valores iniciales

Tomado de Package deSolve: Solving Initial Value Differential Equations in R por K. Soetaert, T. Petzoldt y R. Woodrow Setzer.

Consideremos las ecuaciones de Lorenz que representan un comportamiento idealizado de la atmósfera terrestre. Este modelo describe la dinámica de tres variables de estado, \(X\), \(Y\) y \(Z\):

\[\begin{eqnarray*} \frac{dX}{dt}&=&aX+YZ\\ \frac{dY}{dt}&=&b(Y-Z)\\ \frac{dZ}{dt}&=&-XY+cY-Z \end{eqnarray*}\] con condiciones iniciales \[ X(0)=Y(0)=Z(0)=1 \] y con \(a,b\) y \(c\) que son parámetros con valores \(-\frac83, -10\) y \(28\) respectivamente.

La implementación de este problemas de valores iniciales puede en dos partes: la especificación del modelo y la aplicación del modelo.

• especificación del modelo:
  • Definir los parámetros y sus valores
  • Definir las variables de estado y sus condiciones iniciales
  • Implementar las ecuaciones del modelo y calcular las razones de cambio de las variables de estado
• aplicación del modelo:
  • Especificar el rango de tiempo en que se desear resolver las ecuaciones
  • Integrar el modelo
  • Graficar los resultados

Especificación del modelo

Definimos dos vectores conteniendo los parámetros del modelo y las variables de estado con las condiciones iniciales

Parámetros

parameters <- c(a = -8/3, b = -10, c = 28)

Variables de estado

state <- c(X = 1, Y = 1, Z = 1)

Ecuaciones

Las ecuaciones se especifican por una función Lorenz que, dados los parámetros y variables de estado, devuelve las derivadas de las mismas.

Lorenz <- function(t, state, parameters) {
  # para poder usar los nombres a,b,c,X,Y,Z
  with(as.list(c(state, parameters)),{
  # rate of change
  dX <- a*X + Y*Z
  dY <- b * (Y-Z)
  dZ <- -X*Y + c*Y - Z
 
  # devuelve las derivadas dX,dY,dZ como vector
  list(c(dX, dY, dZ))
  }) # end with(as.list ...
  }

Aplicación del modelo

Rango de tiempo

times <- seq(0, 20, by = 0.01)

Integración

Usaremos la función ode del paquete deSolve que no está presente en la distribución básica, por eso agregamos este paquete y luego aplicamos la función

library(deSolve)
out <- ode(y = state, times = times, func = Lorenz, parms = parameters)
head(out)

     time         X        Y        Z
[1,] 0.00 1.0000000 1.000000 1.000000
[2,] 0.01 0.9848912 1.012567 1.259918
[3,] 0.02 0.9731148 1.048823 1.523999
[4,] 0.03 0.9651593 1.107207 1.798314
[5,] 0.04 0.9617377 1.186866 2.088545
[6,] 0.05 0.9638068 1.287555 2.400161

class(out)

[1] "deSolve" "matrix" 

ode devuelve un objeto de la clase deSolve con una matriz que contiene una columna para el tiempo y una columna por cada variable de estado. Cada fila de la matriz contiene los valores de las variables en el tiempo correspondiente.

Gráficos

par(oma = c(0, 0, 1, 0))
plot(out, xlab = "time", ylab = "-")
plot(out[, "X"], out[, "Z"], pch = ".")

mtext(outer = TRUE, side = 3, "Lorenz model", cex = 1.0)

La función ode implementa un método por default. Sin embargo es posible que el método sea elegido por el usuario usando el parámetro method. Por ejemplo, si se quiere usar el método de Runge-Kutta de cuarto orden, podemos escribir

out <- ode(y = state, times = times, func = Lorenz, parms = parameters, method = "rk4")

Es posible usar los siguientes métodos: “lsoda” (default), “lsode”, “lsodes”, “lsodar”, “vode”, “daspk”, “euler”, “rk4”, “ode23”, “ode45”, “radau”, “bdf”, “bdf_d”, “adams”, “impAdams”, “impAdams_d”, “iteration”

Para ver las características de un método de Runge-Kutta utilizar la función rkMethod()

rkMethod("rk4")

$ID
[1] "rk4"

$varstep
[1] FALSE

$A
[1] 0.0 0.5 0.5 1.0

$b1
[1] 0.1666667 0.3333333 0.3333333 0.1666667

$c
[1] 0.0 0.5 0.5 1.0

$stage
[1] 4

$Qerr
[1] 4

attr(,"class")
[1] "list"     "rkMethod"

Los métodos euler y rk4 utilizan un paso en el tiempo fijo. Pueden implementarse como un método de Runge-Kutta general, con la función ode especificando un paso de tiempo independiente del argunmento times utilizando el argunmento hini. También pueden implementarse con las funciones simplificadas euler o rk4, en las que el paso en el tiempo está determinada por el times span vector times. Los demás métodos utilizan un paso de tiempo variable (adaptativo).

Operaciones con Matrices

Suponiendo que \(A\) y \(B\) son matrices y \(x\) y \(b\) vectores, estas son algunas operaciones que podemos realizar.

• A*B Multiplica elemento por elemento \((A::B)\)
• A%*%B Multiplica las matrices \(A\) y \(B\)
• t(A) Traspuesta de \(A\)
• diag(x) Crea una matriz diagonal, con los elementos de \(x\) en la diagonal principal
• diag(A) Devuelve el vector conteniendo los elementos de la diagonal principal de \(A\)
• diag(k) Crea una matriz con \(k\) en la diagonal, si \(k\) es un escalar
• solve(A,b) Calcula la solución \(x\) de \(Ax=b\)
• solve(A) Calcula la inversa de \(A\)
• y <- eigen(A) Calcula autovalores y autovectores de \(A\), y$values contiene los autovalores, y$vectors contiene los autovectores