Systems of Linear Equations: How Linear Algebra Models Constraints and Feasible States

Last Updated June 28, 2026

Systems of linear equations explain how linear algebra represents constraints, balance conditions, relationships, unknowns, and feasible states in multivariable systems. A single equation can describe one condition. A system of equations describes many conditions that must hold at the same time.

This article introduces systems of linear equations as one of the central modeling structures in linear algebra. It explains how equations become coefficient matrices, how unknowns become vectors, how right-hand sides represent targets or observed values, and how solution sets describe the states that satisfy modeled constraints.

The central modeling question is not only “Can this system be solved?” It is “What do the equations represent, what assumptions define the constraints, and what does the solution mean in the real system?”

Systems of linear equations appear whenever many conditions must be satisfied together. In infrastructure modeling, equations may describe flow balance, resource limits, or asset constraints. In economics, equations may describe sectoral dependencies, production balances, and demand relationships. In ecology, equations may describe population interactions, resource allocation, or equilibrium conditions. In public policy, equations may organize budgets, targets, indicators, constraints, and tradeoffs.

Linear systems are powerful because they connect algebra, geometry, computation, and interpretation. Algebraically, a system can be written as equations. Geometrically, each equation describes a line, plane, or hyperplane. Computationally, the system becomes a matrix equation. Interpretively, the solution set describes the states that satisfy all modeled conditions.

Why Linear Systems Matter

Linear systems matter because many real-world modeling problems are constraint problems. A system model may ask which values satisfy budgets, flows, conservation rules, capacity limits, policy targets, equilibrium conditions, or measured observations. Linear equations provide one of the simplest and most useful ways to represent such constraints.

A system of linear equations has several equations involving several unknowns. Each equation imposes a condition. A solution must satisfy all conditions at once.

For systems modeling, the unknowns may represent flows, allocations, costs, quantities, states, risks, parameters, sector outputs, intervention levels, or estimated effects. The equations may represent physical balance, accounting identities, conservation rules, measurement equations, planning constraints, or equilibrium conditions.

Linear systems are foundational because they turn a collection of relationships into a structured solution problem.

Back to top ↑

From Equations to Matrix Form

A system of linear equations can be written compactly as a matrix equation. The coefficients become a matrix, the unknowns become a vector, and the right-hand-side constants become another vector.

This form is central to linear algebra. It allows modelers to analyze systems using rank, column spaces, null spaces, solution sets, row operations, matrix factorization, numerical solvers, and sensitivity checks.

The matrix form is compact, but it is not neutral. Every row, column, coefficient, unknown, and right-hand-side value must have a documented modeling meaning.

Back to top ↑

Coefficients, Variables, and Constants

Each linear equation is built from coefficients, variables, and constants. Coefficients describe how strongly each variable contributes to an equation. Variables are the unknown quantities. Constants define the required value of the equation.

In systems modeling, the coefficient may represent a resource requirement, transfer rate, conversion factor, input requirement, probability weight, constraint coefficient, observation weight, or physical relationship. The right-hand side may represent a budget, target, observed quantity, demand level, conservation total, or equilibrium condition.

Correct interpretation depends on units. A coefficient measured in dollars per unit activity cannot be freely combined with a coefficient measured in tons per year unless the model explicitly handles those units.

Back to top ↑

Geometric Interpretation

Every linear equation defines a geometric object. In two variables, a linear equation defines a line. In three variables, it defines a plane. In higher dimensions, it defines a hyperplane. A system of equations asks where these objects intersect.

Geometric interpretation helps explain the three broad types of solution behavior. Lines may intersect at one point, overlap, or remain parallel. Planes may intersect at a point, a line, a plane, or not share a common intersection. Higher-dimensional systems behave similarly, though visualization becomes harder.

Geometry reminds us that solving a system is not just calculating values. It is finding where constraints agree.

Back to top ↑

Consistency, Feasibility, and Solutions

A system is consistent if at least one solution exists. It is inconsistent if no solution exists. In systems modeling, consistency is related to feasibility, but the two are not identical. A mathematically consistent system may still be infeasible in practice if the solution violates physical, legal, ethical, financial, or operational constraints not included in the equations.

For example, a resource-allocation system might have a solution with negative allocation values. Algebraically, the equations are satisfied. Practically, negative allocation may be impossible or meaningless. Similarly, a transportation flow system may satisfy balance equations but exceed road capacity. A budget system may satisfy accounting equations but violate legal restrictions or equity requirements.

Consistency is a mathematical property. Feasibility is a modeling and governance judgment.

Back to top ↑

Unique, No, and Infinitely Many Solutions

A linear system can have one solution, no solution, or infinitely many solutions. These three outcomes have different modeling meanings.

A unique solution means the modeled equations determine one compatible value of the unknown vector. No solution means the equations conflict. Infinitely many solutions mean the equations leave some degrees of freedom unresolved.

A unique solution should not be confused with certainty. It is unique only relative to the modeled equations, data, and assumptions.

Back to top ↑

Homogeneous and Nonhomogeneous Systems

A homogeneous system has the form \(A\mathbf{x}=\mathbf{0}\). A nonhomogeneous system has the form \(A\mathbf{x}=\mathbf{b}\), where \(\mathbf{b}\neq\mathbf{0}\).

Homogeneous systems always have at least the zero solution. They reveal directions of freedom, cancellation, balance, invariance, or dependency. Nonhomogeneous systems ask whether a particular target vector \(\mathbf{b}\) can be produced by linear combinations of the columns of \(A\).

This distinction is important because solution freedom often comes from the homogeneous system. If \(\mathbf{x}_h\) can be added without changing \(A\mathbf{x}\), the model has unresolved degrees of freedom.

Back to top ↑

Rank, Nullity, and Solution Structure

Rank measures the number of independent constraints or independent columns. Nullity measures the dimension of the null space. Together, they help explain solution structure.

Rank helps determine whether the system has enough independent information to identify unknowns. Nullity reveals how many directions remain unconstrained by the equations. In systems modeling, this distinction matters because redundant equations may create an appearance of information without increasing independent constraint.

Rank is not a substitute for model adequacy. A full-rank system can still be based on poor data, unrealistic equations, incomplete variables, or invalid assumptions.

Back to top ↑

Augmented Matrices

An augmented matrix places the coefficient matrix and right-hand-side vector together. It is commonly used for row reduction, consistency checks, and solution analysis.

The augmented matrix is not merely a computational convenience. It reminds modelers that consistency depends on both \(A\) and \(\mathbf{b}\). The same coefficient matrix may be consistent for one right-hand side and inconsistent for another.

The augmented form is the bridge from equation listing to systematic solution methods.

Back to top ↑

Row Operations and Equivalent Systems

Row operations transform a system into an equivalent system with the same solution set. They are the foundation of Gaussian elimination and row reduction.

Elementary row operations include swapping rows, multiplying a row by a nonzero scalar, and adding a multiple of one row to another. These operations preserve the set of solutions because they replace equations with equivalent combinations of the original equations.

Row operations are mathematical transformations. Their outputs still require interpretation: pivots, free variables, contradictions, and dependencies should be connected back to the modeled system.

Back to top ↑

Underdetermined and Overdetermined Systems

A system is underdetermined when it has fewer independent constraints than unknowns. It is overdetermined when it has more equations than unknowns. These terms describe structure, but they do not fully determine solution behavior.

An underdetermined system often has infinitely many solutions if it is consistent. An overdetermined system may have no exact solution if equations conflict, but it may also have a unique solution if many equations are redundant or compatible. Least squares methods are often used when overdetermined systems cannot be solved exactly.

Equation count is only the surface. Rank, consistency, data quality, and interpretation determine what the system actually says.

Back to top ↑

Systems Modeling Interpretation

Systems of linear equations are a disciplined way to represent simultaneous constraints. They help modelers ask which states satisfy all modeled conditions, whether targets are compatible with assumptions, whether equations are redundant, and whether some degrees of freedom remain unresolved.

The same mathematical form can represent many modeling situations: balance equations, budget constraints, network flows, input-output systems, calibration problems, conservation laws, estimated relationships, and equilibrium conditions. But the equation form does not guarantee that the model is adequate. Linear systems simplify reality by assuming proportional, additive relationships among variables.

A responsible interpretation should explain what each equation means, why the variables were chosen, what units are used, what the right-hand side represents, whether solutions are feasible, whether omitted constraints matter, and whether the solution should be treated as exact, approximate, conditional, or illustrative.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Systems of linear equations connect matrix equations, column spaces, null spaces, rank conditions, augmented matrices, row reduction, solution sets, affine spaces, and computational linear algebra.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for linear systems should document the coefficient matrix, right-hand-side vector, unknown definitions, equation meanings, units, rank checks, consistency status, solution behavior, and feasibility warnings. A solver should not merely return numbers. It should also report what those numbers mean and whether the modeled system is well-posed.

The companion repository treats systems of linear equations as auditable modeling structures. 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 checking matrix shape, rank, augmented rank, consistency, and solution behavior.

Back to top ↑

Python Workflow: Linear System Audit

The Python workflow below audits a small linear system by recording coefficient shape, rank, augmented rank, consistency, and solution behavior.

from __future__ import annotations

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


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


@dataclass(frozen=True)
class LinearSystemAudit:
    system_name: str
    equation_count: int
    unknown_count: int
    coefficient_rank: int
    augmented_rank: int
    consistent: bool
    solution_behavior: str
    row_meaning: str
    column_meaning: str
    right_hand_side_meaning: str
    interpretation_warning: str


def matrix_rank(matrix: Matrix, tolerance: float = 1e-10) -> int:
    rows = [row[:] for row in matrix]
    row_count = len(rows)
    column_count = len(rows[0]) if rows else 0
    rank = 0

    for column in range(column_count):
        pivot = None
        for row in range(rank, row_count):
            if abs(rows[row][column]) > tolerance:
                pivot = row
                break

        if pivot is None:
            continue

        rows[rank], rows[pivot] = rows[pivot], rows[rank]
        pivot_value = rows[rank][column]
        rows[rank] = [value / pivot_value for value in rows[rank]]

        for row in range(row_count):
            if row != rank:
                factor = rows[row][column]
                rows[row] = [
                    current - factor * pivot_current
                    for current, pivot_current in zip(rows[row], rows[rank])
                ]

        rank += 1

    return rank


def augment(A: Matrix, b: Vector) -> Matrix:
    return [row + [rhs] for row, rhs in zip(A, b)]


def classify_solution_behavior(A: Matrix, b: Vector) -> tuple[bool, str, int, int]:
    coefficient_rank = matrix_rank(A)
    augmented_rank = matrix_rank(augment(A, b))
    unknown_count = len(A[0]) if A else 0

    if coefficient_rank != augmented_rank:
        return False, "no solution", coefficient_rank, augmented_rank

    if coefficient_rank == unknown_count:
        return True, "unique solution", coefficient_rank, augmented_rank

    return True, "infinitely many solutions", coefficient_rank, augmented_rank


def build_audit() -> LinearSystemAudit:
    A = [
        [1.0, 1.0, 0.0],
        [0.0, 1.0, 1.0],
        [1.0, 0.0, 1.0],
    ]
    b = [100.0, 80.0, 90.0]

    consistent, behavior, rank_a, rank_aug = classify_solution_behavior(A, b)

    return LinearSystemAudit(
        system_name="three_constraint_resource_balance_system",
        equation_count=len(A),
        unknown_count=len(A[0]),
        coefficient_rank=rank_a,
        augmented_rank=rank_aug,
        consistent=consistent,
        solution_behavior=behavior,
        row_meaning="resource balance constraints",
        column_meaning="unknown allocation levels",
        right_hand_side_meaning="required total resource targets",
        interpretation_warning=(
            "The linear system may be algebraically consistent, but practical feasibility "
            "also requires nonnegative allocations, capacity limits, and policy constraints."
        ),
    )


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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Linear system audit complete.")

This workflow treats solving as interpretation-aware computation. It checks consistency and solution behavior, but it also records what the equations and unknowns represent.

Back to top ↑

R Workflow: Consistency and Rank Check

R can support linear system checks, rank diagnostics, and reproducible audit records. The workflow below compares coefficient rank and augmented rank.

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

b <- c(100, 80, 90)

augmented <- cbind(A, b)

rank_A <- qr(A)$rank
rank_augmented <- qr(augmented)$rank
unknown_count <- ncol(A)

consistent <- rank_A == rank_augmented

solution_behavior <- if (!consistent) {
  "no solution"
} else if (rank_A == unknown_count) {
  "unique solution"
} else {
  "infinitely many solutions"
}

audit_record <- data.frame(
  system_name = "three_constraint_resource_balance_system",
  equation_count = nrow(A),
  unknown_count = unknown_count,
  coefficient_rank = rank_A,
  augmented_rank = rank_augmented,
  consistent = consistent,
  solution_behavior = solution_behavior,
  row_meaning = "resource balance constraints",
  column_meaning = "unknown allocation levels",
  right_hand_side_meaning = "required total resource targets",
  interpretation_warning = paste(
    "Algebraic consistency does not guarantee practical feasibility;",
    "nonnegative allocations, capacity limits, and policy constraints must also be reviewed."
  )
)

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

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

print(audit_record)

This workflow is useful when linear systems support resource planning, calibration, public reporting, scientific computing, or policy analysis.

Back to top ↑

Haskell Workflow: Typed Linear System Records

Haskell can represent linear system audits with explicit fields for equation count, unknown count, consistency, solution behavior, equation meaning, and interpretation warning.

module Main where

data LinearSystemAudit = LinearSystemAudit
  { systemName :: String
  , equationCount :: Int
  , unknownCount :: Int
  , coefficientRank :: Int
  , augmentedRank :: Int
  , consistent :: Bool
  , solutionBehavior :: String
  , rowMeaning :: String
  , columnMeaning :: String
  , rightHandSideMeaning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: LinearSystemAudit
buildAudit =
  LinearSystemAudit
    "three_constraint_resource_balance_system"
    3
    3
    3
    3
    True
    "unique solution"
    "resource balance constraints"
    "unknown allocation levels"
    "required total resource targets"
    "Algebraic consistency does not guarantee practical feasibility."

main :: IO ()
main =
  print buildAudit

The typed workflow makes the model record explicit. The system is not only a coefficient table; it is a claim about constraints, unknowns, targets, and feasible interpretation.

Back to top ↑

SQL Workflow: Linear System Assumption Registry

SQL can document linear system assumptions when systems of equations support dashboards, planning workflows, optimization pipelines, risk models, scientific computation, or institutional reports.

CREATE TABLE linear_system_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 linear_system_assumption_registry VALUES
(
  'coefficient_matrix',
  'Coefficient matrix',
  'Stores coefficients of unknown variables in each equation.',
  'Defines how modeled variables contribute to constraints, observations, or balances.',
  'Coefficients must have documented units, source, and interpretation.'
);

INSERT INTO linear_system_assumption_registry VALUES
(
  'unknown_vector',
  'Unknown vector',
  'Stores variables to be solved for.',
  'Represents allocations, flows, parameters, outputs, or system states.',
  'Algebraic values may require practical constraints such as nonnegativity or capacity limits.'
);

INSERT INTO linear_system_assumption_registry VALUES
(
  'right_hand_side',
  'Right-hand-side vector',
  'Stores constants, observations, or targets.',
  'Represents demand, budget, total, observed value, or required balance.',
  'Targets may be uncertain, contested, infeasible, or measured with error.'
);

INSERT INTO linear_system_assumption_registry VALUES
(
  'consistency',
  'Consistency',
  'Indicates whether at least one solution exists.',
  'Shows whether modeled constraints can be satisfied together.',
  'Consistency does not prove real-world feasibility or model adequacy.'
);

INSERT INTO linear_system_assumption_registry VALUES
(
  'rank_condition',
  'Rank condition',
  'Compares coefficient rank and augmented rank.',
  'Reveals whether equations are independent, redundant, or contradictory.',
  'Rank should be interpreted alongside equation meaning and data quality.'
);

INSERT INTO linear_system_assumption_registry VALUES
(
  'solution_behavior',
  'Solution behavior',
  'Classifies the system as having no solution, one solution, or infinitely many solutions.',
  'Helps identify conflict, determinacy, or remaining degrees of freedom.',
  'A unique solution is conditional on the modeled assumptions and should not be equated with certainty.'
);

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

This registry keeps the linear system tied to coefficients, unknowns, right-hand-side targets, rank, consistency, solution behavior, and feasibility review.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports linear system audits, coefficient matrix checks, augmented matrix diagnostics, rank comparisons, consistency classification, solution behavior reports, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Systems of linear equations are powerful because they make simultaneous constraints explicit. They are limited because they assume that relationships are linear, additive, and sufficiently represented by the chosen variables and equations. Real systems may include thresholds, nonlinear feedback, uncertainty, institutional constraints, behavioral responses, missing variables, and distributional concerns that the linear system does not capture.

A consistent system is not necessarily feasible. A unique solution is not necessarily correct. An inconsistent system is not necessarily useless; it may reveal conflict among assumptions, observations, targets, or constraints. An underdetermined system is not necessarily weak; it may honestly reveal flexibility or missing information. An overdetermined system is not necessarily overbuilt; it may reflect noisy measurements that require approximation.

Responsible use requires documenting equation meaning, variable meaning, coefficient units, right-hand-side interpretation, data sources, omitted constraints, feasibility conditions, uncertainty, and the difference between algebraic solution and real-world decision.

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
• 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/.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/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/.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• National Institute of Standards and Technology (n.d.) Matrix Market. NIST Mathematical and Computational Sciences Division. Available at: https://math.nist.gov/MatrixMarket/.
• National Institute of Standards and Technology (n.d.) Matrix Market File Formats. NIST Mathematical and Computational Sciences Division. Available at: https://math.nist.gov/MatrixMarket/formats.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.) Sparse Arrays: scipy.sparse. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/sparse.html.
• SciPy Developers (n.d.) Sparse Linear Algebra: scipy.sparse.linalg. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/sparse.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.
• Julia Documentation (n.d.) Linear Algebra — Julia Standard Library. Julia Documentation. Available at: https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/.
• MATLAB Documentation (n.d.) Systems of Linear Equations. MathWorks Documentation. Available at: https://www.mathworks.com/help/matlab/math/systems-of-linear-equations.html.
• MATLAB Documentation (n.d.) Linear Algebra. MathWorks Documentation. Available at: https://www.mathworks.com/help/matlab/linear-algebra.html.

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/.
• Cayley, A. (1858) A Memoir on the Theory of Matrices. London. Available at: https://archive.org/details/theoryofmatrices00cullrich.
• 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/.
• 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/.
• MATLAB Documentation (n.d.) Systems of Linear Equations. MathWorks Documentation. Available at: https://www.mathworks.com/help/matlab/math/systems-of-linear-equations.html.
• 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.
• National Institute of Standards and Technology (n.d.) Matrix Market. NIST Mathematical and Computational Sciences Division. Available at: https://math.nist.gov/MatrixMarket/.
• 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 ↑