Matrices en R: qué son y cómo trabajar con ellas

Una matriz en R es un conjunto de elementos del mismo tipo (numérico, carácter, lógico, etc) organizado en filas y columnas. Las matrices en R se construyen con la función matrix(). Aunque con un ejemplo siempre es mucho más fácil comprender cómo funcionan las matrices.

Matrices en R: qué son y cómo trabajar con ellas

Matrices en R: ejemplos rápidos

Vamos a comenzar generando una matriz que está compuesta por 25 números (del 1 al 25). Pero antes de explicar la formación de una matriz, vamos a ver directamente el código y explicaremos posteriormente sus argumentos. Los detalles de la función matrix() pueden consultarse en su página oficial.

matrix(1:25, byrow = TRUE, nrow = 5)
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    3    4    5
[2,]    6    7    8    9   10
[3,]   11   12   13   14   15
[4,]   16   17   18   19   20
[5,]   21   22   23   24   25

Como hemos visto, la función matrix() presenta 3 argumentos principales:

  • 1:25 indica que se genere un vector de números del 1 al 25, de este modo c(1, 2, 3, ..., 22, 23, 24, 25)
  • byrow = TRUE se refiere a que esos números se van a incorporar a la matriz de izquierda a derecha y de arriba a abajo.
  • nrow = 5 indica que van a formarse 5 filas.

Veamos qué pasa si ponemos byrow = FALSE:

matrix(1:25, byrow = FALSE, nrow = 5)
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25

Vemos ahora que la matriz se ha rellenado con los datos de arriba a abajo y de izquierda a derecha.

Como tenemos 25 números hemos decidido generar tantas filas y columnas para que esos 25 números estuvieran bien repartidos (5×5) ¿Qué pasa si ponemos un número de filas que no sea múltiplo de 25, por ejemplo 7?

matrix(1:25, byrow = FALSE, nrow = 7)

Pues que nos sale un mensaje de advertencia indicándonos precisamente eso, que el 7 no es un múltiplo o submúltiplo de 25.

## Warning in matrix(1:25, byrow = FALSE, nrow = 7): data length [25] is not a
## sub-multiple or multiple of the number of rows [7]
     [,1] [,2] [,3] [,4]
[1,]    1    8   15   22
[2,]    2    9   16   23
[3,]    3   10   17   24
[4,]    4   11   18   25
[5,]    5   12   19    1
[6,]    6   13   20    2
[7,]    7   14   21    3

Si nos fijamos en detenimiento, en las filas 5, 6, 7 y en la columna 4, nos aparecen los números consecutivos 1, 2, 3.

Ahora, si no especificamos nrow, nos generará tantas filas como elementos tengamos.

matrix(1:25, byrow = FALSE)
matrix(1:25, byrow = FALSE, nrow = 25)
     [,1]
[1,]    1
[2,]    2
[3,]    3
[4,]    4
[5,]    5
[6,]    6
[7,]    7
[8,]    8
[9,]    9
[10,]   10
[11,]   11
[12,]   12
[13,]   13
[14,]   14
[15,]   15
[16,]   16
[17,]   17
[18,]   18
[19,]   19
[20,]   20
[21,]   21
[22,]   22
[23,]   23
[24,]   24
[25,]   25

Veamos un ejemplo con 8 elementos organizados en dos filas:

matrix(1:8, byrow = FALSE, nrow = 2)
     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8

Y ahora otro ejemplo de una matriz compuesta por 8 elementos y cuatro filas:

matrix(1:8, byrow = FALSE, nrow = 4)
     [,1] [,2]
[1,]    1    5
[2,]    2    6
[3,]    3    7
[4,]    4    8

Generar matrices en R a partir de vectores

Vamos a unir 3 vectores independientes en una matriz. Para comprender lo que es un vector, os recomendamos leer esta entrada sobre qué son y cómo se generan los vectores en R. Pero volviendo a los 3 que mencionábamos, vamos a llamarles A, B, y C, respectivamente.

# Creamos los 3 vectores: A, B, C
A <- c(460.998, 314.4)
B <- c(290.475, 247.900)
C <- c(309.306, 165.8)

# Los juntamos en un objeto llamado D
D <- c(A, B, C)

# Vemos cómo es el objeto D.
print(D)
[1] 460.998 314.400 290.475 247.900 309.306 165.800
# Construimos la matriz
D_matriz <- matrix(D, byrow=TRUE, nrow=3)
D_matriz
        [,1]  [,2]
[1,] 460.998 314.4
[2,] 290.475 247.9
[3,] 309.306 165.8

Añadir nombre de columnas y filas a las matrices en R

Existen dos formas de añadir nombre de columnas y filas a una matriz:

  • Con las funciones rownames() y colnames(), para filas y columnas respectivamente.
  • Con el atributo dimnames incluido dentro de la función matrix().

Usando rownames() y colnames()

Vamos a aprender a añadir nombres de columnas y filas a nuestra matriz de datos. Para ello, vamos a utilizar las funciones rownames() y colnames().

# Llamamos con el nombre "a" a nuestra matriz del inicio
a <- matrix(1:25, byrow = TRUE, nrow = 5)

# Añadimos los nombres de las filas y columnas indicando la matriz a la que queremos añadir o cambiar esos nombres
rownames(a) <- c("a", "b", "c", "d", "e")
colnames(a) <- c("A", "B", "C", "D", "E")

# Visualizamos la matriz
a
   A  B  C  D  E
a  1  2  3  4  5
b  6  7  8  9 10
c 11 12 13 14 15
d 16 17 18 19 20
e 21 22 23 24 25

Es importante conocer de antemano cuántas filas y columnas hay para escribir tantos nombres como columnas y filas existan. Es por eso que sabiendo que era una matriz de 5×5 hemos definido 2 vectores, cada uno compuesto por 5 cadenas de texto.

Usando dimnames()

En esta ocasión, los nombres de filas y columnas se incluyen dentro de la función matrix(), utilizando el atributo dimnames. Este nombre proviene de dimension names.

# Llamamos con el nombre "b" a nuestra matriz del inicio
b <- matrix(1:25, byrow = TRUE, nrow = 5, 
            dimnames = list(c("a", "b", "c", "d", "e"), 
                            c("A", "B", "C", "D", "E")))

# Visualizamos la matriz
b
   A  B  C  D  E
a  1  2  3  4  5
b  6  7  8  9 10
c 11 12 13 14 15
d 16 17 18 19 20
e 21 22 23 24 25

Como podemos ver, se ha creado el argumento dimnames que incluye la función list(). Ésta a su vez, incluye dos vectores con los nombres de las filas y los nombres de las columnas, en este orden.

Para mostrarlo de otro modo complementario, también podemos crear dos vectores con el nombre de las filas y columnas por un lado, y posteriormente incluir el nombre de esos vectores en dimnames.

# Creamos los vectores con los nombres de filas y folumnas
nombre_filas <- c("a", "b", "c", "d", "e")
nombre_columnas <- c("A", "B", "C", "D", "E")

# Llamamos con el nombre "c" a nuestra matriz del inicio
c <- matrix(1:25, byrow = TRUE, nrow = 5, dimnames = list(nombre_filas, nombre_columnas))

# Visualizamos la matriz
c
   A  B  C  D  E
a  1  2  3  4  5
b  6  7  8  9 10
c 11 12 13 14 15
d 16 17 18 19 20
e 21 22 23 24 25

Eliminar nombres de columnas y filas de matrices en R

Si queremos eliminar los nombres de filas y columnas de una matriz, volvemos a usar las funciones rownames() y colnames(), pero esta vez añadiendo una función c() vacía.

rownames(a) <- c()
colnames(a) <- c()

Sumar los valores de columnas y filas de matrices en R

Para sumar todos los valores de cada fila en las matrices de R, usamos la función rowSums(), mientras que para sumar todos los valores de cada columna usamos la función colSums(). Dentro de cada una de estas funciones tenemos que incluir el nombre de la matriz sobre la que queremos hacer las sumas.

Sumar los valores de las filas

Si empleamos la matriz llamada c, creada anteriormente, podemos sumar los valores de cada fila empleando la función rowSums().

# Sumamos los valores en cada fila de la matriz "c"
rowSums(c)
  a   b   c   d   e 
 15  40  65  90 115

Sumar los valores de las columnas

Por su parte, si seguimos con la matriz llamada c, podemos sumar los valores de cada cada columna empleando la función colSums().

# Sumamos los valores en cada columna de la matriz "c"
colSums(c)
 A  B  C  D  E 
55 60 65 70 75

Añadir columnas y filas nuevas a una matriz

La creación de nuevas columnas y filas en matrices en R es muy simple con dos funciones sencillas de emplear. Un poquito más información puede encontrarse en esta entrada, pero aquí lo vamos a ver también en detalle.

Añadir columnas con cbind()

Vamos a añadir una columna extra a nuestra matriz c que sea la suma de las filas utilizando la función cbind(). Esta función une matrices y/o vectores por columnas. De hecho, su nombre viene del inglés column bind.

# Primero damos el nombre a la suma de las filas
suma_filas <- rowSums(c)

# Ahora unimos la matriz "c" con "suma_filas"
cbind(c, suma_filas)
   A  B  C  D  E suma_filas
a  1  2  3  4  5         15
b  6  7  8  9 10         40
c 11 12 13 14 15         65
d 16 17 18 19 20         90
e 21 22 23 24 25        115

Añadir filas con rbind()

Vamos a añadir una fila extra a nuestra matriz c que sea la suma de las columnas utilizando la función rbind(). Esta función une matrices y/o vectores por filas. De hecho, su nombre viene de row bind.

# Primero damos el nombre a la suma de las filas
suma_columnas <- colSums(c)

# Ahora unimos la matriz "c" con "suma_columnas"
rbind(c, suma_columnas)
               A  B  C  D  E
a              1  2  3  4  5
b              6  7  8  9 10
c             11 12 13 14 15
d             16 17 18 19 20
e             21 22 23 24 25
suma_columnas 55 60 65 70 75

Seleccionar los elementos de una matriz en R

Mientras que un vector tiene solo una dimensión, una matriz, tiene dos. Podemos seleccionar filas y/o columnas específicas del interior de una matriz usando los corchetes, separando por una coma las filas, que se sitúan a la izquierda, y las columnas, que se sitúan a la derecha. Siguiendo esta pequeña lógica, las matrices en R pueden subdividirse o subseleccionarse de un modo muy rápido e intuitivo.

# Seleccionamos sólo la fila 2 del objeto "c"
c[2, ]
 A  B  C  D  E 
 6  7  8  9 10
# Seleccionamos sólo la columna 3
c[, 3]
 a  b  c  d  e 
 3  8 13 18 23
# Seleccionamos el valor que está en la fila 1 y columna 2
c[1,2]
[1] 2
# Seleccionamos las filas 2,3,4 y las columnas 1,2,3 del objeto "c"
c[2:4, 1:3]
   A  B  C
b  6  7  8
c 11 12 13
d 16 17 18

Operaciones aritméticas con las matrices

Podemos sumar, restar, multiplicar y dividir fácilmente matrices en R empleando los operadores y símbolos clásicos. En los siguientes ejemplos vais a ver que cada elemento de una matriz se modifica en base a la operación en cuestión. Por ejemplo, si multiplicamos una matriz por 10, todos los elementos de esa matriz serán multiplicados por 10.

# Multiplicamos por 10 la matriz "c"
c * 10
    A   B   C   D   E
a  10  20  30  40  50
b  60  70  80  90 100
c 110 120 130 140 150
d 160 170 180 190 200
e 210 220 230 240 250
# La dividimos por 2
c / 2
     A    B    C    D    E
a  0.5  1.0  1.5  2.0  2.5
b  3.0  3.5  4.0  4.5  5.0
c  5.5  6.0  6.5  7.0  7.5
d  8.0  8.5  9.0  9.5 10.0
e 10.5 11.0 11.5 12.0 12.5
# La sumamos 1
c + 1
   A  B  C  D  E
a  2  3  4  5  6
b  7  8  9 10 11
c 12 13 14 15 16
d 17 18 19 20 21
e 22 23 24 25 26
# Y le restamos 3
c - 3
   A  B  C  D  E
a -2 -1  0  1  2
b  3  4  5  6  7
c  8  9 10 11 12
d 13 14 15 16 17
e 18 19 20 21 22

Operando con 2 matrices

En este caso, las matrices en R se operan elemento a elemento. Es decir, el elemento en la posición (1,1) de la matriz primera se opera con el elemento en la posición (1,1) de la matriz segunda. Y así sucesivamente.

c*c
    A   B   C   D   E
a   1   4   9  16  25
b  36  49  64  81 100
c 121 144 169 196 225
d 256 289 324 361 400
e 441 484 529 576 625

1 comentario en “Matrices en R: qué son y cómo trabajar con ellas”

Deja un comentario