Inner Products, Norms, and Distance in State Space: How Linear Algebra Defines System Geometry

Last Updated June 28, 2026

Inner products, norms, and distance in state space explain how linear algebra defines geometry for systems modeling. A vector space does not automatically know what length, angle, similarity, or distance means. Those ideas come from additional structure: an inner product, a norm, and a metric. Once those choices are made, a model can measure alignment, residual size, approximation error, state change, uncertainty-weighted distance, and geometric separation.

This article introduces inner products, norms, and distance as the geometry layer of linear algebra. It connects dot products, weighted inner products, Euclidean norms, alternative norms, vector distances, state-space geometry, residual magnitude, scaling, units, normalization, energy-like measures, covariance-aware distance, similarity, orthogonality, numerical conditioning, and responsible interpretation.

The central modeling question is not only “How far apart are these states?” It is “What definition of distance makes sense for this system, this data, this scale, and this modeling purpose?”

State space is not just a collection of possible system states. It becomes geometrically meaningful only when the model defines how states are compared. Inner products define alignment and angle. Norms define length and magnitude. Distances define separation between states. These choices determine how a model measures similarity, error, deviation, residuals, change, risk, and approximation quality.

For systems modeling, geometry is never neutral. A distance measure can privilege one variable over another. A norm can make small deviations look large or large deviations look small. A scaling choice can change which states appear close. A weighted inner product can reflect energy, uncertainty, importance, covariance, cost, or risk. The geometry chosen by the model shapes the conclusions the model can responsibly support.

Why State-Space Geometry Matters

State-space geometry matters because models compare states. A system state may represent temperature readings, economic sector outputs, infrastructure conditions, ecological populations, policy indicators, machine-learning features, or simulation variables. To compare two states, the model must decide what counts as difference, similarity, magnitude, and change.

Those decisions are mathematical, but they are also substantive. If one variable is measured in dollars and another in tons, ordinary Euclidean distance may be meaningless without scaling. If one measurement is highly uncertain and another is reliable, a weighted geometry may be more appropriate. If outliers matter differently from average deviations, different norms can produce different conclusions.

State-space geometry determines what a model treats as close, far, large, small, aligned, independent, or anomalous.

Back to top ↑

Vectors Need Geometry

A vector space supports addition and scalar multiplication. But those operations alone do not define length, angle, or distance. To speak about the size of a vector, the angle between vectors, or the distance between states, additional structure is required.

This is why inner products and norms are not decorative. They define the geometry of the model. Two models may use the same state variables but different geometries, leading to different measures of error, similarity, and importance.

Choosing the geometry is therefore part of the modeling design.

Back to top ↑

Inner Products

An inner product is a rule that takes two vectors and returns a scalar. It generalizes the dot product and defines alignment, angle, orthogonality, and length. In real vector spaces, an inner product is usually written as \(\langle \mathbf{x},\mathbf{y}\rangle\).

For real vector spaces, an inner product must satisfy several core properties: symmetry, linearity in one argument, and positive definiteness.

The inner product defines what it means for state directions to overlap.

Back to top ↑

The Dot Product

The standard dot product is the most familiar inner product on real coordinate vectors. For vectors \(\mathbf{x},\mathbf{y}\in\mathbb{R}^n\), it is:

The dot product is simple and powerful, but it assumes the coordinate dimensions are already comparable. If variables use different units or scales, the standard dot product may produce misleading geometry.

The dot product is a default geometry, not a universally correct geometry.

Back to top ↑

Angles and Alignment

Inner products define angles. In Euclidean geometry, the angle \(\theta\) between nonzero vectors \(\mathbf{x}\) and \(\mathbf{y}\) satisfies:

This quantity is often called cosine similarity in data analysis and machine learning. It compares direction rather than size. Two large vectors and two small vectors can have the same angle if they point in the same direction.

Alignment is useful when the shape or pattern of a state matters more than its magnitude.

Back to top ↑

Weighted Inner Products

A weighted inner product changes the geometry by assigning different importance to different directions. If \(W\) is a symmetric positive definite matrix, a weighted inner product can be written as:

If \(W\) is diagonal, each coordinate receives a separate weight. If \(W\) has off-diagonal entries, the geometry can also account for relationships among variables.

Weighted inner products make geometry explicit, but the weights must be justified.

Back to top ↑

Norms

A norm measures the magnitude or length of a vector. Norms are often derived from inner products, but not every norm comes from an inner product. A norm is usually written as \(\|\mathbf{x}\|\).

A norm must satisfy positivity, homogeneity, and the triangle inequality.

Norms are used to measure residual size, error, state change, perturbation, convergence, distance from equilibrium, and sensitivity.

Back to top ↑

Common Vector Norms

Different norms emphasize different aspects of a vector. The Euclidean norm measures root-sum-square magnitude. The \(1\)-norm measures total absolute magnitude. The infinity norm measures the largest absolute coordinate. General \(p\)-norms interpolate among these behaviors.

The norm chosen for a model determines which deviations matter most.

Back to top ↑

Distance Between States

Distance between two state vectors is usually measured by applying a norm to their difference. If \(\mathbf{x}\) and \(\mathbf{y}\) are two system states, then:

This formula is simple, but its meaning depends entirely on the norm. Different norms can produce different judgments about which states are close, which are far, and which changes are important.

Distance is not just subtraction. It is subtraction plus a chosen geometry.

Back to top ↑

Residuals and Error Magnitude

Residuals are difference vectors. They measure the gap between what was observed and what a model produced. If \(\mathbf{b}\) is the observed target and \(\widehat{\mathbf{b}}\) is the fitted or modeled value, then:

To summarize residual size, a norm is applied:

Different residual norms tell different stories. The \(2\)-norm emphasizes squared deviations. The \(1\)-norm is less dominated by large outliers. The infinity norm focuses on worst-case deviation. A weighted norm can account for uncertainty, reliability, priority, or consequence.

A residual norm is not an objective truth about model quality. It is a measurement under a chosen geometry.

Back to top ↑

Scaling, Units, and Normalization

Scaling affects geometry. If one coordinate is measured in millions and another in fractions, ordinary distance will often be dominated by the large-scale coordinate. This may reflect reality, or it may be a unit artifact.

Normalization and standardization change coordinates so that variables become more comparable. But they also change interpretation. A standardized variable no longer represents the original unit directly; it represents deviation relative to a reference distribution.

Scaling choices should be treated as modeling assumptions, not preprocessing details.

Back to top ↑

State-Space Distance and Model Meaning

In state-space modeling, a state vector represents the condition of a system at a moment, scenario, or simulation step. Distance between states can mean physical change, economic difference, ecological shift, infrastructure degradation, policy movement, or feature-space separation.

But distance only has meaning relative to the state representation. If coordinates are poorly chosen, scaled inconsistently, or mixed across incompatible units, state-space distance may be misleading.

Distance in state space is useful only when the state-space representation is meaningful.

Back to top ↑

Energy, Risk, and Weighted Geometry

In many systems, ordinary Euclidean geometry is not the most meaningful geometry. A weighted norm may better represent energy, cost, uncertainty, reliability, priority, exposure, or risk.

If a deviation in one coordinate is more costly or more dangerous than a deviation in another, a weighted norm can express that difference. But weights embed judgment. They should be documented and reviewed.

Weighted geometry can make a model more realistic, but it also makes value choices explicit.

Back to top ↑

Covariance-Aware Distance

When variables have different variances or are correlated, covariance-aware distance can be more meaningful than ordinary Euclidean distance. One common form is the Mahalanobis distance. If \(\Sigma\) is a covariance matrix, then the squared Mahalanobis distance from \(\boldsymbol{\mu}\) is:

This distance accounts for scale and correlation. A deviation along a high-variance direction may be less unusual than the same raw deviation along a low-variance direction. Correlated variables are not treated as fully independent dimensions.

Covariance-aware distance can improve interpretation when the geometry of variation matters.

Back to top ↑

Norms and Numerical Conditioning

Norms are central to numerical analysis. They measure vector size, matrix size, perturbation size, residual size, approximation error, and condition numbers. Without norms, numerical stability cannot be quantified.

A matrix norm measures the size of a matrix as an operator. It helps describe how much a matrix can amplify input vectors.

The condition number of a matrix measures sensitivity to perturbation:

Numerical claims depend on norm choices. A workflow should document which norms were used and why.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Inner products, norms, and distances connect vector spaces, metric spaces, Hilbert spaces, orthogonality, projections, dual norms, induced matrix norms, positive definite matrices, energy norms, covariance geometry, optimization, regularization, stability, convergence, and approximation theory.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for inner products, norms, and distance should document the state vectors, coordinate units, scaling method, inner product definition, norm choice, distance metric, residual norm, weighted matrix if used, covariance matrix if used, condition diagnostics, and interpretation warnings.

The companion repository treats state-space geometry as auditable systems modeling. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of reproducible geometry analysis.

For this article, the computational examples focus on standard and weighted inner products, vector norms, distance between states, residual norms, scaling warnings, and model-governance records.

Back to top ↑

Python Workflow: State-Space Geometry Audit

The Python workflow below computes dot products, weighted inner products, common norms, distances, residual magnitudes, cosine similarity, and interpretation warnings.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import math


Vector = list[float]
Matrix = list[list[float]]


@dataclass(frozen=True)
class StateSpaceGeometryAudit:
    system_name: str
    state_a: str
    state_b: str
    difference_vector: str
    dot_product: float
    cosine_similarity: float
    weighted_inner_product: float
    norm_1: float
    norm_2: float
    norm_inf: float
    euclidean_distance: float
    weighted_distance: float
    interpretation_warning: str


def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))


def matvec(A: Matrix, x: Vector) -> Vector:
    return [dot(row, x) for row in A]


def weighted_inner_product(x: Vector, y: Vector, W: Matrix) -> float:
    return dot(x, matvec(W, y))


def subtract(a: Vector, b: Vector) -> Vector:
    return [x - y for x, y in zip(a, b)]


def norm1(x: Vector) -> float:
    return sum(abs(v) for v in x)


def norm2(x: Vector) -> float:
    return math.sqrt(sum(v * v for v in x))


def norminf(x: Vector) -> float:
    return max(abs(v) for v in x)


def cosine_similarity(a: Vector, b: Vector) -> float:
    denom = norm2(a) * norm2(b)
    if denom <= 1e-12:
        raise ValueError("cosine similarity undefined for near-zero vector")
    return dot(a, b) / denom


def vector_to_string(x: Vector) -> str:
    return ",".join(f"{v:.6f}" for v in x)


def build_audit() -> StateSpaceGeometryAudit:
    state_a = [12.0, 4.0, 0.8]
    state_b = [10.0, 5.5, 1.1]
    difference = subtract(state_a, state_b)

    # Diagonal weights: third coordinate matters more because it represents
    # a normalized risk or reliability measure in this synthetic example.
    W = [
        [1.0, 0.0, 0.0],
        [0.0, 0.5, 0.0],
        [0.0, 0.0, 8.0],
    ]

    weighted_diff_magnitude = math.sqrt(weighted_inner_product(difference, difference, W))

    return StateSpaceGeometryAudit(
        system_name="three_indicator_state_space_geometry_audit",
        state_a=vector_to_string(state_a),
        state_b=vector_to_string(state_b),
        difference_vector=vector_to_string(difference),
        dot_product=round(dot(state_a, state_b), 12),
        cosine_similarity=round(cosine_similarity(state_a, state_b), 12),
        weighted_inner_product=round(weighted_inner_product(state_a, state_b, W), 12),
        norm_1=round(norm1(difference), 12),
        norm_2=round(norm2(difference), 12),
        norm_inf=round(norminf(difference), 12),
        euclidean_distance=round(norm2(difference), 12),
        weighted_distance=round(weighted_diff_magnitude, 12),
        interpretation_warning=(
            "State-space distance depends on units, scaling, norm choice, and weights. "
            "Weighted distances may reflect risk, uncertainty, cost, or priority, but those weights "
            "must be documented and translated back into domain terms."
        ),
    )


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)

    audit = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "state_space_geometry_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    (output_dir / "json" / "state_space_geometry_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("State-space geometry audit complete.")

This workflow treats geometry as a modeling assumption. It reports multiple norms and distances so that the modeler can see how conclusions depend on measurement choice.

Back to top ↑

R Workflow: Inner Product and Norm Diagnostics

R can support geometry diagnostics by computing dot products, cosine similarity, common norms, weighted distances, and audit-ready records.

state_a <- c(12.0, 4.0, 0.8)
state_b <- c(10.0, 5.5, 1.1)

difference <- state_a - state_b

dot_product <- sum(state_a * state_b)

norm1 <- function(x) sum(abs(x))
norm2 <- function(x) sqrt(sum(x^2))
norminf <- function(x) max(abs(x))

cosine_similarity <- dot_product / (norm2(state_a) * norm2(state_b))

W <- matrix(
  c(
    1.0, 0.0, 0.0,
    0.0, 0.5, 0.0,
    0.0, 0.0, 8.0
  ),
  nrow = 3,
  byrow = TRUE
)

weighted_inner_product <- as.numeric(t(state_a) %*% W %*% state_b)
weighted_distance <- sqrt(as.numeric(t(difference) %*% W %*% difference))

audit_record <- data.frame(
  system_name = "three_indicator_state_space_geometry_audit",
  state_a = paste(round(state_a, 6), collapse = ","),
  state_b = paste(round(state_b, 6), collapse = ","),
  difference_vector = paste(round(difference, 6), collapse = ","),
  dot_product = dot_product,
  cosine_similarity = cosine_similarity,
  weighted_inner_product = weighted_inner_product,
  norm_1 = norm1(difference),
  norm_2 = norm2(difference),
  norm_inf = norminf(difference),
  euclidean_distance = norm2(difference),
  weighted_distance = weighted_distance,
  interpretation_warning = paste(
    "State-space distance depends on units, scaling, norm choice, and weights.",
    "Weighted distances require documented domain justification."
  )
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(
  audit_record,
  "outputs/tables/r_state_space_geometry_audit.csv",
  row.names = FALSE
)

print(audit_record)

This R workflow is useful when comparing scenarios, residuals, indicator states, feature vectors, or system trajectories under different distance assumptions.

Back to top ↑

Haskell Workflow: Typed Geometry Records

Haskell can represent state-space geometry diagnostics as a typed record with fields for dot products, similarity, norms, distances, and interpretation warnings.

module Main where

data StateSpaceGeometryAudit = StateSpaceGeometryAudit
  { systemName :: String
  , stateA :: String
  , stateB :: String
  , differenceVector :: String
  , dotProduct :: Double
  , cosineSimilarity :: Double
  , weightedInnerProduct :: Double
  , normOne :: Double
  , normTwo :: Double
  , normInfinity :: Double
  , euclideanDistance :: Double
  , weightedDistance :: Double
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: StateSpaceGeometryAudit
buildAudit =
  StateSpaceGeometryAudit
    "three_indicator_state_space_geometry_audit"
    "12.000000,4.000000,0.800000"
    "10.000000,5.500000,1.100000"
    "2.000000,-1.500000,-0.300000"
    142.88
    0.988725
    133.04
    3.8
    2.517936
    2.0
    2.517936
    2.33538
    "Distance depends on units, scaling, norm choice, and weights; weighted geometry requires domain justification."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps geometry choices attached to interpretation, instead of reducing state-space comparison to anonymous arithmetic.

Back to top ↑

SQL Workflow: Distance Assumption Registry

SQL can document inner-product, norm, and distance assumptions when state-space geometry supports dashboards, model audits, residual reviews, simulation reports, or institutional decision workflows.

CREATE TABLE state_space_geometry_assumption_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'inner_product',
  'Inner product',
  'Defines alignment, angle, orthogonality, and derived length.',
  'Determines how state directions are compared.',
  'Changing weights, units, or scaling can change geometric conclusions.'
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'norm',
  'Norm',
  'Measures vector magnitude.',
  'Measures state size, residual magnitude, error, or change.',
  'Different norms emphasize different kinds of deviation.'
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'distance',
  'Distance',
  'Applies a norm to the difference between states.',
  'Measures separation between scenarios, observations, or simulations.',
  'Distance is meaningful only when state coordinates are comparable.'
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'weighted_geometry',
  'Weighted geometry',
  'Uses a positive definite matrix to weight directions.',
  'Represents risk, cost, energy, uncertainty, priority, or reliability.',
  'Weights must be justified and documented.'
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'normalization',
  'Normalization',
  'Transforms coordinates to comparable scales.',
  'Reduces unit dominance in distance calculations.',
  'Normalized outputs must be translated back into domain terms.'
);

INSERT INTO state_space_geometry_assumption_registry VALUES
(
  'covariance_distance',
  'Covariance-aware distance',
  'Uses covariance structure to measure unusual deviation.',
  'Accounts for variance and correlation among state variables.',
  'Requires reliable covariance estimation and review.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM state_space_geometry_assumption_registry
ORDER BY assumption_key;

This registry keeps state-space geometry tied to inner products, norms, distance, scaling, weighting, covariance, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports inner-product audits, norm comparisons, state-space distance reports, weighted geometry diagnostics, residual norm records, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Inner products, norms, and distances are powerful because they make state-space comparison precise. They are limited because precision does not guarantee meaning. A distance can be mathematically valid while being substantively inappropriate. A norm can be easy to compute while emphasizing the wrong kind of error. A weighted geometry can represent real priorities, but it can also hide contested assumptions inside a matrix.

Euclidean distance is especially easy to misuse. It assumes coordinates are comparable after encoding. In real systems, variables may differ in units, uncertainty, scale, reliability, cost, risk, and institutional meaning. Normalization may solve one problem while creating another: transformed coordinates are easier to compare but harder to interpret directly.

Responsible use requires documenting the inner product, norm, metric, scaling method, units, weights, covariance assumptions, residual interpretation, thresholds, tolerances, and whether distance is being used for explanation, approximation, anomaly detection, clustering, forecasting, simulation, optimization, or decision support.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Scalars, Vectors, and System States
• Vector Spaces and System Representation
• Span, Linear Independence, and Basis
• Dimension and the Structure of Solution Spaces
• Matrices and the Organization of Multivariable Systems
• Matrix Arithmetic and the Logic of Combination
• Systems of Linear Equations
• Gaussian Elimination and Row Reduction
• Pivot Structure and Solvability
• Rank, Nullity, and Structural Dependence
• Determinants and Invertibility
• Inverse Matrices and Structural Recovery
• Overdetermined Systems and Least Squares Thinking
• Linear Transformations and Model Behavior
• Matrix Multiplication and Interaction Effects
• Change of Basis and Alternative Representations
• Projections, Reflections, and Geometric Interpretation
• Orthogonality and Structured Simplification
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer. Available at: https://linear.axler.net/.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. PDF edition. Stanford University and UCLA. Available at: https://web.stanford.edu/~boyd/vmls/vmls.pdf.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/linearalgebra/.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/matrix-analysis/FDA3627DC2B9F5C3DF2FD8C3CC136B48.
• Julia Documentation (n.d.) Linear Algebra — Julia Standard Library. Julia Documentation. Available at: https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-06sc-linear-algebra-fall-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/.
• Meyer, C.D. (2023) Matrix Analysis and Applied Linear Algebra. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611977448.
• MIT Mathematics (2023) Introduction to Linear Algebra, Sixth Edition. Cambridge, MA: Massachusetts Institute of Technology. Available at: https://math.mit.edu/~gs/linearalgebra/ila6/indexila6.html.
• Netlib (n.d.) BLAS — Basic Linear Algebra Subprograms. Netlib Repository. Available at: https://www.netlib.org/blas/.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage. Netlib Repository. Available at: https://www.netlib.org/lapack/.
• Netlib and SIAM (1999) LAPACK Users’ Guide. 3rd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://www.netlib.org/lapack/lug/.
• NumPy Developers (n.d.) Linear Algebra: numpy.linalg. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/routines.linalg.html.
• SciPy Developers (n.d.) Linear Algebra: scipy.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/linalg.html.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University. Available at: https://www.math.brown.edu/streil/papers/LADW/LADW.html.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin. Available at: https://www.cs.utexas.edu/~flame/laff/laff/LAFF-2.00M.pdf.

Back to top ↑

References

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer. Available at: https://linear.axler.net/.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/linearalgebra/.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/matrix-analysis/FDA3627DC2B9F5C3DF2FD8C3CC136B48.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-06sc-linear-algebra-fall-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/.
• Meyer, C.D. (2023) Matrix Analysis and Applied Linear Algebra. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611977448.
• MIT Mathematics (2023) Introduction to Linear Algebra, Sixth Edition. Cambridge, MA: Massachusetts Institute of Technology. Available at: https://math.mit.edu/~gs/linearalgebra/ila6/indexila6.html.
• Netlib (n.d.) BLAS — Basic Linear Algebra Subprograms. Netlib Repository. Available at: https://www.netlib.org/blas/.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage. Netlib Repository. Available at: https://www.netlib.org/lapack/.
• NumPy Developers (n.d.) Linear Algebra: numpy.linalg. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/routines.linalg.html.
• R Core Team and Matrix Package Authors (n.d.) Matrix: Sparse and Dense Matrix Classes and Methods. CRAN. Available at: https://cran.r-project.org/package=Matrix.
• SciPy Developers (n.d.) Linear Algebra: scipy.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/linalg.html.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University. Available at: https://www.math.brown.edu/streil/papers/LADW/LADW.html.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin. Available at: https://www.cs.utexas.edu/~flame/laff/laff/LAFF-2.00M.pdf.

Back to top ↑