El contenedor vector

En R, un vector es una combinación de datos con la particularidad de que todos los datos contenidos en un vector son del mismo tipo. Podemos almacenar por ejemplo múltiples elementos del tipo character o numeric en un vector, pero no ambos. El contenedor vector es importante porque es el elemento básico de R.

miVec <- c(1, 5, 3, 6)
print(miVec)

## [1] 1 5 3 6

El contenedor vector

typeof(miVec)

## [1] "double"

is.vector(miVec)

## [1] TRUE

miVec <- as.integer(c(1, 5, 3, 6))
typeof(miVec)

## [1] "integer"

El contenedor vector

miVec02 <- c("a", "b", "c") 
print(miVec02)

## [1] "a" "b" "c"

typeof(miVec02)

## [1] "character"

is.vector(miVec02)

## [1] TRUE

El contenedor vector

El valor NA se puede usar para especificar que no hay datos o datos faltantes.

miVecNA <- c(1, NA, 3, NA, 5)
print(miVecNA)

## [1]  1 NA  3 NA  5

typeof(miVecNA)

## [1] "double"

is.vector(miVecNA)

## [1] TRUE

El contenedor vector

Si combinamos diferentes tipos de datos, R intentará transformar los elementos en un tipo de forma predeterminada.

miVecNA <- c(1, NA, 3, NA, 5, "NA")
print(miVecNA)

## [1] "1"  NA   "3"  NA   "5"  "NA"

typeof(miVecNA)

## [1] "character"

El contenedor vector

Podemos combinar objetos existentes dentro de un vector.

vecA <- c("a", "b")
vecB <- c("e", "f")
vecC <- c(vecA, "c", "d", vecB)
print(vecC)

## [1] "a" "b" "c" "d" "e" "f"

Operaciones con un vector

miVecNA <- c(1, NA, 3, NA, 5)
miVecNA + 100

## [1] 101  NA 103  NA 105

Se llama vectorización y eso es lo que hace que R es tan poderoso. Siempre que sea posible, intentaremos realizar operaciones utilizando vectorización.

Operaciones con un vector

miVec1 <- c(1, 1, 1, 1, 1, 1, 1, 1, 1)
print(miVec1)

## [1] 1 1 1 1 1 1 1 1 1

miVec2 <- c(10, 20, 30)
print(miVec2)

## [1] 10 20 30

miVec1 + miVec2

## [1] 11 21 31 11 21 31 11 21 31

Operaciones con un vector

Para acceder a un elemento de un vector usamos los corchetes [].

miVec20 <- c(10, 20, 30, 40, 50, 60, 70, 80, 90)
miVec21 <- c("a", "b", "c", "d", "e", "f", "g", "h", "i")
miVec20[1]

## [1] 10

miVec21[3]

## [1] "c"

Operaciones con un vector

miVec20[c(1, 5, 9)]

## [1] 10 50 90

miVec21[c(4, 3, 1)]

## [1] "d" "c" "a"

miVec21[c(4, 4, 3, 4, 3, 2, 5)]

## [1] "d" "d" "c" "d" "c" "b" "e"

Operaciones con un vector

miVec20[miVec20 >= 50]

## [1] 50 60 70 80 90

miVec20[(miVec20 >= 50) & ((miVec20 < 80))]

## [1] 50 60 70

miVec20[miVec20 != 50]

## [1] 10 20 30 40 60 70 80 90

Operaciones con un vector

miVec20[miVec20 == 30]

## [1] 30

miVec20[(miVec20 == 30) | (miVec20 == 50)]

## [1] 30 50

miVec21[miVec21 == "a"]

## [1] "a"

Operaciones con un vector

miVec21[miVec20 >= 50]

## [1] "e" "f" "g" "h" "i"

miVec21[(miVec20 >= 50) & ((miVec20 < 80))]

## [1] "e" "f" "g"

miVec21[miVec20 != 50]

## [1] "a" "b" "c" "d" "f" "g" "h" "i"

Operaciones con un vector

miVec21[miVec20 == 30]

## [1] "c"

miVec21[(miVec20 == 30) | (miVec20 == 50)]

## [1] "c" "e"

miVec21[(miVec20 == 30) | (miVec21 == "h")]

## [1] "c" "h"

Operaciones con un vector

print(miVec20[-1])

## [1] 20 30 40 50 60 70 80 90

print(miVec21[-5])

## [1] "a" "b" "c" "d" "f" "g" "h" "i"

print(miVec20[-c(1, 2, 5)])

## [1] 30 40 60 70 80 90

print(miVec21[-c(1, 2, 5)])

## [1] "c" "d" "f" "g" "h" "i"

Operaciones con un vector

miVec22 <- c(TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE)
miVec21[miVec22]

## [1] "a" "b" "d" "f" "h" "i"

Dar nombres a un vector

miVec23 <- c(aaa = 10, bbb = 20, ccc = 30, ddd = 40, eee = 50)
print(miVec23)

## aaa bbb ccc ddd eee 
##  10  20  30  40  50

miVec23["bbb"]

## bbb 
##  20

names(miVec23)

## [1] "aaa" "bbb" "ccc" "ddd" "eee"

Modificar un vector

print(miVec21)

## [1] "a" "b" "c" "d" "e" "f" "g" "h" "i"

miVec21[3] <- "zzz"
print(miVec21)

## [1] "a"   "b"   "zzz" "d"   "e"   "f"   "g"   "h"   "i"

miVec21[(miVec20 >= 50) & ((miVec20 < 80))] <- "0"
print(miVec21)

## [1] "a"   "b"   "zzz" "d"   "0"   "0"   "0"   "h"   "i"

Modificar un vector

print(miVec23)

## aaa bbb ccc ddd eee 
##  10  20  30  40  50

miVec23["ccc"] <- miVec23["ccc"] + 100
print(miVec23)

## aaa bbb ccc ddd eee 
##  10  20 130  40  50

Modificar un vector

print(miVec23)

## aaa bbb ccc ddd eee 
##  10  20 130  40  50

names(miVec23)[2] <- "bb_bb"
print(miVec23)

##   aaa bb_bb   ccc   ddd   eee 
##    10    20   130    40    50

Modificar un vector

Podemos hacer mucho más con un vector y volveremos a su manejo y operaciones posibles en el capítulo sobre funciones…

El contenedor list

El contenedor de tipo list le permite almacenar listas de elementos. Contrariamente a lo que vimos antes con el tipo vector, los elementos del tipo list pueden ser diferentes (por ejemplo, un vector de tipo numeric, luego un vector de tipo character). Los elementos del tipo list también pueden ser contenedores diferentes (por ejemplo, un vector, luego una list).

El contenedor list

miList01 <- list()
print(miList01)

## list()

El contenedor list

miList02 <- list(5, "qwerty", c(4, 5, 6), c("a", "b", "c"))
print(miList02)

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"

El contenedor list

miList03 <- list(5, "qwerty", list(c(4, 5, 6), c("a", "b", "c")))
print(miList03)

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [[3]][[1]]
## [1] 4 5 6
## 
## [[3]][[2]]
## [1] "a" "b" "c"

El contenedor list

is.list(miList02)

## [1] TRUE

typeof(miList02)

## [1] "list"

Operaciones con una list

Los elementos del contenedor list son identificables por los corchetes dobles [[ ]].

print(miList02)

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"

Operaciones con una list

typeof(miList02)

## [1] "list"

miList02[[1]]

## [1] 5

typeof(miList02[[1]])

## [1] "double"

Operaciones con una list

print(miList02)

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"

miList02[[4]][2]

## [1] "b"

Operaciones con una list

miList04 <- list(miList02, miList03)
print(miList04)

## [[1]]
## [[1]][[1]]
## [1] 5
## 
## [[1]][[2]]
## [1] "qwerty"
## 
## [[1]][[3]]
## [1] 4 5 6
## 
## [[1]][[4]]
## [1] "a" "b" "c"
## 
## 
## [[2]]
## [[2]][[1]]
## [1] 5
## 
## [[2]][[2]]
## [1] "qwerty"
## 
## [[2]][[3]]
## [[2]][[3]][[1]]
## [1] 4 5 6
## 
## [[2]][[3]][[2]]
## [1] "a" "b" "c"

Operaciones con una list

miList04[[2]][[3]][[1]][1]

## [1] 4

Operaciones con una list

bddInsect <- list(Snonagrioides = list(site01 = c(12, 5, 8, 7), site02 = c(5, 23, 4, 41), site03 = c(12, 0, 0, 0)), Onubilalis = list(site01 = c(12, 1, 2, 3), site02 = c(0, 0, 0, 1), site03 = c(1, 1, 2, 3)))
print(bddInsect)

## $Snonagrioides
## $Snonagrioides$site01
## [1] 12  5  8  7
## 
## $Snonagrioides$site02
## [1]  5 23  4 41
## 
## $Snonagrioides$site03
## [1] 12  0  0  0
## 
## 
## $Onubilalis
## $Onubilalis$site01
## [1] 12  1  2  3
## 
## $Onubilalis$site02
## [1] 0 0 0 1
## 
## $Onubilalis$site03
## [1] 1 1 2 3

Operaciones con una list

El código está hecho para la máquina, pero también para los humanos.

bddInsect <- list(
  Snonagrioides = list(
    site01 = c(12, 5, 8, 7), 
    site02 = c(5, 23, 4, 41), 
    site03 = c(12, 0, 0, 0)
  ), 
  Onubilalis = list(
    site01 = c(12, 1, 2, 3), 
    site02 = c(0, 0, 0, 1), 
    site03 = c(1, 1, 2, 3)
  )
)

Operaciones con una list

bddInsect[[1]][[2]]

## [1]  5 23  4 41

bddInsect$Snonagrioides$site02

## [1]  5 23  4 41

bddInsect[['Snonagrioides']][['site02']]

## [1]  5 23  4 41

Operaciones con una list

names(bddInsect)

## [1] "Snonagrioides" "Onubilalis"

names(bddInsect[[1]])

## [1] "site01" "site02" "site03"

Operaciones con una list

bddInsect[[1]][[2]]

## [1]  5 23  4 41

is.list(bddInsect[[1]][[2]])

## [1] FALSE

bddInsect[[1]][2]

## $site02
## [1]  5 23  4 41

is.list(bddInsect[[1]][2])

## [1] TRUE

Operaciones con una list

bddInsect[[1]][c(1, 2)]

## $site01
## [1] 12  5  8  7
## 
## $site02
## [1]  5 23  4 41

bddInsect[['Snonagrioides']][c("site01", "site02")]

## $site01
## [1] 12  5  8  7
## 
## $site02
## [1]  5 23  4 41

Modificar una list

print(miList02)

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"

Modificar una list

miList02[[1]] <- 12
print(miList02)

## [[1]]
## [1] 12
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"

Modificar una list

print(bddInsect)

## $Snonagrioides
## $Snonagrioides$site01
## [1] 12  5  8  7
## 
## $Snonagrioides$site02
## [1]  5 23  4 41
## 
## $Snonagrioides$site03
## [1] 12  0  0  0
## 
## 
## $Onubilalis
## $Onubilalis$site01
## [1] 12  1  2  3
## 
## $Onubilalis$site02
## [1] 0 0 0 1
## 
## $Onubilalis$site03
## [1] 1 1 2 3

Modificar una list

bddInsect[['Snonagrioides']][['site02']] <- c(2, 4, 6, 8)
print(bddInsect)

## $Snonagrioides
## $Snonagrioides$site01
## [1] 12  5  8  7
## 
## $Snonagrioides$site02
## [1] 2 4 6 8
## 
## $Snonagrioides$site03
## [1] 12  0  0  0
## 
## 
## $Onubilalis
## $Onubilalis$site01
## [1] 12  1  2  3
## 
## $Onubilalis$site02
## [1] 0 0 0 1
## 
## $Onubilalis$site03
## [1] 1 1 2 3

Modificar una list

miList0203 <- c(miList02, miList03)
print(miList0203)

## [[1]]
## [1] 12
## 
## [[2]]
## [1] "qwerty"
## 
## [[3]]
## [1] 4 5 6
## 
## [[4]]
## [1] "a" "b" "c"
## 
## [[5]]
## [1] 5
## 
## [[6]]
## [1] "qwerty"
## 
## [[7]]
## [[7]][[1]]
## [1] 4 5 6
## 
## [[7]][[2]]
## [1] "a" "b" "c"

Modificar una list

miList05 <- list("a", c("b", "c"), "d")
print(miList05)

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

unlist(miList05)

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

Modificar una list

print(miList05)

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

Modificar una list

miList05 <- c(miList05, "e")
print(miList05)

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

Modificar una list

print(miList05)

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

Modificar una list

miList05[[2]] <- NULL
print(miList05)

## [[1]]
## [1] "a"
## 
## [[2]]
## [1] "d"
## 
## [[3]]
## [1] "e"

El contenedor data.frame

El contenedor data.frame se puede comparar a una tabla. Es en realidad un caso especial de list donde todos los elementos de la list tienen el mismo tamaño.

El contenedor data.frame

miDf01 <- data.frame(
  numbers = c(1, 2, 3, 4), 
  logicals = c(TRUE, TRUE, FALSE, TRUE), 
  characters = c("a", "b", "c", "d")
)
print(miDf01)

##   numbers logicals characters
## 1       1     TRUE          a
## 2       2     TRUE          b
## 3       3    FALSE          c
## 4       4     TRUE          d

El contenedor data.frame

numbers <- c(1, 2, 3, 4)
logicals <- c(TRUE, TRUE, FALSE, TRUE)
characters <- c("a", "b", "c", "d")
miDf01 <- data.frame(numbers, logicals, characters)
print(miDf01)

##   numbers logicals characters
## 1       1     TRUE          a
## 2       2     TRUE          b
## 3       3    FALSE          c
## 4       4     TRUE          d

El contenedor data.frame

str(miDf01)

## 'data.frame':    4 obs. of  3 variables:
##  $ numbers   : num  1 2 3 4
##  $ logicals  : logi  TRUE TRUE FALSE TRUE
##  $ characters: Factor w/ 4 levels "a","b","c","d": 1 2 3 4

El contenedor data.frame

Por defecto, data.frame transforma character en factor

str(miDf01)

## 'data.frame':    4 obs. of  3 variables:
##  $ numbers   : num  1 2 3 4
##  $ logicals  : logi  TRUE TRUE FALSE TRUE
##  $ characters: Factor w/ 4 levels "a","b","c","d": 1 2 3 4

El contenedor data.frame

miDf01 <- data.frame(
  numbers = c(1, 2, 3, 4), 
  logicals = c(TRUE, TRUE, FALSE, TRUE), 
  characters = c("a", "b", "c", "d"),
  stringsAsFactors = FALSE
)

El contenedor data.frame

str(miDf01)

## 'data.frame':    4 obs. of  3 variables:
##  $ numbers   : num  1 2 3 4
##  $ logicals  : logi  TRUE TRUE FALSE TRUE
##  $ characters: chr  "a" "b" "c" "d"

El contenedor data.frame

miDf01 <- data.frame(
  numbers = c(1, 2, 3, 4), 
  logicals = c(TRUE, TRUE, FALSE, TRUE), 
  characters = c("a", "b", "c", "d")
)
miDf01$characters <- as.character(miDf01$characters)

El contenedor data.frame

str(miDf01)

## 'data.frame':    4 obs. of  3 variables:
##  $ numbers   : num  1 2 3 4
##  $ logicals  : logi  TRUE TRUE FALSE TRUE
##  $ characters: chr  "a" "b" "c" "d"

El contenedor data.frame

Nota: “0” y “1” no son logical por defecto

Nota: Tratamientos “1”, “2”, “3” no son factor por defecto

El contenedor data.frame

miExpe <- data.frame(
  tratamiento = c(1, 1, 2, 2, 3, 3),
  resultado = c(0, 1, 0, 0, 1, 0)
)
str(miExpe)

## 'data.frame':    6 obs. of  2 variables:
##  $ tratamiento: num  1 1 2 2 3 3
##  $ resultado  : num  0 1 0 0 1 0

El contenedor data.frame

miExpe$tratamiento <- as.factor(miExpe$tratamiento)
miExpe$resultado <- as.logical(miExpe$resultado)
str(miExpe)

## 'data.frame':    6 obs. of  2 variables:
##  $ tratamiento: Factor w/ 3 levels "1","2","3": 1 1 2 2 3 3
##  $ resultado  : logi  FALSE TRUE FALSE FALSE TRUE FALSE

Modificar un data.frame

El acceso a los diferentes valores de un data.frame se puede hacer de la misma manera que para un contenedor de tipo list.

miDf01$numbers # vector

## [1] 1 2 3 4

miDf01[[1]] # vector

## [1] 1 2 3 4

miDf01[["numbers"]] # vector

## [1] 1 2 3 4

Modificar un data.frame

miDf01[1] # list

##   numbers
## 1       1
## 2       2
## 3       3
## 4       4

miDf01["numbers"] # list

##   numbers
## 1       1
## 2       2
## 3       3
## 4       4

Modificar un data.frame

myRow <- 2
myCol <- 1
miDf01[myRow, myCol]

## [1] 2

Modificar un data.frame

miDf01[myRow, ]

##   numbers logicals characters
## 2       2     TRUE          b

miDf01[, myCol]

## [1] 1 2 3 4

miDf01[, "numbers"]

## [1] 1 2 3 4

Modificar un data.frame

miDf01[, c(1, 2)]

##   numbers logicals
## 1       1     TRUE
## 2       2     TRUE
## 3       3    FALSE
## 4       4     TRUE

miDf01[c(2, 1), ]

##   numbers logicals characters
## 2       2     TRUE          b
## 1       1     TRUE          a

Modificar un data.frame

miDf01[miDf01$numbers > 2, ]

##   numbers logicals characters
## 3       3    FALSE          c
## 4       4     TRUE          d

miDf01[(miDf01$logicals == TRUE) & (miDf01$numbers < 2), ]

##   numbers logicals characters
## 1       1     TRUE          a

Modificar un data.frame

miDf01[(miDf01$numbers %% 2) == 0, ]

##   numbers logicals characters
## 2       2     TRUE          b
## 4       4     TRUE          d

miDf01[((miDf01$numbers %% 2) == 0) | (miDf01$logicals == TRUE), ]

##   numbers logicals characters
## 1       1     TRUE          a
## 2       2     TRUE          b
## 4       4     TRUE          d

Modificar un data.frame

print(miDf01)

##   numbers logicals characters
## 1       1     TRUE          a
## 2       2     TRUE          b
## 3       3    FALSE          c
## 4       4     TRUE          d

Modificar un data.frame

miDf01$otraColumna <- c(4, 5, 6, 7)
print(miDf01)

##   numbers logicals characters otraColumna
## 1       1     TRUE          a           4
## 2       2     TRUE          b           5
## 3       3    FALSE          c           6
## 4       4     TRUE          d           7

Modificar un data.frame

miDf01$numbers <- miDf01$numbers + 100
print(miDf01)

##   numbers logicals characters otraColumna
## 1     101     TRUE          a           4
## 2     102     TRUE          b           5
## 3     103    FALSE          c           6
## 4     104     TRUE          d           7

Dar nombres a un data.frame

colnames(miDf01)

## [1] "numbers"     "logicals"    "characters"  "otraColumna"

rownames(miDf01)

## [1] "1" "2" "3" "4"

Dar nombres a un data.frame

miDf01 <- rbind(miDf01, 
  otraLinea = data.frame(
    numbers = 5, 
    logicals = TRUE, 
    characters = "e", 
    otraColumna = 8))

Dar nombres a un data.frame

print(miDf01)

##           numbers logicals characters otraColumna
## 1             101     TRUE          a           4
## 2             102     TRUE          b           5
## 3             103    FALSE          c           6
## 4             104     TRUE          d           7
## otraLinea       5     TRUE          e           8

Dar nombres a un data.frame

rownames(miDf01)

## [1] "1"         "2"         "3"         "4"         "otraLinea"

rownames(miDf01) <- c("R1", "R2", "R3", "R4", "R5")

Dar nombres a un data.frame

print(miDf01)

##    numbers logicals characters otraColumna
## R1     101     TRUE          a           4
## R2     102     TRUE          b           5
## R3     103    FALSE          c           6
## R4     104     TRUE          d           7
## R5       5     TRUE          e           8

El contenedor data.frame

miVec <- c(1, 2, 3)
as.data.frame(miVec)

##   miVec
## 1     1
## 2     2
## 3     3

El contenedor data.frame

Podemos hacer mucho más con un data.frame y volveremos a su manejo y operaciones posibles en el capítulo sobre funciones…

El contenedor matrix

El contenedor matrix se puede ver como un vector de dos dimensiones: líneas y columnas. Corresponde a una matriz en matemáticas, y puede contener solo un tipo de datos (logical, numeric, character, …).

El contenedor matrix

vecForMatrix <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
miMat <- matrix(vecForMatrix, nrow = 3, ncol = 4)
print(miMat)

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

El contenedor matrix

nrow o ncol

vecForMatrix <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
miMat <- matrix(vecForMatrix, nrow = 3)
print(miMat)

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

El contenedor matrix

miMat <- matrix(
  vecForMatrix, 
  nrow = 3, 
  byrow = TRUE)
print(miMat)

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12

El contenedor matrix

miMat <- matrix(
  vecForMatrix, 
  nrow = 3, 
  byrow = TRUE, 
  dimnames = list(
    c("r1", "r2", "r3"), 
    c("c1", "c2", "c3", "c4"))
)
print(miMat)

##    c1 c2 c3 c4
## r1  1  2  3  4
## r2  5  6  7  8
## r3  9 10 11 12

El contenedor matrix

vecForMat01 <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
vecForMat02 <- vecForMat01 * 10
vecForMat03 <- vecForMat01 / 10
dfForMat <- data.frame(vecForMat01, vecForMat02, vecForMat03)
print(dfForMat)

##    vecForMat01 vecForMat02 vecForMat03
## 1            1          10         0.1
## 2            2          20         0.2
## 3            3          30         0.3
## 4            4          40         0.4
## 5            5          50         0.5
## 6            6          60         0.6
## 7            7          70         0.7
## 8            8          80         0.8
## 9            9          90         0.9
## 10          10         100         1.0
## 11          11         110         1.1
## 12          12         120         1.2

El contenedor matrix

is.matrix(dfForMat)

## [1] FALSE

as.matrix(dfForMat)

##       vecForMat01 vecForMat02 vecForMat03
##  [1,]           1          10         0.1
##  [2,]           2          20         0.2
##  [3,]           3          30         0.3
##  [4,]           4          40         0.4
##  [5,]           5          50         0.5
##  [6,]           6          60         0.6
##  [7,]           7          70         0.7
##  [8,]           8          80         0.8
##  [9,]           9          90         0.9
## [10,]          10         100         1.0
## [11,]          11         110         1.1
## [12,]          12         120         1.2

Manipular matrix

# operaciones término a término
miMat01 <- matrix(vecForMat01, ncol = 3)
miVecOp <- c(1, 10, 100, 1000)
miMat01 * miVecOp

##      [,1] [,2]  [,3]
## [1,]    1    5     9
## [2,]   20   60   100
## [3,]  300  700  1100
## [4,] 4000 8000 12000

Manipular matrix

# operaciones término a término
miMat01 / miMat01

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

miMat01 - 10

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

Manipular matrix

# operaciones algebraicas
miVecConf <- c(1, 10, 100)
miMat01 %*% miVecConf

##      [,1]
## [1,]  951
## [2,] 1062
## [3,] 1173
## [4,] 1284

Manipular matrix

miMat02 <- matrix(
  c(1, 2, 3, 4, 5, 6, 7, 8, 9), 
  ncol = 3)

Manipular matrix

La diagonal de una matrix: diag().

print(miMat02)

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

diag(miMat02)

## [1] 1 5 9

Manipular matrix

Transposición de matrix (columnas en líneas o líneas en columnas).

aperm(miMat01)

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12

t(miMat01)

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12

Manipular matrix

i <- 2
j <- 1
miMat01[i, j]

## [1] 2

miMat01[i, ]

## [1]  2  6 10

miMat01[, j]

## [1] 1 2 3 4

Manipular matrix

miMat01[c(1, 2), c(2, 3)]

##      [,1] [,2]
## [1,]    5    9
## [2,]    6   10

miMat01[10]

## [1] 10

El contenedor array

El contenedor array es una generalización del contenedor de tipo matrix. Donde el tipo matrix tiene dos dimensiones (líneas y columnas), el tipo array tiene un número indefinido de dimensiones. Podemos saber el número de dimensiones de un array (y por lo tanto una matrix) con la función dim().

dim(miMat01)

## [1] 4 3

El contenedor array

miVecArr <- 1:24
miArray <- array(miVecArr, dim = c(3, 4, 2))
print(miArray)

## , , 1
## 
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4]
## [1,]   13   16   19   22
## [2,]   14   17   20   23
## [3,]   15   18   21   24

El contenedor array

miArray02 <- array(1:24, 
  dim = c(3, 4, 2), 
  dimnames = list(
    c("r1", "r2", "r3"), 
    c("c1", "c2", "c3", "c4"), 
    c("matrix1", "matrix2")
  )
)
print(miArray02)

## , , matrix1
## 
##    c1 c2 c3 c4
## r1  1  4  7 10
## r2  2  5  8 11
## r3  3  6  9 12
## 
## , , matrix2
## 
##    c1 c2 c3 c4
## r1 13 16 19 22
## r2 14 17 20 23
## r3 15 18 21 24

El contenedor array

i <- 2
j <- 1
k <- 1
miArray02[i, j, k]

## [1] 2

miArray02[, j, k]

## r1 r2 r3 
##  1  2  3

El contenedor array

miArray02[i, , k]

## c1 c2 c3 c4 
##  2  5  8 11

miArray02[i, j, ]

## matrix1 matrix2 
##       2      14