Introducción a las matrices en R
Como sabemos, las matrices son los objetos que pueden almacenar dos o más datos bidimensionales. En R, Array tiene el mismo concepto, que se crea utilizando la función array (). Aquí los datos se almacenan en matrices de formularios, filas y columnas. Para acceder a un elemento específico desde la matriz, uno debe especificar el índice de fila, el índice de columna y el nivel de matriz.
Las matrices de uso frecuente en R, es un tipo especial de matriz 2-D.
Representación pictórica: Vector, matriz, matriz
- Matriz unidimensional denominada vector.
- Matriz bidimensional denominada matriz.
Sintaxis:
Aquí está la sintaxis de array:
Array_NAME <- array (data, dim = (row_Size, column_Size, matrices, dimnames)
- data: los datos son un vector de entrada que se alimenta a la matriz.
- matrices - Esto se refiere a la dimensionalidad de las matrices. La matriz en R puede ser matrices multidimensionales.
- row_Size: row_Size representa el número de filas de las que formará una matriz.
- column_Size - column_Size representa el número de columnas de las que formará una matriz.
- dimnames: este campo sirve para cambiar los nombres predeterminados de filas y columnas según el deseo / preferencia del usuario.
Propiedades:
- Es homogéneo Eso significa que puede almacenar el mismo tipo de datos.
- Almacena datos en memoria contigua
- Se puede acceder a los elementos de la matriz conociendo el número de índice.
¿Cómo crear una matriz en R?
A continuación se presentan diferentes escenarios sobre cómo crear una matriz en r de la siguiente manera:
Escenario 1:
Creemos una matriz que sería 3 × 4 matrices. Aquí 3 se remarán y 4 serán columnas, las matrices serán una. Como nuestros pasos iniciales, mantengamos dimnames = NULL (que es un valor predeterminado, si no se especifica nada).
Esta es una matriz unidimensional
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Salida:
Para verificar si finalmente se creó la matriz creada o no.
Una vez que se crea la matriz:
Resultado
La función "clase" puede ayudarlo con eso.
clase (Resultado)
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
class(Result)
Salida:
Para verificar el producto de la dimensión de la matriz, uno puede usar la función: longitud.
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
length(Result)
Salida:
Escenario 2:
Creemos la misma matriz que sería 3 × 4 matrices. Aquí nuevamente, 3 será una fila y 4 serán columnas, pero las matrices serán dos. Mantengamos dimnames = NULL (que es un valor predeterminado, si no se especifica nada).
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 2)))
Salida:
Escenario 3:
Creemos la misma matriz que sería 3 × 4 matrices. Aquí nuevamente, 3 será fila y 4 serán columnas, pero las matrices serán dos. Veamos los valores asignados a los nombres oscuros.
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names ))
Salida:
Ahora somos buenos para crear una matriz de cualquier dimensionalidad. Vamos a centrarnos ahora en la forma de acceder a cualquier elemento de una matriz.
¿Cómo crear una matriz de elementos de acceso en R?
A continuación hay diferentes elementos de acceso sobre cómo crear una matriz en r de la siguiente manera:
Escenario 1:
Digamos que tenemos la misma matriz en R:
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
Salida:
Ahora, necesitamos acceder a la 3ª fila, a la 3ª columna de la segunda matriz de la matriz.
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(3, 3, 2)
Salida:
Para resumir esto, los corchetes se usan para denotar un índice. Para especificar el índice en las matrices, hay cuatro opciones disponibles: enteros positivos, enteros negativos, valores lógicos, nombres de elementos
Escenario 2:
Uno necesita acceder a una matriz completa de la primera matriz:
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1)
Salida:
Operación de matriz diferente con ejemplos
Esta sección le proporcionará control sobre diversas operaciones realizadas en matrices para lograr diversos resultados.
1. Suma y resta:
La matriz multidimensional tiene que convertirse a la matriz unidimensional, para poder sumarla o restarla.
- Adición:
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) + result(,, 2))
Salida:
- Sustracción:
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) - result(,, 2))
Salida:
2. Cálculos sobre el elemento Array
El nombre de una función apply (), ayuda a aplicar cualquier operación a través de los elementos de la matriz.
Sintaxis:
apply(x, margin, fun)
Aquí x es una matriz, el margen aquí se refiere a filas o columnas.
- MARGEN = 1 para operación en fila
- MARGEN = 2 para operación en columna
- MARGEN = c (1, 2) para ambos.
Diversión es la función aplicada a través de elementos en la matriz del marco de datos. Estas podrían ser las funciones estándar que forman parte de R o funciones personalizadas (definidas por el usuario)
Ejemplo 1:
Código Row Wise R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, sum)
Salida:
Columna Wise - Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 2, sum)
Salida:
Esto da salida en forma de vector que contiene la suma de columnas individuales. Aquí "suma" es la función estándar de R.
Ejemplo 2
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, function(x) x+10)
Salida:
Esto da la salida de la misma dimensión. Lo que hay que notar aquí es que hemos aplicado una función definida por el usuario. Esta función es muy útil y poderosa al resolver problemas del mundo real. La función aplicada también es base para otras funciones complejas como lapply (), rapply (), etc.
3. Verifique la matriz
Verifique la matriz si el objeto es una matriz o no. El nombre de la función es.array () es una función primitiva que le permite hacerlo. Da salida en términos Verdadero o Falso
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) is.array(result)
Salida:
4. Compruebe el tamaño de la matriz
Conocer la dimensionalidad, una serie de filas, columnas de matriz ayuda a cortar y cortar datos. Aquí hay algunas funciones para hacer eso: dim, nrow, ncol
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
result <- array(c(vector1, vector2), dim = c(3, 4, 2))
print(result)
dim(result)
nrow(result)
ncol(result)
Salida:
5. Verifique los nombres de las filas y columnas
Para conocer los nombres de filas, columnas y nombres de dimensiones de una matriz. A continuación se muestran la implementación mostrada.
Código R:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
rownames(result)
colnames(result)
dimnames(result)
Salida:
Conclusión:
Revisar el contenido anterior le habría dado una comprensión clara de las matrices en R. R es un lenguaje estadístico, y las matrices son objetos de datos utilizados con frecuencia. Esto significa que trabajar con una variedad de operaciones como sumar, restar, aplicar, etc. con una matriz en cualquier aplicación ahora será un paseo fácil para usted.
Artículos recomendados
Esta ha sido una guía para la matriz en R. Aquí discutimos una introducción a las matrices en R, las propiedades de R, cómo crear una matriz en R y algunos ejemplos de ejemplos. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Instalar R
- Matrices de VBA
- Tipos de datos en MATLAB
- VBA ArrayList
- Matrices en PHP