Matrices

In R, matrices (matrix objects) are two-dimensional arrays. They generally contain row and column names. A matrix must contain elements of the same mode (numeric, character, boolean…).

As an example, a matrix can be created as follows.

x <- round(runif(25), 2)
mat <- matrix(data=x, 
              ncol = 5, 
              byrow = TRUE)
print(mat)

You can also create a matrix by grouping vectors of the same size using the functions cbind() (column bind) or rbind() (row bind).

mat <- cbind(0:5, 20:25, 30:35)
mat

mat <- rbind(0:5, 20:25, 30:35)
mat

Row and column names

Column/row names can be changed as follows:

set.seed(1)
mat <- matrix(data=round(rnorm(20), 2), 
            ncol = 4, 
            byrow = TRUE)

colnames(mat) <- LETTERS[1:4]
rownames(mat) <- letters[1:5]
print(mat)

Matrix dimensions

We can find out the number of rows, columns and dimensions of the matrix with the nrow(), ncol() and dim() functions respectively.

nrow(mat)
ncol(mat)
dim(mat)

Exercise

set.seed(123)
mat <- matrix(data=round(runif(200, 0, 100), 0), 
            ncol = 10, 
            byrow = TRUE)

set.seed(123)
mat <- matrix(data=round(runif(200, 0, 100), 0), 
            ncol = 10, 
            byrow = TRUE)

rown <- paste0("gene_", 1:nrow(mat))
rownames(mat) <- rown
coln <- paste0("sample_", 1:ncol(mat))
colnames(mat) <- coln

The transposition function

To transpose a matrix (\(mat^{T}\)), rows and columns are swapped. In machine learning, features (e.g., genes) often appear in columns, while samples are rows. Use the t() function to perform the transposition.

mat
t(mat)

The diag() function

You can easily manipulate the matrix object with various specific functions. For example, getting and modifying the diagonal values can be performed by the diag() function.

Let’s imagine that a matrix represents the adjacency matrix of a graph which for any protein, A to H, indicates with a 1 whether it interacts with another (0 otherwise). Proteins will be the nodes (nodes/vertices) of the graph and interactions will constitute the edges (edges).

Let’s create such a matrix (we will see just later the graph representation).

mat <- matrix(c(0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 
                0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 
                1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 
                0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 
                0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 
                0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 
                1, 1, 0, 0),
            ncol = 8, 
            byrow = TRUE)
cr_names <- LETTERS[1:8]
colnames(mat) <- rownames(mat) <- cr_names
print(mat)

Using the igraph library, the graph can be created with the graph_from_adjacency_matrix() function. Here, we choose to declare the graph as undirected (mode=“undirected”) because, here, for protein-protein interactions, there is no particular source and target (i.e we don’t know whether one activates or represses the other, they just interact…).

library(igraph)
my_graph <- igraph::graph_from_adjacency_matrix(mat, mode="undirected")
plot(my_graph)

From the diagram, and by extracting the values from the matrix diagonal, we can see that B interacts with itself, as does D. This proteins may create homodimers. To check all the proteins that can create homodimers, we can just ask for the matrix diagonal.

diag(mat)

If we do not want to focus on these homodimeric interactions we may simply set the diagonal values to 0.

diag(mat) <- 0
all(diag(mat) == 0) # TRUE
print(mat) # 

mat

library(igraph)
my_graph <- igraph::graph_from_adjacency_matrix(mat, mode="undirected")
plot(my_graph)

The lower.tri() function

The functions upper.tri() or lower.tri() return a logical matrix indicating if a cell from the matrix is part of the upper or lower triangle respectively.

upper.tri(mat)

Indexing by a matrix

A test can be applied to all cells of the matrix. For example we can test whether the value is 1.

mat > 0.5

We can apply more complex tests by using boolean operators. For instance we could test whether a cell value is equal to 1 and part of the lower triangle.

mat > 0.5 & lower.tri(mat)

Two-dimensional indexing

Since a matrix contains rows and columns, we’ll (most of the time) use two-dimensional indexing. Two pieces of information are passed to the indexing operator in the form [lines, columns] (where lines and columns are vectors for the size of rows and columns respectively). If lines is not defined (e.g. [, columns]), all rows are extracted. Same principle for columns.

set.seed(123)
mat <- matrix(data=sample(1:20, size=40, replace = TRUE), 
            ncol = 4, 
            byrow = TRUE)
colnames(mat) <- LETTERS[1:4]
rownames(mat) <- letters[1:10]

set.seed(123)
mat <- matrix(data=sample(1:20, size=40, replace = TRUE), 
            ncol = 4, 
            byrow = TRUE)
colnames(mat) <- LETTERS[1:4]
rownames(mat) <- letters[1:10]

a <- mat[1, 1]
b <- mat[1, c(1, 2)]
c <- mat[1, ]
d <- mat[c(1,3), ]
e <- mat[, 1]
f <- mat[ ,c(1, 3)]

set.seed(123)
mat <- matrix(data=sample(1:20, size=40, replace = TRUE), 
            ncol = 4, 
            byrow = TRUE)
colnames(mat) <- LETTERS[1:4]
rownames(mat) <- letters[1:10]

set.seed(123)
mat <- matrix(data=sample(1:20, size=40, replace = TRUE), 
            ncol = 4, 
            byrow = TRUE)
colnames(mat) <- LETTERS[1:4]
rownames(mat) <- letters[1:10]

g <- mat[c(1, 3) ,c(1, 3)]
h <- mat[mat[, 1] > 11, ]
i <- mat["a", "B"]
j <- mat[c("a", "b", "c"), "B"]
k <- mat[, mat[1,] > 10]

Implicit Conversion by the Indexing Function

The indexing function can cause a type conversion that is not always desired (but is often very practical). For example, below, if we select a column from the matrix, we end up with a vector, which seems quite natural (the same is observed if we select a row).

mat <- matrix(1:20, ncol=4)
is(mat[, 1])

We can prevent this default behavior by setting the drop argument of the indexing function to FALSE. It is set to TRUE by default.

mat <- matrix(1:20, nc=10)
is(mat[, 1, drop=FALSE])

End of the section

Thank you for following this tutorial.