Breve Introducción a R

Análisis espacial con R

Dr. Francisco Zambrano

Para partir

Motivación

• Es quizas el más poderoso ambiente computacional para análisis de datos.

• Con R puedes:

  • leer y guardar archivos,
  • manipular y resumir datos
  • correr modelos y test estadísticos
  • crear elegantes gráficos
  • y mucho, mucho más

• Las funcionalidades se amplian gracias a miles de paquetes (plug-ins)

• Consejos:

  • Cuando tengas duda, pruébalo! (Norman Matloff’s)
  • Estas aprendiendo un lenguaje, tendras que dedicar mucho tiempo para alcanzar un buen nivel en R, pero vale la pena.

Motivación

¿Por qué utilizar R?

• R en su nucleo, es un lenguaje de programación orientada a objetos de alto nivel, lenguaje de programación funcional (Wickham, 2014), y fue especialmente diseñado como una interfaz intercativa a otros softwares (Chambers 2016).

• R es una herramienta potente que ha tenido un alto crecimiento, en particular para el análisis espacial.

• Revolución de datos (ej., datos satelitales).

• R para entender el mundo

• R es un ambiente y lenguaje de código abierto y multiplataforma para computacion estadística y gráficos.

• Por todas las ventajas que tiene para análisis de datos (includios espaciales) e investigación reproducible.

Ranking popularidad R

R: lo básico

Sintaxis de R

Ejemplo de script:

• los comentarios # se utilizan para documentar funciones y su contenido.
• en R se tuenen objetos (variables) y funciones
• el operador de asignación <-
• el operador = para argumentos en una función

# Carga paquete {ggplot2}
library(ggplot2)

# nombree de variables
nombre_archivo <- 'datos.csv'

# cargar datos

data <- read.csv2(nombre_archivo,header = FALSE)

Sintaxis de R

Tener en mente

todo lo que hay en R es un objeto y todo lo que pasa en R es fruto de una función

Funciones y argumentos

• Las funciones ejecutan acciones sobre los argumentos.
  • synatxis: nombre_funcion(argumentos)
  • ejemplo: mean(10)
• Los argumentos son los datos de entrada - valores, expresiones, texto, etc.
  • Le dices a la función que argumentos necesita dentro de los parentesis.

Usa la función ls() para ver todos los objetos definidos. Notar que ls() no toma ningun argumento!

ls()

Tipos de datos

Tipos de datos:
- Numéricos: integer y double
- Caracter
- Lógicos
- Complejos
- Raw

v1 <- c(1,5,7,10)
v2 <- c('palabra1','palabra2','palabra3')
v3 <- c(TRUE, FALSE, FALSE, TRUE)

Tipos de datos derivados

Valores faltantes (NA)

(n1 <- c(NA, 1, 3, NA))

[1] NA  1  3 NA

(n2 <- c(NA, 'a', 'b', NA))

[1] NA  "a" "b" NA 

(n3 <- c(NA, TRUE, FALSE, NA))

[1]    NA  TRUE FALSE    NA

Date y date-time

(d1 <- as.Date("2024-09-02"))

[1] "2024-09-02"

class(d1)

[1] "Date"

(d2 <- as.POSIXct("2024-09-02 19:00:00"))

[1] "2024-09-02 19:00:00 -04"

class(d2)

[1] "POSIXct" "POSIXt" 

Factores

(f1 <- factor(c('A','B','A','B','C','C')))

[1] A B A B C C
Levels: A B C

levels(f1)

[1] "A" "B" "C"

Estructuras de datos

Estructuras de datos:
- vectores
- matrices
- arrays
- data.frame
- listas

Vectores

Hay dos tipos de vectores en R:

• Vectores atómicos: homogéneos
  • Seis tipos: lógicos, integer, double, character, complex, and raw. Vectores tipo integer y double son conocidos como vectores numericos.
• Listas: hetereogéneos
  • son a veces llamados vectores recursivos, por que las listas puede contener otras listas.

Estructuras de datos

Almacena el mismo tipo de dato (numeric, character, logical)

Vectores atómicos

(v1 <- c(1, 2, 3, 4)) #numeric vector

[1] 1 2 3 4

(v2 <- c('a', 'b', 'c','d')) #character vector

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

(v3 <- c(TRUE, FALSE, TRUE, TRUE)) # logical vector

[1]  TRUE FALSE  TRUE  TRUE

Matrices

(m1 <- matrix(data = 1:9,nrow = 3, ncol = 3))

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

(m2 <- matrix(1:9, nrow = 3, byrow = TRUE))

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

Data Frames

(df <- data.frame(columna1=v1, 
                  columna2=v2, 
                  columna3=v3))

  columna1 columna2 columna3
1        1        a     TRUE
2        2        b    FALSE
3        3        c     TRUE
4        4        d     TRUE

#str(df)

Listas

(l <- list(v1,m2,df,list(v1,v2)))

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

[[2]]
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

[[3]]
  columna1 columna2 columna3
1        1        a     TRUE
2        2        b    FALSE
3        3        c     TRUE
4        4        d     TRUE

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

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

Algunas cosas importantes

• R es un lenguaje vectorizado por defecto.

Ejemplo

Aplicar la función log a cada elemento del vector v1.

v1 <- c(40,30,10,50,80)
v2 <- vector()

for (i in 1:5) v2[i] <- log(v1[i])
v2

[1] 3.688879 3.401197 2.302585 3.912023 4.382027

Pero lo podemos realizar así:

(v2 <- log(v1))

[1] 3.688879 3.401197 2.302585 3.912023 4.382027

Algunas cosas importantes

Jerarquia de coherción

Si intentamos mezclar diferentes tipos de datos en un vector.

(v1 <- c(0, TRUE, 'a'))

[1] "0"    "TRUE" "a"   

logical -> integer -> double -> character

Reciclado de vectores

Si intentamos realizar operaciones con vectores de diferentes cantidades de elementos.

v1 <- c(1,5,10,15,3,2,7,6,0)
v2 <- c(1,2,3)
v3 <- c(1,2)
(v1 + v2)

[1]  2  7 13 16  5  5  8  8  3

(v1 + v3)

Warning in v1 + v3: longer object length is not a multiple of shorter object
length

[1]  2  7 11 17  4  4  8  8  1

Condicionales y ciclos

a <- 5

if (a==5){
  print('A es igual a 5') 
} else {
    print('A no es igual a 5')
  }

[1] "A es igual a 5"

for (i in 10:1) {
  print(i)
}

[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1

Funciones applys

Reemplazan en muchos casos el uso de ciclos for

apply: aplica funciones sobre matrices o arrays

m2

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

apply(X = m2,MARGIN = 1,FUN = mean) #aplica por fila

[1] 2 5 8

apply(m2,1,sum) #aplica por fila

[1]  6 15 24

apply(m2,2,sum) #aplica por columna

[1] 12 15 18

lapply aplica una función a una lista

lapply(l,class)

[[1]]
[1] "numeric"

[[2]]
[1] "matrix" "array" 

[[3]]
[1] "data.frame"

[[4]]
[1] "list"

Crear funciones

Sintaxis

nombre_funcion <- function(arg1, arg2, ...){
  #script
}

Ejemplos de funciones

fun <- function(x,y) {
  x+y
}

fun2 <- function(x,...){
  fun(x,...)+2
}
fun2(8,4)

[1] 14

fun2(1:5,3:5)

[1]  6  8 10  9 11