# Progress Log 108 (R): Create and Name Matrices

- June 7, 2019
- nanakoohashi
- Data Analytics/Data Science, R
- No Comments

#### I’m taking an edX course entitled “Introduction to R for Data Science” and all of the concepts described below come from that course.

### Matrix

- Vector: 1D array of data elements.
- Matrix: 2D array of data elements.
- Rows and columns.
- Can only contain one atomic vector type.

### Create a matrix

To build a matrix, you use the `matrix()`

function. You can choose to specify the number of rows or the number of columns. Have a look at the following example that creates a 2 by 3 matrix containing the values 1 to 6 by specifying the vector and setting the `nrow`

argument to 2.

R sees that the input vector has length 6 and that there have to be 2 rows. It then infers that you’ll probably want 3 columns, such that the number of matrix elements matches the number of input vector elements.

You could just as well specify `ncol`

instead of `nrow`

:

In this case, R infers the number of rows automatically.

In both examples, R takes the vector containing the values 1 to 6 and fills it up, column-by-column.

If you prefer to fill up the matrix in a row-wise fashion, such that 1, 2, and 3 are in the first row, you can set the `byrow`

argument of the matrix to `TRUE`

.

### Create a Matrix: recycling

Remember how R did recycling when you were subsetting vectors using logical vectors? The same thing happens when you pass the matrix function to a vector that is too short to fill up the entire matrix.

Suppose you pass a vector containing the values 1 to 3 to the matrix function and you explicitly say you want a matrix with 2 rows and 3 columns. R fills up the matrix column by column and simply repeats the vector.

If you try to fill up the matrix with a vector whose multiple does not nicely fit in the matrix, for example, when you want to put a 4-element vector in a 6-element matrix, R generates a warning message.

`rbind()`

, `cbind()`

Apart from the `matrix()`

function, there is another easy way to create matrices that is more intuitive in some cases. You can paste vectors together using the `rbind()`

and `cbind()`

functions.

`cbind()`

, short for column bind, takes the vectors you pass through it and sticks them together as if they were columns of a matrix.

`rbind()`

, short for row bind, does the same thing but takes the input as rows and makes a matrix out of them.

These bind functions can also handle matrices, so you can use them to paste another row or another column to an existing matrix.

Suppose you have a matrix containing the elements 1 to 6. If you want to add another row to it, containing the values 7, 8, 9, you could simply run this command:

You can do a similar thing with `cbind()`

.

### Naming a matrix: `rownames()`

, `colnames()`

In the case of naming vectors, you can simply use the `names()`

function but in the case of matrices, you could assign names to both columns and rows. That is why R came up with the `rownames()`

and `colnames()`

functions.

Retaking the matrix `m`

from before, we can set the row names just the same way as we named vectors, but this time with the `rownames()`

function. Setting up the column names with a vector of length 3 gives us a fully named matrix.

### Naming a matrix

Just as with vectors, there are also one-liner ways of naming matrices while you’re building it. You can use the `dimnames`

argument of the matrix function for this.

You will need to specify a list which has a vector of row names as the first element and column names as the second element.

### Coercion

Matrices are just an extension of vectors. This means that they can only contain a single atomic vector type. If you try to store different types in a matrix, coercion automatically takes place.

Take a look at these two matrices, one containing numerics, the other one containing characters.

Let’s now try to bind these two matrices together in a column-wise fashion using `cbind()`

.

Did you see what happened? The numeric matrix elements were coerced to characters to end up with a matrix that is only comprised of characters.

To have a multi-dimensional data structure that contain different elements, you’ll have to use the lists or more specifically: `data.frame`

.

`rowSums()`

In R, the function `rowSums()`

conveniently calculates the totals for each row of a matrix. This function creates a new vector:

```
sum_of_rows_vector
<- rowSums(my_matrix)
```

`colSums()`

R also has the function `colSums()`

which calculates the totals for each column of a matrix.

```
sum_of_cols_vector
<- colSums(my_matrix)
```