notebooks/matrices-in-r/matrices-in-r.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Mastering Matrices in R\n",
    "### An Introduction to Matrices for Data Manipulation and Analysis using R\n",
    "2023-02-14 | Clemens Jarnach \n",
    "\n",
    "A matrix is a two-dimensional array that contains elements of the same data type (e.g., numeric, character, or logical). In R, matrices  can be created using the `matrix()` function, which takes a vector of elements and specifies the number of rows and columns.\n",
    "Matrices are a fundamental data structure in R, offering immense power and flexibility to perform complex mathematical operations with ease. Matrices in R can store different types of data, from integers and real numbers to characters and even logical values. With built-in functions for basic arithmetic, matrix algebra, and linear algebra, matrices offer a wide range of applications in science, engineering, and finance. In this brief guide, we will explore the basics of matrices in R, how to create and manipulate them, and how to perform mathematical operations on them.\n",
    "\n",
    "Let's start by creating a basic matrix  called `my_matrix` with three rows and three columns, containing the numbers 1 to 9 in order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     [,1] [,2] [,3]\n",
      "[1,]    1    4    7\n",
      "[2,]    2    5    8\n",
      "[3,]    3    6    9\n"
     ]
    }
   ],
   "source": [
    "# Create a 3x3 matrix\n",
    "my_matrix <- matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9), nrow = 3, ncol = 3)\n",
    "\n",
    "# Print the matrix\n",
    "print(my_matrix)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we first create a vector with the values 1 through 9 using the `c()` function. We then pass this vector to the `matrix()` function, along with the `nrow()` and `ncol()` arguments to specify the number of rows and columns in the matrix. Finally, we assign the resulting matrix to the variable `my_matrix`.\n",
    "The resulting matrix has 3 rows and 3 columns, with the values 1 to 9 arranged in row-major order. We can access individual elements of the matrix using square brackets, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "4"
      ],
      "text/latex": [
       "4"
      ],
      "text/markdown": [
       "4"
      ],
      "text/plain": [
       "[1] 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the value in the first row and second column\n",
    "my_matrix[1, 2]  # In our example, this returns 4"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access entire rows or columns of the matrix using the colon operator, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>1</li><li>4</li><li>7</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1\n",
       "\\item 4\n",
       "\\item 7\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1\n",
       "2. 4\n",
       "3. 7\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1 4 7"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the first row\n",
    "my_matrix[1, ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Addition and Subtraction\n",
    "Built-in R functions allow us to perform matrix operations such as addition, multiplication, and inversion. Let me give you an example of how to perform some basic matrix operations in R. Let's start simple with additions and subtractions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A matrix: 2 × 2 of type dbl</caption>\n",
       "<tbody>\n",
       "\t<tr><td>6</td><td>10</td></tr>\n",
       "\t<tr><td>8</td><td>12</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A matrix: 2 × 2 of type dbl\n",
       "\\begin{tabular}{ll}\n",
       "\t 6 & 10\\\\\n",
       "\t 8 & 12\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A matrix: 2 × 2 of type dbl\n",
       "\n",
       "| 6 | 10 |\n",
       "| 8 | 12 |\n",
       "\n"
      ],
      "text/plain": [
       "     [,1] [,2]\n",
       "[1,] 6    10  \n",
       "[2,] 8    12  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A matrix: 2 × 2 of type dbl</caption>\n",
       "<tbody>\n",
       "\t<tr><td>4</td><td>4</td></tr>\n",
       "\t<tr><td>4</td><td>4</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A matrix: 2 × 2 of type dbl\n",
       "\\begin{tabular}{ll}\n",
       "\t 4 & 4\\\\\n",
       "\t 4 & 4\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A matrix: 2 × 2 of type dbl\n",
       "\n",
       "| 4 | 4 |\n",
       "| 4 | 4 |\n",
       "\n"
      ],
      "text/plain": [
       "     [,1] [,2]\n",
       "[1,] 4    4   \n",
       "[2,] 4    4   "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First, create two new matrices\n",
    "matrix_A <- matrix(c(1, 2, 3, 4), nrow = 2)\n",
    "matrix_B <- matrix(c(5, 6, 7, 8), nrow = 2)\n",
    "\n",
    "# Matrix addition\n",
    "matrix_C <- matrix_A + matrix_B\n",
    "matrix_C\n",
    "\n",
    "# Matrix subtraction\n",
    "matrix_D <- matrix_B - matrix_A\n",
    "matrix_D"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we create two 2x2 matrices (`matrix_A` and `matrix_B`). We then perform a matrix addition by simply adding the two matrices together to get `matrix_C`. Similarly, we perform a subtraction to obtain `matrix_D`.\n",
    "A-OK. That wasn't too hard, was it?\n",
    "\n",
    "### Scalar Multiplication\n",
    "Next is scalar multiplication, which is the multiplication of each entry in a matrix by the same number; this number is called the 'scalar'. In R, this could look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     [,1] [,2]\n",
      "[1,]   10   14\n",
      "[2,]   12   16\n"
     ]
    }
   ],
   "source": [
    "# Scalar multiplication\n",
    "print( 2 * matrix_B )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Multiplication\n",
    "Scalar multiplication is easy. Matrix multiplication, however, is a completely different story. In fact, it's a pain in the neck. But luckily we have R and she does all the calculations for us.\n",
    "Matrix multiplication is the process of multiplying one matrix by another. Matrix multiplication is a mathematical operation performed between two matrices to create a new matrix. It involves multiplying the corresponding elements in each row of the first matrix with the corresponding elements in each column of the second matrix and then summing the results to get the element of the resulting matrix. The number of columns in the first matrix must be equal to the number of rows in the second matrix. If the matrices do not meet this requirement, matrix multiplication cannot be performed. (If you need more information on this read this Wikipedia article on matrix multiplication.)\n",
    "Fortunately, we have R to do all that for us. And here is how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A matrix: 2 × 2 of type dbl</caption>\n",
       "<tbody>\n",
       "\t<tr><td>23</td><td>31</td></tr>\n",
       "\t<tr><td>34</td><td>46</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A matrix: 2 × 2 of type dbl\n",
       "\\begin{tabular}{ll}\n",
       "\t 23 & 31\\\\\n",
       "\t 34 & 46\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A matrix: 2 × 2 of type dbl\n",
       "\n",
       "| 23 | 31 |\n",
       "| 34 | 46 |\n",
       "\n"
      ],
      "text/plain": [
       "     [,1] [,2]\n",
       "[1,] 23   31  \n",
       "[2,] 34   46  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Matrix multiplication\n",
    "matrix_E <- matrix_A %*% matrix_B\n",
    "matrix_E"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%*%` operator is used to multiply matrices that satisfy the condition that the number of columns in the first matrix is equal to the number of rows in the second matrix. If this condition is not met,  R will throw an error indicating that the matrices are not conformable.\n",
    "So far we have added, subtracted, and even multiplied matrices, but what about divisions? WARNING: You cannot divide matrices! There is, however, a related concept called 'inversion'.\n",
    "\n",
    "\n",
    "### Inverse of a Matrix\n",
    "In linear algebra, the inverse of a matrix is a matrix that, when multiplied by the original matrix, results in an identity matrix. An identity matrix is a square matrix in which all the elements of the main diagonal are 1, and all other elements are 0. Simple! The inverse of a matrix can be calculated only for square matrices. If a matrix A has an inverse, it is denoted as $A^{-1}$. The inverse matrix satisfies the property that $A \\times A^{-1} = A^{-1} \\times A = I$, where I is the identity matrix.\n",
    "So let's find the inverse of our `matrix_A` using R:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [],
   "source": [
    "# Matrix inversion\n",
    "inverse_matrix <- solve(matrix_A)\n",
    "inverse_matrix"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the `solve()` function, which is  R's standard function for matrix inverse calculations. The `solve()` function takes a matrix as an argument and returns the inverse of that matrix.\n",
    "The inverse of a matrix has a number of useful applications in linear algebra and related fields, including solving systems of linear equations, calculating determinants, and finding solutions to matrix equations.\n",
    "\n",
    "### apply()function\n",
    "Another slightly more advanced method for matrices in R is to use the `apply()`  function. This allows you to apply a function to each row or column of a matrix. The `apply()` function is useful when you need to apply a function to each row or column of a matrix and return a vector or array of the results.\n",
    "The syntax of the apply() function looks like this:\n",
    "`apply(X, MARGIN, FUN, ...)`\n",
    "where `X` is the matrix, `MARGIN` specifies whether the function should be applied to rows `(MARGIN=1)` or columns `(MARGIN=2)` of the matrix, `FUN` is the function to apply, and `…` indicated that there are more optional arguments possible. \n",
    "Here is an example that uses the apply() function to calculate the row means of a matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>5.5</li><li>6.5</li><li>7.5</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 5.5\n",
       "\\item 6.5\n",
       "\\item 7.5\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 5.5\n",
       "2. 6.5\n",
       "3. 7.5\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 5.5 6.5 7.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a 3x4 matrix\n",
    "matrix_F <- matrix(1:12, nrow = 3, ncol = 4)\n",
    "\n",
    "# calculate the row means\n",
    "row_means <- apply(matrix_F, 1, mean)\n",
    "\n",
    "# print the row means\n",
    "row_means"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `apply()` function to perform more complex operations on the rows or columns of a matrix. For example, we can calculate the standard deviation of each column of a matrix using the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "vscode": {
     "languageId": "r"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A matrix: 4 × 4 of type dbl</caption>\n",
       "<tbody>\n",
       "\t<tr><td>-2.1200371</td><td> 0.9504217</td><td> 0.84884919</td><td>-1.56976571</td></tr>\n",
       "\t<tr><td>-0.3488258</td><td>-1.1072797</td><td> 0.08566767</td><td> 0.39763699</td></tr>\n",
       "\t<tr><td> 0.6608534</td><td> 0.6407980</td><td>-0.17447592</td><td>-1.22851150</td></tr>\n",
       "\t<tr><td> 0.1148343</td><td>-0.6463477</td><td> 0.53062618</td><td> 0.01183711</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A matrix: 4 × 4 of type dbl\n",
       "\\begin{tabular}{llll}\n",
       "\t -2.1200371 &  0.9504217 &  0.84884919 & -1.56976571\\\\\n",
       "\t -0.3488258 & -1.1072797 &  0.08566767 &  0.39763699\\\\\n",
       "\t  0.6608534 &  0.6407980 & -0.17447592 & -1.22851150\\\\\n",
       "\t  0.1148343 & -0.6463477 &  0.53062618 &  0.01183711\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A matrix: 4 × 4 of type dbl\n",
       "\n",
       "| -2.1200371 |  0.9504217 |  0.84884919 | -1.56976571 |\n",
       "| -0.3488258 | -1.1072797 |  0.08566767 |  0.39763699 |\n",
       "|  0.6608534 |  0.6407980 | -0.17447592 | -1.22851150 |\n",
       "|  0.1148343 | -0.6463477 |  0.53062618 |  0.01183711 |\n",
       "\n"
      ],
      "text/plain": [
       "     [,1]       [,2]       [,3]        [,4]       \n",
       "[1,] -2.1200371  0.9504217  0.84884919 -1.56976571\n",
       "[2,] -0.3488258 -1.1072797  0.08566767  0.39763699\n",
       "[3,]  0.6608534  0.6407980 -0.17447592 -1.22851150\n",
       "[4,]  0.1148343 -0.6463477  0.53062618  0.01183711"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>1.20408195876568</li><li>0.991827122786333</li><li>0.455863458494401</li><li>0.949572731075639</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 1.20408195876568\n",
       "\\item 0.991827122786333\n",
       "\\item 0.455863458494401\n",
       "\\item 0.949572731075639\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 1.20408195876568\n",
       "2. 0.991827122786333\n",
       "3. 0.455863458494401\n",
       "4. 0.949572731075639\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] 1.2040820 0.9918271 0.4558635 0.9495727"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a 4x4 matrix with random numbers \n",
    "matrix_G <- matrix(rnorm(16), nrow = 4, ncol = 4)\n",
    "matrix_G\n",
    "\n",
    "# calculate the standard deviations for each column\n",
    "column_SD <- apply(matrix_G, 2, sd)\n",
    "\n",
    "# print the column standard deviations\n",
    "column_SD"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line of code generates a 4x4 matrix named `matrix_G`. The matrix is created by calling the `matrix()` function in R, which creates a matrix with random numbers generated by the `rnorm()` function. The arguments `nrow()` and `ncol()` specify the number of rows and columns in the matrix. Just like we did before. This time, the resulting matrix `matrix_G` will contain 4 rows and 4 columns. The second line of code calculates the standard deviation (SD) of each column of `matrix_G` using the `apply()` function in R.\n",
    "\n",
    "### To sum up\n",
    "Matrices are a mathematical workhorse with extraordinary capabilities in R programming. Their versatility in storing different forms of data allows for simple yet complex mathematical operations. R's `matrix()` function provides an easy way to create matrices by specifying the number of rows and columns using a vector of elements. Whether in arithmetic, matrix algebra or linear algebra, matrices are widely used in science, engineering and finance.\n",
    "\n",
    "### Resources\n",
    "- R - Matrices:  https://www.tutorialspoint.com/r/r_matrices.htm\n",
    "  \n",
    "- Wikipedia - Matrix multiplication: https://en.wikipedia.org/wiki/Matrix_multiplication \n",
    "  \n",
    "- Wikipedia - Invertible matrix: https://en.wikipedia.org/wiki/Invertible_matrix#Methods_of_matrix_inversion\n",
    "  \n",
    "- R - apply(): https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/apply\n",
    "  \n",
    "- R - Matrix Inversion: https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/solve\n",
    "  \n",
    "- statmethods - Matrix Algebra: https://www.statmethods.net/advstats/matrix.html\n",
    "\n",
    "---\n",
    "👉👈  Follow me for more: [Medium](https://medium.com/r/?url=https%3A%2F%2Ft.co%2FD0Ndbkjld9) | [Twitter](https://medium.com/r/?url=https%3A%2F%2Ftwitter.com%2FClemensJarnach) | [GitHub](https://github.com/clemensjarnach)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.1.2"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e092955e1a1b1a2f7a8b51520666650835e009b20f9c23ceb523ee5a48e66295"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}