Vectors and Matrices

A vector is a list of numbers; a matrix is a table of numbers. Linear algebra is the language of multi-factor models, portfolio optimization, and machine learning.

6 of 6 ~4 min

Vectors: Ordered Lists of Numbers

A vector is the simplest data structure in quantitative finance. It is an ordered collection of numbers, nothing more, nothing less.

Picture a portfolio with five assets. The vector of expected returns, in percent per month, might look like this:

\mathbf{r} = \begin{bmatrix} 2.1 \\ 1.4 \\ 3.2 \\ 0.8 \\ 1.9 \end{bmatrix}

Each entry corresponds to one asset. The order matters, asset 3’s expected return is 3.2, not 0.8.

The Geometric View

Vectors have a geometric life too. A 2-dimensional vector like $\mathbf{v} = [3, 4]$ can be drawn as an arrow starting at the origin and ending at the point (3, 4) in a coordinate plane. The norm (or length) of a vector is the distance from the origin to its tip:

\|\mathbf{v}\| = \sqrt{v_1^2 + v_2^2 + \cdots + v_n^2}

For $\mathbf{v} = [3, 4]$ , the norm is $\sqrt{9 + 16} = 5$ . This is the Pythagorean theorem in action.

In a 500-asset portfolio, each asset is its own dimension. You are working in a 500-dimensional space, which is impossible to visualize, but the algebra stays the same.

Vector Operations

Vectors support three basic operations.

Addition adds corresponding entries: $[1, 2] + [3, 4] = [4, 6]$ .

Scalar multiplication multiplies every entry by a constant: $2 \times [1, 2] = [2, 4]$ .

The dot product (inner product) multiplies vectors entry-by-entry and sums the results:

\mathbf{v} \cdot \mathbf{w} = \sum_{i=1}^{n} v_i w_i

The dot product of $\mathbf{v} = [1, 2, 3]$ and $\mathbf{w} = [4, 5, 6]$ is $1 \times 4 + 2 \times 5 + 3 \times 6 = 32$ .

The dot product leads to one of the most useful concepts: orthogonality. Two vectors are orthogonal when their dot product equals zero. Geometrically, they are perpendicular, they point in completely unrelated directions. This matters in statistics when you want to confirm that one variable adds independent information that another cannot provide.

Matrices: Tables That Transform Data

A matrix is a rectangular table of numbers with rows and columns. If a vector is a single column of data, a matrix is several columns side by side.

A matrix with $m$ rows and $n$ columns is called an $m \times n$ matrix. The entry in row $i$ , column $j$ is written $a_{ij}$ .

Two matrices appear constantly in quant finance:

The returns matrix $\mathbf{R}$ of size $T \times n$ contains $T$ time periods of returns for $n$ assets. Row $t$ holds all assets’ returns on day $t$ ; column $j$ holds asset $j$ ‘s returns across all days.

The covariance matrix $\mathbf{\Sigma}$ of size $n \times n$ contains the variances of each asset on the diagonal and the covariances between each pair off the diagonal. It is always symmetric, $\Sigma_{ij} = \Sigma_{ji}$ because covariance is symmetric.

The Transpose

The transpose operation swaps rows and columns. If $\mathbf{A}$ is $m \times n$ , then $\mathbf{A}^\top$ is $n \times m$ . The first row becomes the first column.

[\mathbf{A}^\top]_{ij} = a_{ji}

In Python with NumPy:

import numpy as np


A = np.array([[1, 4],
              [2, 5],
              [3, 6]])

print(A.shape)  # (3, 2)
print(A.T.shape)  # (2, 3)

PROMPT

Use numpy to create a 3x2 matrix and print its shape along with the shape of its transpose.

Matrix Operations

Matrices add and multiply by scalars just like vectors, entry by entry. The interesting operation is matrix multiplication, which combines two matrices.

To multiply $\mathbf{A}$ (size $m \times n$ ) by $\mathbf{B}$ (size $n \times p$ ), you compute each entry $(i,j)$ as the dot product of row $i$ of $\mathbf{A}$ with column $j$ of $\mathbf{B}$ :

(\mathbf{A}\mathbf{B})_{ij} = \sum_{k=1}^{n} a_{ik} b_{kj}

The resulting matrix has size $m \times p$ . Notice that the inner dimensions must match, $\mathbf{A}$ must have as many columns as $\mathbf{B}$ has rows.

import numpy as np

A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

# Matrix multiplication
C = A @ B  # or np.matmul(A, B)
print(C)
# [[19 22]
#  [43 50]]

PROMPT

Use numpy to multiply two 2x2 matrices with the @ operator and print the result.

The Dot Product as Matrix Multiplication

A key insight: taking the dot product of two vectors is the same as multiplying a row vector by a column vector. This is the foundation of portfolio return calculations.

Given a weight vector $\mathbf{w}$ (the proportion of capital in each asset) and a return vector $\mathbf{r}$ :

r_p = \mathbf{w}^\top \mathbf{r} = \sum_{i=1}^{n} w_i r_i

The portfolio return is the weighted sum of individual asset returns, a single dot product.

import numpy as np

# Five assets: expected monthly returns
expected_returns = np.array([2.1, 1.4, 3.2, 0.8, 1.9])  # percent

# Portfolio weights (must sum to 1)
weights = np.array([0.30, 0.20, 0.25, 0.10, 0.15])

# Portfolio return = dot product of weights and returns
portfolio_return = weights @ expected_returns
print(f"Expected portfolio return: {portfolio_return:.2f}%")

PROMPT

Use numpy to compute a portfolio’s expected return as the dot product of an asset-weight vector and a returns vector.

This simple operation, one dot product, is the backbone of portfolio return calculations. Every time you see a portfolio’s expected return, somewhere a weight vector is being dotted with a return vector.

References

Strang, Introduction to Linear Algebra, 5th edition, Wellesley-Cambridge Press, Chapters 1–2. ISBN: 978-0980232776.

Lax, Linear Algebra and Its Applications, 2nd edition, Wiley, Chapter 1. ISBN: 978-0471751564.