CC BY-NC-ND 3.0
vector
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
vector
typeof(miVec)
## [1] "double"
is.vector(miVec)
## [1] TRUE
miVec <- as.integer(c(1, 5, 3, 6))
typeof(miVec)
## [1] "integer"
vector
miVec02 <- c("a", "b", "c")
print(miVec02)
## [1] "a" "b" "c"
typeof(miVec02)
## [1] "character"
is.vector(miVec02)
## [1] TRUE
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
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"
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"
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.
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
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"
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"
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
vector
miVec20[miVec20 == 30]
## [1] 30
miVec20[(miVec20 == 30) | (miVec20 == 50)]
## [1] 30 50
miVec21[miVec21 == "a"]
## [1] "a"
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"
vector
miVec21[miVec20 == 30]
## [1] "c"
miVec21[(miVec20 == 30) | (miVec20 == 50)]
## [1] "c" "e"
miVec21[(miVec20 == 30) | (miVec21 == "h")]
## [1] "c" "h"
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"
vector
miVec22 <- c(TRUE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, TRUE)
miVec21[miVec22]
## [1] "a" "b" "d" "f" "h" "i"
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"
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"
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
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
vector
Podemos hacer mucho más con un vector
y volveremos a su manejo y operaciones posibles en el capítulo sobre funciones…
list
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
).
list
miList01 <- list()
print(miList01)
## list()
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"
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"
list
is.list(miList02)
## [1] TRUE
typeof(miList02)
## [1] "list"
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"
list
typeof(miList02)
## [1] "list"
miList02[[1]]
## [1] 5
typeof(miList02[[1]])
## [1] "double"
list
print(miList02)
## [[1]]
## [1] 5
##
## [[2]]
## [1] "qwerty"
##
## [[3]]
## [1] 4 5 6
##
## [[4]]
## [1] "a" "b" "c"
miList02[[4]][2]
## [1] "b"
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"
list
miList04[[2]][[3]][[1]][1]
## [1] 4
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
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)
)
)
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
list
names(bddInsect)
## [1] "Snonagrioides" "Onubilalis"
names(bddInsect[[1]])
## [1] "site01" "site02" "site03"
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
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
list
print(miList02)
## [[1]]
## [1] 5
##
## [[2]]
## [1] "qwerty"
##
## [[3]]
## [1] 4 5 6
##
## [[4]]
## [1] "a" "b" "c"
list
miList02[[1]] <- 12
print(miList02)
## [[1]]
## [1] 12
##
## [[2]]
## [1] "qwerty"
##
## [[3]]
## [1] 4 5 6
##
## [[4]]
## [1] "a" "b" "c"
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
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
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"
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"
list
print(miList05)
## [[1]]
## [1] "a"
##
## [[2]]
## [1] "b" "c"
##
## [[3]]
## [1] "d"
list
miList05 <- c(miList05, "e")
print(miList05)
## [[1]]
## [1] "a"
##
## [[2]]
## [1] "b" "c"
##
## [[3]]
## [1] "d"
##
## [[4]]
## [1] "e"
list
print(miList05)
## [[1]]
## [1] "a"
##
## [[2]]
## [1] "b" "c"
##
## [[3]]
## [1] "d"
##
## [[4]]
## [1] "e"
list
miList05[[2]] <- NULL
print(miList05)
## [[1]]
## [1] "a"
##
## [[2]]
## [1] "d"
##
## [[3]]
## [1] "e"
data.frame
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.
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
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
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
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
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
)
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"
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)
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"
data.frame
Nota: “0” y “1” no son logical
por defecto
Nota: Tratamientos “1”, “2”, “3” no son factor
por defecto
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
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
data.frame
str()
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
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
data.frame
myRow <- 2
myCol <- 1
miDf01[myRow, myCol]
## [1] 2
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
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
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
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
data.frame
print(miDf01)
## numbers logicals characters
## 1 1 TRUE a
## 2 2 TRUE b
## 3 3 FALSE c
## 4 4 TRUE d
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
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
data.frame
colnames(miDf01)
## [1] "numbers" "logicals" "characters" "otraColumna"
rownames(miDf01)
## [1] "1" "2" "3" "4"
data.frame
miDf01 <- rbind(miDf01,
otraLinea = data.frame(
numbers = 5,
logicals = TRUE,
characters = "e",
otraColumna = 8))
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
data.frame
rownames(miDf01)
## [1] "1" "2" "3" "4" "otraLinea"
rownames(miDf01) <- c("R1", "R2", "R3", "R4", "R5")
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
data.frame
miVec <- c(1, 2, 3)
as.data.frame(miVec)
## miVec
## 1 1
## 2 2
## 3 3
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…
matrix
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
, …).
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
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
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
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
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
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
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
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
matrix
# operaciones algebraicas
miVecConf <- c(1, 10, 100)
miMat01 %*% miVecConf
## [,1]
## [1,] 951
## [2,] 1062
## [3,] 1173
## [4,] 1284
matrix
miMat02 <- matrix(
c(1, 2, 3, 4, 5, 6, 7, 8, 9),
ncol = 3)
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
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
matrix
i <- 2
j <- 1
miMat01[i, j]
## [1] 2
miMat01[i, ]
## [1] 2 6 10
miMat01[, j]
## [1] 1 2 3 4
matrix
miMat01[c(1, 2), c(2, 3)]
## [,1] [,2]
## [1,] 5 9
## [2,] 6 10
miMat01[10]
## [1] 10
array
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
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
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
array
i <- 2
j <- 1
k <- 1
miArray02[i, j, k]
## [1] 2
miArray02[, j, k]
## r1 r2 r3
## 1 2 3
array
miArray02[i, , k]
## c1 c2 c3 c4
## 2 5 8 11
miArray02[i, j, ]
## matrix1 matrix2
## 2 14