Julia Linear Algebra Guide — Matrix Operations, Factorizations, and Solvers

In this tutorial, you will learn about Julia Linear Algebra Guide. We cover key concepts, practical examples, and best practices to help you master this topic.

Julia linear algebra uses the backslash operator (\) for solving linear systems, built-in functions for LU, QR, Cholesky, SVD factorizations, and eigvals/eigvecs for eigenvalue problems -- all backed by BLAS and LAPACK for high performance.

Matrix Operations

A = [1 2; 3 4]
B = [5 6; 7 8]

# Multiplication
C = A * B    # [19 22; 43 50]

# Transpose
A'           # adjoint (conjugate transpose)
transpose(A) # non-conjugating transpose

# Inverse
inv(A)       # [-2.0 1.0; 1.5 -0.5]

# Determinant
det(A)       # -2.0

# Trace
tr(A)        # 5

Solving Linear Systems

A = [1 2; 3 4]
b = [5, 6]

# Solve Ax = b
x = A \ b    # [-4.0, 4.5]

# Verify
A * x ≈ b    # true

# Multiple right-hand sides
B = [5 6; 6 7]
X = A \ B    # solves for both columns

Factorizations

A = [3 1; 1 3]

# LU factorization
F = lu(A)
F.L * F.U ≈ A[F.p, :]  # true

# Cholesky (symmetric positive definite)
F = cholesky(A)
F.L * F.L' ≈ A          # true

# QR factorization
Q, R = qr(A)
Q * R ≈ A               # true

# SVD
U, S, V = svd(A)
U * Diagonal(S) * V' ≈ A  # true

Eigenvalues

A = [1 2; 2 1]

# Eigenvalues
vals = eigvals(A)     # [3.0, -1.0]

# Eigenvectors
vecs = eigvecs(A)     # columns are eigenvectors

# Both
D, V = eigen(A)
A * V ≈ V * Diagonal(D)  # true

# Generalized eigenvalue problem
B = [3 0; 0 1]
vals = eigvals(A, B)

Special Matrices

using LinearAlgebra

# Diagonal matrix
D = Diagonal([1, 2, 3])

# Symmetric
S = Symmetric([1 2; 2 1])

# Hermitian
H = Hermitian([1 2im; -2im 1])

# Identity
I(3)  # 3x3 identity

# Uniform scaling
2I    # works generically

# Tridiagonal
Tridiagonal([1,1], [2,2,2], [3,3])

Common Mistakes

1. Mistaking * for element-wise

A * B is matrix multiplication. Use A .* B for element-wise multiplication.

2. Forgetting A \ b vs b / A

A \ b solves Ax = b. b / A solves xA = b (less common).

3. Mutating with factorizations

Factorizations return factors as new objects. Use lu!, qr! for in-place (mutating) versions to save memory.

Practice Questions

1. How do you solve Ax = b in Julia? x = A \ b. The backslash operator selects the best factorization based on matrix structure.

2. How do you compute eigenvalues? eigvals(A) for values, eigvecs(A) for eigenvectors, eigen(A) for both.

3. What is the difference between * and . for matrices?* * is matrix multiplication. .* is element-wise multiplication.

FAQ

{{< faq question="Does Julia use BLAS and LAPACK?" >}} Yes. Julia links to OpenBLAS (or MKL) and LAPACK for matrix operations. Performance is comparable to MATLAB or NumPy. {{< /faq >}}

{{< faq question="Can I use GPU linear algebra?" >}} Yes. CUDA.jl and AMDGPU.jl provide GPU-accelerated linear algebra. They overload \, *, etc. for GPU arrays. {{< /faq >}}

{{< faq question="What is the difference between transpose and adjoint?" >}} transpose(A) swaps rows and columns. A' computes the conjugate transpose (adjoint). For real matrices they're the same. {{< /faq >}}

What's Next

Now learn about strings in Julia.