What is a Matrix?
A matrix is a collection of elements, all the same type, arranged in a two-dimensional layout.
In a nutshell, a matrix is just a vector that has two dimensions.
When using R, you will frequently encounter the four basic matrix types viz. logical, character, integer and double (often called numeric).
Create a Matrix
You can create a matrix using the matrix() function and specifying the data and the number of rows and columns to make the matrix.
# Create a numeric matrix
m <- matrix(1:6, nrow=2, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
Matrix can contain character values as well.
# Create a character matrix
letters <- c("a","b","c","d","e","f")
m <- matrix(letters, nrow=2, ncol=3)
m
[,1] [,2] [,3]
[1,] "a" "c" "e"
[2,] "b" "d" "f"
You don’t have to specify both ncol and nrow. If you specify one, R will know automatically what the other needs to be.
m <- matrix(1:6, nrow=2)
m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
By default, the matrix is filled column-by-column. By setting byrow=TRUE you can fill the matrix row-by-row.
m <- matrix(1:6, nrow=2, ncol=3, byrow=TRUE)
m
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
Combine Vectors into a Matrix
You can also create a matrix using the cbind() and rbind() functions. However, keep in mind that the vectors that are being binded must be of equal length and same type.
v1 <- c(1, 2, 3)
v2 <- c(4, 5, 6)
v3 <- c(7, 8, 9)
rbind(v1, v2, v3)
[,1] [,2] [,3]
v1 1 2 3
v2 4 5 6
v3 7 8 9
The cbind() function does something similar. It binds the vectors as columns of a matrix.
v1 <- c(1, 2, 3)
v2 <- c(4, 5, 6)
v3 <- c(7, 8, 9)
cbind(v1, v2, v3)
v1 v2 v3
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
Change Matrix Dimension
By using the dim() function you can get the dimension of the matrix without looking at the structure.
# Print the dimension of a matrix
m <- matrix(1:6, nrow=2, ncol=3)
dim(m)
[1] 2 3
The dim() function can also be used to set the dimension of the matrix.
# Change the dimension of a matrix
# define a 2x3 matrix
m <- matrix(1:6, nrow=2, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
# make it 3x2
dim(m) <- c(3,2)
m
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
# make it 1x6
dim(m) <- c(1,6)
m
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 2 3 4 5 6
Naming Matrix Rows and Columns
R lets you assign descriptive names to the rows and columns of a matrix. It is useful for subsetting and printing the matrix.
You can do this by assigning two element list containing row and column names to the dimnames attribute.
# Assign names to the rows and columns
m <- matrix(1:6, nrow=2, ncol=3)
dimnames(m) <- list(c("r1","r2"), c("c1","c2","c3"))
m
c1 c2 c3
r1 1 3 5
r2 2 4 6
You can even name the rows and columns while creating a matrix by passing dimnames argument.
# Naming rows and columns while matrix creation
m <- matrix(1:6, nrow=2, ncol=3, dimnames=list(c("r1","r2"), c("c1","c2","c3")))
m
c1 c2 c3
r1 1 3 5
r2 2 4 6
By using the rownames() and colnames() function you can assign row names and column names separately.
# Assign names to the rows and columns separately
m <- matrix(1:6, nrow=2, ncol=3)
rownames(m) <- c("r1","r2")
colnames(m) <- c("c1","c2","c3")
m
c1 c2 c3
r1 1 3 5
r2 2 4 6
You can use the same dimnames(), colnames() and rownames() functions to print column names and row names.
# print column names
colnames(m)
[1] "c1" "c2" "c3"
# print row names
rownames(m)
[1] "r1" "r2"
# print both
dimnames(m)
[[1]]
[1] "r1" "r2"
[[2]]
[1] "c1" "c2" "c3"
Subsetting Matrices
In R, subsetting elements from matrices is much like subsetting elements from vectors.
The only difference is that you now have to specify both the row and the column position, in the order of [row, column].
Subsetting by Positive Integer
Subsetting with positive integers returns the elements at the specified positions.
m <- matrix(1:9, nrow=3, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
# subset for 2nd row
m[2,]
[1] 2 5 8
# subset for 3rd column
m[,3]
[1] 7 8 9
# select single element
m[2,3]
[1] 8
# subset for row 1 and 2 but keep all columns
m[1:2,]
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
# subset for both rows and columns
m[1:2,2:3]
[,1] [,2]
[1,] 4 7
[2,] 5 8
# use a vector to subset
m[1:2,c(1, 3)]
[,1] [,2]
[1,] 1 7
[2,] 2 8
When you subset for a single row or a column, the result will always be a vector. To avoid this you can set the drop argument to FALSE.
m <- matrix(1:9, nrow=3, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
# simplifies the output to a vector
m[, 2]
[1] 4 5 6
class(m[, 2])
[1] "integer"
# preserves output as a matrix
m[, 2, drop = FALSE]
[,1]
[1,] 4
[2,] 5
[3,] 6
class(m[, 2, drop = FALSE])
[1] "matrix"
Subsetting by Negative Integer
Subsetting with negative integers will omit the elements at the specified positions.
m <- matrix(1:9, nrow=3, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
# omit 2nd row
m[-2,]
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 3 6 9
# omit 3rd column
m[,-3]
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
# omit 2nd row and 3rd column
m[-2,-3]
[,1] [,2]
[1,] 1 4
[2,] 3 6
Subsetting by Logical Values
Subsetting with logical values will return the elements where the corresponding logical value is TRUE.
m <- matrix(1:9, nrow=3, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
# select elements where corresponding logical value is TRUE
m[c(TRUE,FALSE,TRUE),c(TRUE,TRUE,FALSE)]
[,1] [,2]
[1,] 1 4
[2,] 3 6
# select elements greater than 5
m[m > 5]
[1] 6 7 8 9
# select even elements
m[m %% 2 == 0]
[1] 2 4 6 8
Subsetting by Names
Subsetting with names will return the elements having the matching names.
m <- matrix(1:9, nrow=3, ncol=3)
dimnames(m) <- list(c("r1","r2","r3"), c("c1","c2","c3"))
# subset for 2nd row
m["r2",]
c1 c2 c3
2 5 8
# subset for 3rd column
m[,"c3"]
r1 r2 r3
7 8 9
# subset for 1st and 3rd row but keep all columns
m[c("r1","r3"),]
c1 c2 c3
r1 1 4 7
r3 3 6 9
# select single element
m["r2","c3"]
[1] 8
Add New Rows and Columns to Matrix
You can use the cbind() and rbind() functions for adding new rows and columns to the matrix as well. However, keep in mind that the vectors that are being added must be of equal length and same type.
m <- matrix(1:6, nrow=2, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
# add new column
cbind(m, c(7,8))
[,1] [,2] [,3] [,4]
[1,] 1 3 5 7
[2,] 2 4 6 8
# add new row
rbind(m, c(10,20,30))
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
[3,] 10 20 30
Modify Matrix Elements
Modifying a matrix element is pretty straightforward. Access the element using [] operator and simply assign a new value.
m <- matrix(1:6, nrow=2, ncol=3)
# moidfy single element
m[1,2] <- 99
m
[,1] [,2] [,3]
[1,] 1 99 5
[2,] 2 4 6
# modify 2nd row
m[2,] <- c(10,20,30)
m
[,1] [,2] [,3]
[1,] 1 99 5
[2,] 10 20 30
# modify elements less than 5
m[m > 5] <- 0
m
[,1] [,2] [,3]
[1,] 1 0 5
[2,] 0 0 0
Matrix Operations
The most powerful feature of R is the ease of dealing with matrix operations. Because much of statistics depend on matrix operations, R perform them in an easy and optimized way:
- Matrix transpose
- Creating an identity matrix
- Scalar multiple of a matrix
- Matrix addition and subtraction
- Matrix multiplication
- Matrix inversion
Matrix Transpose
The transpose of a matrix is simply a flipped version of the original matrix obtained by switching rows with columns. To transpose a matrix, use t() function.
m <- matrix(1:6, nrow=2, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
t(m)
[,1] [,2]
[1,] 1 2
[2,] 3 4
[3,] 5 6
Creating an Identity Matrix
You can create an identity matrix using the diag() function. Its behavior depends on what argument you pass.
If you pass a single positive integer, then diag() will create an identity matrix of that dimension.
# Create a 3x3 identity matrix
diag(3)
[,1] [,2] [,3]
[1,] 1 0 0
[2,] 0 1 0
[3,] 0 0 1
If you pass a matrix, diag() will return the diagonal elements of the matrix.
# Return diagonal elements of the matrix
m <- matrix(1:9, nrow=3, ncol=3)
m
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
diag(m)
[1] 1 5 9
Scalar Multiple of a Matrix
When you multiply a matrix by a scalar value (a single number), every individual element is multiplied by that value.
# Multiply each matrix element by 10
m <- matrix(1:6, nrow=2, ncol=3)
m * 10
[,1] [,2] [,3]
[1,] 10 30 50
[2,] 20 40 60
Matrix Addition and Subtraction
R performs addition or subtraction of two matrices of equal size in an element-wise manner. Meaning, corresponding elements are added or subtracted from one another, depending on the operation.
m1 <- matrix(1:6, nrow=2, ncol=3)
m1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
m2 <- matrix(-6:-1, nrow=2, ncol=3)
m2
[,1] [,2] [,3]
[1,] -6 -4 -2
[2,] -5 -3 -1
# addition
m1 + m2
[,1] [,2] [,3]
[1,] -5 -1 3
[2,] -3 1 5
# subtraction
m1 - m2
[,1] [,2] [,3]
[1,] 7 7 7
[2,] 7 7 7
Matrix Multiplication
Unlike scalar multiplication, matrix multiplication is not a simple element-by-element calculation, and the standard * operator cannot be used. Instead, you must use R’s matrix product operator %*%.
m1 <- matrix(1:6, nrow=2, ncol=3)
m1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
m2 <- matrix(1:6, nrow=3, ncol=2)
m2
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
# multiplication
m1 %*% m2
[,1] [,2]
[1,] 22 49
[2,] 28 64
Matrix Inversion
The inverse of a matrix can be calculated by using the solve() function.
m <- matrix(1:4, nrow=2, ncol=2)
m
[,1] [,2]
[1,] 1 3
[2,] 2 4
solve(m)
[,1] [,2]
[1,] -2 1.5
[2,] 1 -0.5
Matrix Length
You can find the total number of values in a matrix using the length() function.
m <- matrix(1:6, nrow=2, ncol=3)
length(m)
[1] 6