Understanding Matrices in R

# Understanding Matrices in R
# When I first encountered matrices in R, I was intrigued by how they offer a structured way to store data with two dimensions. Unlike vectors, which are limited to a single dimension, matrices open up possibilities for organizing and manipulating data in rows and columns. However, a matrix still has a lot in common with a vector, especially since it can only contain data of a single type. In this essay, I’ll walk through the basics of creating matrices in R, assigning row and column names, and working with different data types within matrices.
# 
# Creating Matrices
# To create a matrix in R, I can use the matrix() function. This function is straightforward yet powerful, allowing me to specify the data, the number of rows (nrow), and the number of columns (ncol). For instance, if I want a matrix that contains numbers from 1 to 6 arranged in two rows and three columns, I could write:

matrix(data = 1:6, nrow = 2, ncol = 3)

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

# This command yields a 2x3 matrix where each column is filled sequentially with the data values, resulting in:

# By default, the matrix fills by column. However, if I want the data to be filled by row instead, I can set byrow = TRUE. This small change leads to a different layout:

matrix(data = 1:6, nrow = 2, ncol = 3, byrow = TRUE)

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

# Different Data Types in Matrices
# One thing I find particularly interesting about matrices is that they aren’t limited to just numbers. Any vector can be transformed into a matrix, provided that all elements are of the same type. For example, I could create a matrix of logical values:

matrix(data = c(TRUE, TRUE, TRUE, FALSE, FALSE, FALSE), nrow = 3, ncol = 2)

##      [,1]  [,2]
## [1,] TRUE FALSE
## [2,] TRUE FALSE
## [3,] TRUE FALSE

# I can even create matrices with character data, which could be useful for certain types of categorical or label data:

matrix(data = c("a", "b", "c", "d", "e", "f"), nrow = 3, ncol = 2)

##      [,1] [,2]
## [1,] "a"  "d" 
## [2,] "b"  "e" 
## [3,] "c"  "f"

# Naming Rows and Columns
# Naming the rows and columns in a matrix is essential for clarity, especially when working with more complex datasets. Initially, when I create a matrix, the rows and columns don’t have names, which is reflected by NULL if I check with rownames() or colnames(). But I can easily assign meaningful names to each row and column. For instance:

mat1 <- matrix(data = 1:6, nrow = 2, ncol = 3, byrow = TRUE)
rownames(mat1) <- c("Row 1", "Row 2")
colnames(mat1) <- c("Col 1", "Col 2", "Col 3")
# Now, if I print mat1, I get:

# This makes it much easier to interpret the matrix, especially in larger datasets.
# 
# Data Type Coercion in Matrices
# One important thing I’ve learned about matrices is that they can only contain a single data type. If I try to mix types—say, combining characters with numbers—the entire matrix will be coerced to the highest data class available (character in this case). This behavior is something I need to keep in mind, especially when transforming data.
# 
# To check or convert the structure of a matrix, I can use functions like class(), is.matrix(), and as.vector(). These functions provide insight into the structure and allow me to coerce matrices into other types when needed.

class(mat1)        

## [1] "matrix" "array"

is.matrix(mat1)   

## [1] TRUE

as.vector(mat1)    

## [1] 1 4 2 5 3 6

# Summary Table of Matrix Operations
# To summarize, here’s a table that captures some key matrix operations and examples for easy reference.

# Here are a list of libraries that I have already installed
library(knitr)
library(kableExtra)

# Here is the data table where I have added some color 
matrix_table <- data.frame(
  Operation = c("Create Matrix by Column", "Create Matrix by Row",
                "Logical Matrix", "Character Matrix", "Set Row Names", "Set Column Names"),
  Code_Example = c("matrix(data = 1:6, nrow = 2, ncol = 3)", 
                   "matrix(data = 1:6, nrow = 2, ncol = 3, byrow = TRUE)",
                   "matrix(data = c(TRUE, FALSE), nrow = 3, ncol = 2)", 
                   "matrix(data = c('a', 'b', 'c'), nrow = 3, ncol = 2)", 
                   "rownames(mat1) <- c('Row 1', 'Row 2')",
                   "colnames(mat1) <- c('Col 1', 'Col 2', 'Col 3')"),
  Result = c("[1 3 5; 2 4 6]", "[1 2 3; 4 5 6]", 
             "[TRUE FALSE; TRUE FALSE; TRUE FALSE]",
             "['a' 'd'; 'b' 'e'; 'c' 'f']", 
             "Rows labeled as Row 1 and Row 2",
             "Columns labeled as Col 1, Col 2, and Col 3")
)

# Next I have created and formatted the table 
kable(matrix_table, "html", col.names = c("Operation", "Code Example", "Result")) %>%
  kable_styling(full_width = F, bootstrap_options = c("striped", "hover", "condensed")) %>%
  column_spec(1, bold = TRUE, color = "white", background = "#4CAF50") %>%
  column_spec(2, background = "#E0F7FA") %>%
  column_spec(3, background = "#FFEBEE")

Operation	Code Example	Result
Create Matrix by Column	matrix(data = 1:6, nrow = 2, ncol = 3)	[1 3 5; 2 4 6]
Create Matrix by Row	matrix(data = 1:6, nrow = 2, ncol = 3, byrow = TRUE)	[1 2 3; 4 5 6]
Logical Matrix	matrix(data = c(TRUE, FALSE), nrow = 3, ncol = 2)	[TRUE FALSE; TRUE FALSE; TRUE FALSE]
Character Matrix	matrix(data = c(‘a’, ‘b’, ‘c’), nrow = 3, ncol = 2)	[‘a’ ‘d’; ‘b’ ‘e’; ‘c’ ‘f’]
Set Row Names	rownames(mat1) <- c(‘Row 1’, ‘Row 2’)	Rows labeled as Row 1 and Row 2
Set Column Names	colnames(mat1) <- c(‘Col 1’, ‘Col 2’, ‘Col 3’)	Columns labeled as Col 1, Col 2, and Col 3

# This table provides a quick guide to common matrix operations in R, showing both code examples and their expected results. Understanding how to work with matrices has been essential for me in handling multidimensional data and makes data manipulation in R far more efficient.