Overdetermined Systems and Least Squares Thinking: How Linear Algebra Models Approximation

Last Updated June 28, 2026

Overdetermined systems and least squares thinking explain how linear algebra handles models with more constraints, measurements, or observations than unknowns. In exact linear systems, the goal is often to find a vector that satisfies every equation. In empirical systems, scientific computing, calibration, regression, and decision support, the more common question is different: what should we do when all equations cannot be satisfied at once?

This article introduces overdetermined systems as linear systems where the number of equations exceeds the number of unknowns. It connects inconsistency, residuals, approximation, least squares, normal equations, projections, rank, column space, measurement error, calibration, regression, numerical stability, QR decomposition, singular value decomposition, and responsible interpretation.

The central modeling question is not only “Can this system be solved exactly?” It is “What is the most defensible approximation when the system contains more information, noise, conflict, or constraints than an exact solution can satisfy?”

Overdetermined systems appear when a model has more equations than unknowns. Sometimes that means the system is redundant but consistent. More often, especially with real data, measurements conflict slightly or substantially. Exact solutions disappear, but useful modeling does not end. Least squares thinking provides a principled way to choose an approximate solution by minimizing residual error.

For systems modeling, this is a major transition. Earlier articles focused on exact solvability, pivots, rank, determinants, and inverse recovery. This article moves toward empirical modeling: calibration, regression, parameter estimation, measurement error, model fitting, residual analysis, and approximation under uncertainty.

Why Overdetermined Systems Matter

Overdetermined systems matter because real models often contain more evidence than unknowns. Sensors provide repeated measurements. Surveys provide many observations. Economic data include many sector records. Infrastructure systems contain multiple balance checks. Ecological models combine many field measurements. Regression models fit parameters from many cases.

When equations outnumber unknowns, exact consistency becomes less likely. A system may contain noise, measurement error, rounding, missing variables, incompatible assumptions, or true structural conflict. Least squares thinking gives linear algebra a way to work with imperfection without pretending that every equation can be satisfied exactly.

This shift is central to systems modeling. It moves linear algebra from exact structure into empirical judgment: how much error remains, where it appears, whether it is acceptable, and what it says about the model.

Overdetermination is not a defect. It is often what makes empirical modeling possible.

Back to top ↑

What Is an Overdetermined System?

An overdetermined linear system has more equations than unknowns. In matrix form, this means the coefficient matrix \(A\) has more rows than columns.

Overdetermined systems often arise when rows represent observations and columns represent parameters. Each row contributes one equation. The unknown vector contains the parameters or quantities being estimated. When many observations are used to estimate a smaller number of unknowns, the system becomes overdetermined.

The key point is that extra equations provide information, but they also create the possibility of conflict. Least squares thinking asks how to use that information responsibly.

Back to top ↑

Exact Solutions and Inconsistency

An exact solution exists only if the right-hand side vector \(\mathbf{b}\) lies in the column space of \(A\). In overdetermined systems, this condition can fail easily because \(\mathbf{b}\) may contain measurement noise or conflicting observations.

If \(\mathbf{b}\notin\operatorname{Col}(A)\), no choice of \(\mathbf{x}\) can satisfy every equation. The model must then choose an approximate solution. This does not necessarily mean the model is useless. It means exact equality is not the right standard for the available data.

Inconsistency is not merely a problem to minimize. It is evidence to interpret.

Back to top ↑

Residuals

A residual is the difference between the observed right-hand side and the value predicted by the model. If \(\hat{\mathbf{x}}\) is an approximate solution, the residual vector is:

Residuals are central to least squares thinking because they preserve information about misfit. A small residual norm may suggest a useful approximation. A large residual norm may indicate poor fit. A structured residual pattern may reveal missing variables, biased measurements, nonlinear behavior, or violated assumptions.

Residuals are not leftovers to ignore. They are part of the model’s evidence.

Back to top ↑

Least Squares Thinking

Least squares chooses the vector \(\hat{\mathbf{x}}\) that minimizes the sum of squared residuals. Instead of requiring \(A\mathbf{x}=\mathbf{b}\), it seeks the closest possible approximation in the column space of \(A\).

The squared-error criterion has mathematical advantages. It is differentiable, geometrically connected to orthogonal projection, and computationally tractable. It also carries assumptions and values: large errors are penalized heavily, outliers can dominate, and minimizing squared error is not always the same as making the most responsible decision.

Least squares is not simply a technique. It is a way of turning inconsistency into a structured approximation problem.

Back to top ↑

Column Space and Projection

The geometric meaning of least squares is projection. When \(\mathbf{b}\) is not in the column space of \(A\), least squares finds the point in \(\operatorname{Col}(A)\) closest to \(\mathbf{b}\). That point is \(A\hat{\mathbf{x}}\).

The residual vector is orthogonal to the column space. This means the remaining error has no component that can be further reduced by changing \(\mathbf{x}\).

This projection interpretation connects least squares to the next part of the series: linear transformations, geometric structure, and model behavior.

Back to top ↑

Normal Equations

The normal equations arise from the orthogonality condition. Since the least-squares residual is orthogonal to every column of \(A\), we have:

This gives the normal equations:

If \(A\) has full column rank, \(A^TA\) is invertible and the least-squares solution is unique:

In numerical computation, however, normal equations can amplify conditioning problems. QR or SVD methods are often preferred for stability, especially in ill-conditioned systems.

The normal equations are mathematically central, but not always computationally ideal.

Back to top ↑

Rank and Identifiability

Rank determines whether the least-squares solution is unique and whether parameters are identifiable. In an overdetermined system with \(A\in\mathbb{R}^{m\times n}\), full column rank means \(\operatorname{rank}(A)=n\). In that case, the columns of \(A\) are independent and the least-squares solution is unique.

If columns are dependent, multiple parameter vectors may produce the same fitted values. The model may still predict, but individual coefficients may not be separately interpretable.

Least squares should therefore be paired with rank diagnostics. Without them, a fitted solution may conceal non-identifiability.

Back to top ↑

Least Squares and Regression

Linear regression is one of the most widely used forms of least squares. Rows represent observations, columns represent predictors, and unknowns represent coefficients. The fitted model chooses coefficients that minimize squared prediction errors.

Regression connects linear algebra to empirical modeling, but it adds statistical assumptions. Least squares can compute a best fit without guaranteeing causality, unbiasedness, valid uncertainty estimates, or policy relevance. The matrix calculation is only part of the reasoning.

Least squares provides the algebraic foundation. Responsible regression requires statistical and substantive judgment.

Back to top ↑

Weighted and Constrained Least Squares

Ordinary least squares treats all residuals equally. In many systems, that is not appropriate. Some measurements are more reliable than others. Some errors have different units. Some observations represent larger populations. Some decisions must satisfy constraints.

Weighted least squares modifies the objective by assigning weights to residuals:

Constrained least squares adds restrictions on the solution, such as nonnegativity, conservation rules, capacity limits, budget constraints, or physical feasibility.

The least-squares objective encodes values about error, reliability, and feasibility. Those values should be explicit.

Back to top ↑

Numerical Methods: QR, SVD, and Stability

Least-squares problems can be solved in several ways. The normal equations are conceptually important, but QR decomposition and singular value decomposition are often more reliable for computation.

Numerical method choice is not merely technical. It affects stability, interpretability, reproducibility, and trust.

Serious least-squares workflows should document the solver used, rank estimate, condition estimate, residual norm, scaling choices, and tolerance assumptions.

Back to top ↑

Systems Modeling Interpretation

Overdetermined systems are central to empirical systems modeling. They appear when many observations are used to estimate a smaller number of parameters, when repeated measurements are used to calibrate a model, when competing constraints cannot all be satisfied, or when noisy data must be reconciled with a structured representation.

In infrastructure modeling, least squares can estimate unknown flows from many partial measurements. In ecological modeling, it can calibrate interaction parameters from field observations. In economic modeling, it can fit sector relationships or demand coefficients. In climate and energy modeling, it can reconcile sensor readings, simulations, and constraints. In policy analysis, it can fit indicators while revealing where the model fails to explain observed outcomes.

Responsible interpretation should document residuals, rank, conditioning, scaling, weighting, outliers, uncertainty, omitted variables, and whether least squares is being used for prediction, explanation, calibration, reconstruction, or decision support.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Overdetermined systems and least squares connect projections, orthogonality, column spaces, normal equations, QR factorization, singular value decomposition, pseudoinverses, condition numbers, statistical regression, constrained optimization, and inverse-problem regularization.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for overdetermined systems and least squares should document the matrix shape, row meanings, column meanings, rank, condition estimate, solver method, residual norm, fitted values, weighting choices, tolerance rules, and interpretation warnings. A least-squares fit should not appear without residual review.

The companion repository treats least-squares approximation as auditable mathematical 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 systems modeling.

For this article, the computational examples focus on residuals, least-squares solutions, fitted values, rank checks, condition warnings, and model-governance records.

Back to top ↑

Python Workflow: Least Squares Audit

The Python workflow below solves a small overdetermined system using normal-equation logic for transparency, records the fitted values, residual vector, residual norm, and interpretation warnings.

from __future__ import annotations

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


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


@dataclass(frozen=True)
class LeastSquaresAudit:
    system_name: str
    row_count: int
    column_count: int
    overdetermined: bool
    rank: int
    solution: str
    fitted_values: str
    residuals: str
    residual_norm: float
    solver_method: str
    interpretation_warning: str


def transpose(A: Matrix) -> Matrix:
    return [list(row) for row in zip(*A)]


def matmul(A: Matrix, B: Matrix) -> Matrix:
    return [
        [sum(a * b for a, b in zip(row, col)) for col in zip(*B)]
        for row in A
    ]


def matvec(A: Matrix, x: Vector) -> Vector:
    return [sum(a * b for a, b in zip(row, x)) for row in A]


def solve_2x2(A: Matrix, b: Vector) -> Vector:
    det = A[0][0] * A[1][1] - A[0][1] * A[1][0]
    if abs(det) <= 1e-12:
        raise ValueError("Normal-equation matrix is singular or ill-conditioned.")
    return [
        (b[0] * A[1][1] - A[0][1] * b[1]) / det,
        (A[0][0] * b[1] - b[0] * A[1][0]) / det,
    ]


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


def build_audit() -> LeastSquaresAudit:
    A = [
        [1.0, 1.0],
        [1.0, 2.0],
        [1.0, 3.0],
        [1.0, 4.0],
    ]
    b = [2.0, 2.9, 4.1, 5.1]

    At = transpose(A)
    AtA = matmul(At, A)
    Atb = matvec(At, b)
    solution = solve_2x2(AtA, Atb)
    fitted = matvec(A, solution)
    residuals = [observed - fit for observed, fit in zip(b, fitted)]
    residual_norm = norm2(residuals)

    return LeastSquaresAudit(
        system_name="four_observation_linear_calibration",
        row_count=len(A),
        column_count=len(A[0]),
        overdetermined=len(A) > len(A[0]),
        rank=2,
        solution=",".join(f"{value:.6f}" for value in solution),
        fitted_values=",".join(f"{value:.6f}" for value in fitted),
        residuals=",".join(f"{value:.6f}" for value in residuals),
        residual_norm=round(residual_norm, 12),
        solver_method="normal equations for transparent teaching example; use QR or SVD for robust numerical workflows",
        interpretation_warning=(
            "Least squares minimizes squared residuals; fit quality, residual patterns, "
            "scaling, rank, conditioning, and model purpose still require review."
        ),
    )


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" / "least_squares_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" / "least_squares_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Least squares audit complete.")

This workflow treats least squares as a documented approximation. It records the solution, fitted values, residuals, residual norm, solver method, and interpretation warning.

Back to top ↑

R Workflow: Residual and Fit Diagnostics

R can support overdetermined-system analysis through least-squares fitting, residual diagnostics, rank checks, and model-audit outputs.

A <- matrix(
  c(
    1, 1,
    1, 2,
    1, 3,
    1, 4
  ),
  nrow = 4,
  byrow = TRUE
)

b <- c(2.0, 2.9, 4.1, 5.1)

fit <- lm.fit(A, b)
solution <- fit$coefficients
fitted_values <- as.vector(A %*% solution)
residuals <- b - fitted_values
residual_norm <- sqrt(sum(residuals^2))
rank_A <- qr(A)$rank

audit_record <- data.frame(
  system_name = "four_observation_linear_calibration",
  row_count = nrow(A),
  column_count = ncol(A),
  overdetermined = nrow(A) > ncol(A),
  rank = rank_A,
  solution = paste(round(solution, 6), collapse = ","),
  fitted_values = paste(round(fitted_values, 6), collapse = ","),
  residuals = paste(round(residuals, 6), collapse = ","),
  residual_norm = residual_norm,
  solver_method = "R lm.fit QR-based least-squares workflow",
  interpretation_warning = paste(
    "Least squares fit should be reviewed with residuals,",
    "rank, conditioning, scaling, and model purpose."
  )
)

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

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

print(audit_record)

This R workflow is useful when least squares supports regression, calibration, measurement reconciliation, scientific modeling, or decision support.

Back to top ↑

Haskell Workflow: Typed Least Squares Records

Haskell can represent a least-squares audit as a typed record with fields for system shape, rank, solution, fitted values, residuals, residual norm, solver method, and interpretation warning.

module Main where

data LeastSquaresAudit = LeastSquaresAudit
  { systemName :: String
  , rowCount :: Int
  , columnCount :: Int
  , overdetermined :: Bool
  , rankValue :: Int
  , solution :: String
  , fittedValues :: String
  , residuals :: String
  , residualNorm :: Double
  , solverMethod :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: LeastSquaresAudit
buildAudit =
  LeastSquaresAudit
    "four_observation_linear_calibration"
    4
    2
    True
    2
    "0.900000,1.030000"
    "1.930000,2.960000,3.990000,5.020000"
    "0.070000,-0.060000,0.110000,0.080000"
    0.165831
    "normal equations teaching record; QR or SVD preferred for robust workflows"
    "Least squares minimizes residuals, but residual meaning depends on model purpose."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps approximation results attached to diagnostics rather than treating coefficients as self-explanatory outputs.

Back to top ↑

SQL Workflow: Approximation Assumption Registry

SQL can document least-squares assumptions when approximation workflows support dashboards, planning systems, scientific-computing pipelines, regression outputs, calibration records, or institutional reports.

CREATE TABLE least_squares_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 least_squares_assumption_registry VALUES
(
  'overdetermined_system',
  'Overdetermined system',
  'A linear system with more equations than unknowns.',
  'Represents many observations, measurements, or constraints used to estimate fewer unknowns.',
  'Extra equations may improve evidence or expose inconsistency.'
);

INSERT INTO least_squares_assumption_registry VALUES
(
  'residual',
  'Residual',
  'The difference between observed and fitted values.',
  'Shows what the model fails to satisfy or explain.',
  'Residual patterns should be reviewed, not merely minimized.'
);

INSERT INTO least_squares_assumption_registry VALUES
(
  'least_squares_objective',
  'Least-squares objective',
  'Minimizes the squared Euclidean norm of residuals.',
  'Chooses the best squared-error approximation under the model.',
  'Squared-error loss may not match every decision or error structure.'
);

INSERT INTO least_squares_assumption_registry VALUES
(
  'projection',
  'Projection',
  'Maps the observed vector to the closest point in the column space.',
  'Shows the closest output the model can produce.',
  'Distance depends on scaling, weighting, and norm choice.'
);

INSERT INTO least_squares_assumption_registry VALUES
(
  'normal_equations',
  'Normal equations',
  'The system A transpose A x equals A transpose b.',
  'Connects least squares to residual orthogonality.',
  'Normal equations may worsen conditioning in numerical workflows.'
);

INSERT INTO least_squares_assumption_registry VALUES
(
  'qr_or_svd',
  'QR or SVD solver',
  'Factorization-based methods for stable least-squares computation.',
  'Support rank, conditioning, and residual diagnostics.',
  'Solver choice should be documented for reproducibility.'
);

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

This registry keeps least-squares approximation tied to residuals, projection, rank, conditioning, solver choice, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports overdetermined-system audits, least-squares diagnostics, residual reports, fitted-value outputs, rank checks, conditioning warnings, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Least squares is powerful because it gives overdetermined and inconsistent systems a principled approximation strategy. It is limited because minimizing squared residuals is not the same as validating a model. A least-squares solution can fit poorly, fit well for the wrong reasons, conceal omitted variables, amplify scale choices, overreact to outliers, or produce coefficients that are not substantively meaningful.

A small residual does not prove causality. A high rank does not guarantee conceptual adequacy. A stable solver does not validate the data. A fitted coefficient does not automatically become a policy lever. A model that minimizes error under one norm may be inappropriate under another decision context.

Responsible use requires documenting matrix construction, row and column meanings, residuals, rank, conditioning, solver method, weights, scaling, outliers, uncertainty, and the difference between approximation, prediction, explanation, calibration, and 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
• 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.
• Björck, Å. (1996) Numerical Methods for Least Squares Problems. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611971484.
• 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.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning: Data Mining, Inference, and Prediction. 2nd edn. New York: Springer. Available at: https://hastie.su.domains/ElemStatLearn/.
• 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/.
• 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.
• SciPy Developers (n.d.) Linear Least Squares: scipy.linalg.lstsq. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lstsq.html.
• SciPy Developers (n.d.) Moore-Penrose Pseudoinverse: scipy.linalg.pinv. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.pinv.html.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• 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.
• 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.
• Julia Documentation (n.d.) Linear Algebra — Julia Standard Library. Julia Documentation. Available at: https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/.

Back to top ↑

References

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer. Available at: https://linear.axler.net/.
• Björck, Å. (1996) Numerical Methods for Least Squares Problems. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611971484.
• 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.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning: Data Mining, Inference, and Prediction. 2nd edn. New York: Springer. Available at: https://hastie.su.domains/ElemStatLearn/.
• 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.
• 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.
• SciPy Developers (n.d.) Linear Least Squares: scipy.linalg.lstsq. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lstsq.html.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/linearalgebra/.
• 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.

Back to top ↑