Matrix Addition and Subtraction

Matrices, like individual numbers and vectors, can undergo arithmetic operations. The simplest of these are addition and subtraction. These operations are fundamental for tasks where you might need to combine or compare datasets that share the same structure. For instance, if you have two matrices representing sales data from two consecutive months, adding them together gives you the total sales over that period.

The First Rule: Dimensions Must Match

Before you can add or subtract two matrices, you must check one important condition: the matrices must have the exact same dimensions. This means they must have the same number of rows and the same number of columns.

If you have a matrix $A$ with dimensions $m \times n$ (read as "m by n," meaning $m$ rows and $n$ columns) and a matrix $B$ with dimensions $p \times q$, you can only add or subtract them if $m = p$ and $n = q$. If their shapes don't align perfectly, the operation is undefined. You can't add an element that doesn't have a corresponding partner in the other matrix.

The Mechanics: Element-wise Operations

Once you've confirmed that two matrices have identical dimensions, the process of adding or subtracting them is straightforward. The operation is performed element-wise. This means you take the element in the first row and first column of the first matrix and add it to the element in the first row and first column of the second matrix. You repeat this for every single position.

Let's say we have two matrices, $A$ and $B$, and we want to find a new matrix $C$ such that $C = A + B$. The value of any element in $C$ at row $i$ and column $j$, denoted as $C_{ij}$, is simply the sum of the elements at the same position in $A$ and $B$.

Formally, this is written as:

$$C_{ij} = A_{ij} + B_{ij}$$

The same principle applies to subtraction:

$$C_{ij} = A_{ij} - B_{ij}$$

The diagram below illustrates this element-wise addition for two 2x2 matrices. Each element in the resulting matrix is the sum of the elements from the corresponding positions in the input matrices.

Each element at position ($i, j$) in the resulting matrix is the sum of the elements at position ($i, j$) from the original matrices.

A Practical Example

Imagine a small company tracks the number of products sold by two sales agents across three product categories. The sales for January are stored in matrix $J$, and February's sales are in matrix $F$.

Here are the sales for January (matrix $J$):

$$J = \begin{bmatrix} 50 & 35 & 110 \\ 75 & 90 & 60 \end{bmatrix}$$

And the sales for February (matrix $F$):

$$F = \begin{bmatrix} 45 & 40 & 100 \\ 80 & 110 & 50 \end{bmatrix}$$

Both matrices are $2 \times 3$, so we can add them to get the total sales for both months.

$$\text{Total Sales} = J + F = \begin{bmatrix} 50+45 & 35+40 & 110+100 \\ 75+80 & 90+110 & 60+50 \end{bmatrix} = \begin{bmatrix} 95 & 75 & 210 \\ 155 & 200 & 110 \end{bmatrix}$$

Likewise, if we wanted to see the change in sales from January to February, we could subtract $J$ from $F$:

$$\text{Change in Sales} = F - J = \begin{bmatrix} 45-50 & 40-35 & 100-110 \\ 80-75 & 110-90 & 50-60 \end{bmatrix} = \begin{bmatrix} -5 & 5 & -10 \\ 5 & 20 & -10 \end{bmatrix}$$

The resulting matrix shows that sales for Agent 1 dropped for products 1 and 3 but increased for product 2. Agent 2 saw an increase in sales for all products.

Properties of Matrix Addition

Matrix addition follows some familiar properties from standard arithmetic, which can be useful to remember:

• Commutative Property: The order of addition doesn't matter. $A + B = B + A$
• Associative Property: When adding three or more matrices, the grouping doesn't matter. $(A + B) + C = A + (B + C)$

These properties hold because the underlying operation is just the addition of individual numbers, which are themselves commutative and associative.

Matrix Addition in NumPy

In Python with the NumPy library, performing these operations is as simple as using the standard + and - operators. NumPy automatically handles the element-wise calculations.

import numpy as np

# January sales
J = np.array([
    [50, 35, 110],
    [75, 90, 60]
])

# February sales
F = np.array([
    [45, 40, 100],
    [80, 110, 50]
])

# Total sales
total_sales = J + F
print("Total Sales (J + F):")
print(total_sales)

# Change in sales
change_in_sales = F - J
print("\nChange in Sales (F - J):")
print(change_in_sales)

If you try to add or subtract matrices with mismatched dimensions in NumPy, it will raise a ValueError, protecting you from performing an invalid operation. This behavior reinforces the mathematical rule in a practical coding environment.