Gaussian Elimination and Row Reduction: How Linear Algebra Simplifies Constraint Systems

Last Updated June 28, 2026

Gaussian elimination and row reduction explain how linear algebra solves systems of equations by transforming them into simpler equivalent systems. The method does not merely “do algebra faster.” It reveals pivots, free variables, contradictions, redundancy, rank, consistency, and the structure of solution spaces.

This article introduces Gaussian elimination as a systematic procedure for simplifying linear systems and row reduction as the broader logic of transforming augmented matrices while preserving their solution sets. It connects elementary row operations, echelon form, reduced echelon form, pivot columns, rank, consistency, back substitution, numerical caution, and modeling interpretation.

The central modeling question is not only “Can we row-reduce this matrix?” It is “What do the pivots, free variables, zero rows, and contradictions reveal about the modeled system?”

Gaussian elimination is one of the most important algorithms in linear algebra. It transforms a system of linear equations into an equivalent system that is easier to solve. Row reduction extends this idea by using elementary row operations to reveal the internal structure of a matrix or augmented matrix.

In systems modeling, Gaussian elimination is more than a computational tool. It helps identify whether constraints are independent, whether targets conflict, whether variables are determined, whether degrees of freedom remain, and whether a model is underdetermined, overdetermined, or inconsistent. The algorithm exposes the structure of the system.

Why Gaussian Elimination Matters

Gaussian elimination matters because systems of linear equations can quickly become too complex to solve by inspection. The method gives a reliable procedure for simplifying equations without changing their solution set. It replaces a complicated system with an equivalent system whose solution behavior is easier to see.

The central idea is to eliminate variables from equations step by step. By using one equation to remove a variable from another equation, the system gradually becomes triangular or echelon-shaped. Once the system is simplified, solutions can often be found by back substitution.

For systems modeling, the elimination process is also diagnostic. It can show which equations are independent, which equations are redundant, which variables are controlled by constraints, and which variables remain free.

Gaussian elimination is therefore both an algorithm and a lens for understanding modeled constraints.

Back to top ↑

The Augmented Matrix View

Gaussian elimination is usually performed on an augmented matrix. The left side contains the coefficient matrix \(A\). The right side contains the vector \(\mathbf{b}\). Together, they represent the full system \(A\mathbf{x}=\mathbf{b}\).

The augmented matrix view is useful because it separates the equation structure from the variable symbols. Row operations can then focus on the coefficient and right-hand-side values. However, the modeler should not forget what each row and column means.

The augmented matrix makes elimination efficient, but interpretation still requires the original model context.

Back to top ↑

Elementary Row Operations

Gaussian elimination uses elementary row operations. These operations transform a system into an equivalent system, meaning the solution set is unchanged.

These operations are valid because they preserve the logical content of the equation system. Reordering equations does not change the solution. Multiplying an equation by a nonzero constant does not change the values that satisfy it. Adding a multiple of one equation to another replaces a constraint with an equivalent derived constraint.

Row operations are algebraically safe when performed correctly. Modeling errors arise when the resulting structure is interpreted without remembering the meaning of the original equations.

Back to top ↑

Echelon Form

Gaussian elimination usually aims first for row echelon form. In echelon form, nonzero rows appear above zero rows, each leading entry is to the right of the leading entry above it, and entries below each pivot are zero.

Echelon form reveals the pivot structure of the system. Each pivot marks an independent constraint direction. The number of pivot rows gives the rank. If the augmented matrix contains a row such as \(0=1\), the system is inconsistent.

Echelon form is usually enough for solving by back substitution. Reduced row echelon form goes further by making the solution structure even clearer.

Back to top ↑

Reduced Row Echelon Form

Reduced row echelon form, often abbreviated RREF, is a more fully simplified matrix form. In RREF, each pivot is 1, each pivot is the only nonzero entry in its column, zero rows appear at the bottom, and pivots move right as rows descend.

RREF is especially useful for identifying solution structure when free variables exist. It can show which variables are pivot variables, which are free variables, and how pivot variables depend on free variables.

RREF is not always the most numerically stable way to solve large systems, but conceptually it is one of the clearest tools for understanding solution structure.

Back to top ↑

Pivots and Free Variables

Pivots are the central structural markers in row reduction. A pivot indicates that a column contributes independent information. Variables corresponding to pivot columns are pivot variables. Variables corresponding to non-pivot columns are free variables.

In systems modeling, pivots and free variables have substantive meaning. A pivot variable may represent an allocation or flow determined by the model. A free variable may represent flexibility, ambiguity, missing information, or a decision variable that requires an additional criterion.

Pivots are mathematical objects, but they help diagnose real modeling structure: what is determined, what is redundant, and what remains unresolved.

Back to top ↑

Back Substitution

Back substitution solves an upper triangular or echelon system by starting with the last equation and working upward. Once a later variable is known, it can be substituted into earlier equations.

Back substitution works because the simplified equations have fewer unknowns in lower rows. The last equation may determine the last variable. That value then helps determine the previous variable, and so on.

Back substitution is straightforward in exact arithmetic. In numerical computing, small pivots, rounding error, and ill-conditioning can complicate results.

Back to top ↑

Rank and Consistency

Row reduction is one of the clearest ways to determine rank and consistency. The rank of a matrix is the number of pivot positions. A system \(A\mathbf{x}=\mathbf{b}\) is consistent when the rank of \(A\) equals the rank of the augmented matrix \([A\mid \mathbf{b}]\).

If the augmented matrix has a pivot in the right-hand-side column that does not correspond to a coefficient pivot, the system is inconsistent. This means the modeled target vector cannot be produced by the modeled coefficient relationships.

Rank is a powerful diagnostic. It tells us about independent structure, not whether the model is realistic, complete, ethical, or well-measured.

Back to top ↑

Detecting Redundancy and Contradiction

Row reduction reveals redundancy and contradiction. A redundant equation reduces to a zero row with a zero right-hand side. A contradictory equation reduces to a zero row with a nonzero right-hand side.

This distinction is important in modeling. Redundancy is not always bad. It may reflect repeated measurement, accounting structure, conservation logic, or deliberate verification. Contradiction is also not always useless. It may reveal data errors, impossible targets, incompatible assumptions, or a missing variable.

Row reduction is useful because it makes hidden structure visible. That structure must then be interpreted in the context of the model.

Back to top ↑

Underdetermined, Overdetermined, and Square Systems

Gaussian elimination applies to square, underdetermined, and overdetermined systems. The number of equations and unknowns gives a starting point, but rank determines the actual solution behavior.

A square system may have a unique solution, no solution, or infinitely many solutions. An underdetermined system often has free variables if it is consistent. An overdetermined system may have no exact solution if constraints conflict, but it may also have an exact solution when equations are compatible or redundant.

Equation count is never the whole story. Row reduction reveals the independent structure hidden beneath the surface dimensions.

Back to top ↑

Numerical Row Reduction

In exact arithmetic, row reduction is clean. In numerical computing, rounding error, small pivots, scaling problems, and ill-conditioning can affect results. This matters in applied systems modeling because data often come from measurements, simulations, estimates, or large computational pipelines.

Pivoting is one way to improve numerical behavior. Partial pivoting swaps rows to use a larger pivot, reducing the risk of dividing by a very small number. Scaling can also matter because variables measured in very different units can create unstable calculations.

Numerical row reduction should be treated as a computational approximation, not an oracle. Solver outputs should be checked against conditioning, tolerances, and the original modeling context.

Back to top ↑

Systems Modeling Interpretation

Gaussian elimination helps systems modelers understand constraint systems. It reveals whether constraints are independent, whether targets are compatible, whether variables are determined, and whether degrees of freedom remain.

The meaning of row reduction depends on the model. A pivot might represent an independently binding resource constraint. A free variable might represent planning flexibility. A contradictory row might indicate impossible targets. A zero row might reveal redundant measurement. A small pivot might warn that the model is numerically fragile.

Responsible interpretation should document what the rows mean, what the variables mean, what units are used, what the right-hand side represents, whether row operations preserve intended meaning, whether solution values are feasible, and whether numerical tolerance affects the classification of rank and consistency.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Gaussian elimination and row reduction connect elementary matrices, row equivalence, echelon forms, pivot structure, rank, nullity, consistency, LU factorization, numerical stability, and computational complexity.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for Gaussian elimination should document the original augmented matrix, row operation sequence, pivot choices, tolerance rules, echelon form, rank, consistency status, solution behavior, and interpretation warnings. A solver should not simply return an answer; it should produce an audit trail.

The companion repository treats row reduction 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 row-reduction diagnostics, rank detection, consistency classification, pivot records, and feasibility warnings.

Back to top ↑

Python Workflow: Row Reduction Audit

The Python workflow below performs row reduction on an augmented matrix and records pivot columns, 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]]


@dataclass(frozen=True)
class RowReductionAudit:
    system_name: str
    equation_count: int
    unknown_count: int
    pivot_columns: str
    coefficient_rank: int
    augmented_rank: int
    consistent: bool
    solution_behavior: str
    tolerance: float
    interpretation_warning: str


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

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

        if pivot is None:
            continue

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

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

        pivot_columns.append(column)
        pivot_row += 1

        if pivot_row == row_count:
            break

    cleaned = [
        [0.0 if abs(value) < tolerance else round(value, 10) for value in row]
        for row in rows
    ]
    return cleaned, pivot_columns


def rank_from_rref(reduced: Matrix, coefficient_columns: int, tolerance: float = 1e-10) -> int:
    rank = 0
    for row in reduced:
        if any(abs(value) > tolerance for value in row[:coefficient_columns]):
            rank += 1
    return rank


def augmented_rank_from_rref(reduced: Matrix, tolerance: float = 1e-10) -> int:
    rank = 0
    for row in reduced:
        if any(abs(value) > tolerance for value in row):
            rank += 1
    return rank


def classify_solution_behavior(
    coefficient_rank: int,
    augmented_rank: int,
    unknown_count: int,
) -> tuple[bool, str]:
    if coefficient_rank != augmented_rank:
        return False, "no solution"
    if coefficient_rank == unknown_count:
        return True, "unique solution"
    return True, "infinitely many solutions"


def build_audit() -> RowReductionAudit:
    augmented = [
        [1.0, 1.0, 0.0, 100.0],
        [0.0, 1.0, 1.0, 80.0],
        [1.0, 0.0, 1.0, 90.0],
    ]

    tolerance = 1e-10
    unknown_count = 3
    reduced, pivots = rref(augmented, tolerance=tolerance)

    coefficient_rank = rank_from_rref(reduced, coefficient_columns=unknown_count, tolerance=tolerance)
    augmented_rank = augmented_rank_from_rref(reduced, tolerance=tolerance)
    consistent, behavior = classify_solution_behavior(
        coefficient_rank,
        augmented_rank,
        unknown_count,
    )

    variable_pivots = [column for column in pivots if column < unknown_count]

    return RowReductionAudit(
        system_name="three_constraint_resource_balance_system",
        equation_count=len(augmented),
        unknown_count=unknown_count,
        pivot_columns=",".join(str(column) for column in variable_pivots),
        coefficient_rank=coefficient_rank,
        augmented_rank=augmented_rank,
        consistent=consistent,
        solution_behavior=behavior,
        tolerance=tolerance,
        interpretation_warning=(
            "Row reduction reveals algebraic structure, but the computed solution still "
            "requires feasibility checks, unit review, and validation against original 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" / "row_reduction_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" / "row_reduction_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Row reduction audit complete.")

This workflow treats row reduction as an auditable procedure. It records the pivot structure and solution behavior while preserving an interpretation warning.

Back to top ↑

R Workflow: Echelon and Rank Check

R can support rank diagnostics and row-reduction-adjacent checks using QR decomposition or direct matrix operations. The workflow below records rank, consistency, and solution behavior.

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"
}

solution <- if (consistent && rank_A == unknown_count) {
  paste(round(solve(A, b), 4), collapse = ";")
} else {
  "not uniquely determined"
}

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,
  solution = solution,
  interpretation_warning = paste(
    "Rank diagnostics reveal algebraic structure, but feasibility and model adequacy",
    "must be reviewed against the original system."
  )
)

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

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

print(audit_record)

This R workflow is useful when row reduction is part of statistical modeling, calibration, policy analysis, or scientific computing.

Back to top ↑

Haskell Workflow: Typed Row Reduction Records

Haskell can represent row reduction audits with explicit fields for pivots, ranks, consistency, solution behavior, and warnings.

module Main where

data RowReductionAudit = RowReductionAudit
  { systemName :: String
  , equationCount :: Int
  , unknownCount :: Int
  , pivotColumns :: String
  , coefficientRank :: Int
  , augmentedRank :: Int
  , consistent :: Bool
  , solutionBehavior :: String
  , tolerance :: Double
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: RowReductionAudit
buildAudit =
  RowReductionAudit
    "three_constraint_resource_balance_system"
    3
    3
    "0,1,2"
    3
    3
    True
    "unique solution"
    1.0e-10
    "Row reduction reveals algebraic structure, but feasibility and model adequacy still require review."

main :: IO ()
main =
  print buildAudit

The typed workflow makes row reduction visible as a modeling record rather than a hidden solver step.

Back to top ↑

SQL Workflow: Row Reduction Assumption Registry

SQL can document row reduction assumptions when linear solvers support dashboards, planning systems, reporting pipelines, optimization workflows, risk models, or scientific computing tools.

CREATE TABLE row_reduction_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 row_reduction_assumption_registry VALUES
(
  'row_equivalence',
  'Row equivalence',
  'Elementary row operations preserve the solution set.',
  'Allows constraints to be transformed without changing feasible algebraic solutions.',
  'Equivalent algebraic systems may become harder to interpret if original equation meanings are lost.'
);

INSERT INTO row_reduction_assumption_registry VALUES
(
  'pivot_selection',
  'Pivot selection',
  'Chooses leading entries for elimination.',
  'Identifies independent constraint directions and controlled variables.',
  'Small or unstable pivots may create numerical reliability issues.'
);

INSERT INTO row_reduction_assumption_registry VALUES
(
  'rank_detection',
  'Rank detection',
  'Counts pivot rows or independent constraint directions.',
  'Reveals the effective number of independent modeled constraints.',
  'Rank depends on tolerance in numerical computation and should be interpreted carefully.'
);

INSERT INTO row_reduction_assumption_registry VALUES
(
  'consistency_check',
  'Consistency check',
  'Compares coefficient rank and augmented rank.',
  'Tests whether targets or right-hand-side values conflict with modeled relationships.',
  'Consistency does not guarantee practical feasibility or model adequacy.'
);

INSERT INTO row_reduction_assumption_registry VALUES
(
  'free_variables',
  'Free variables',
  'Variables without pivots remain unconstrained by independent equations.',
  'Represent degrees of freedom, flexibility, missing constraints, or decision variables.',
  'Free variables should be reviewed before choosing a solution.'
);

INSERT INTO row_reduction_assumption_registry VALUES
(
  'solution_verification',
  'Solution verification',
  'Substitutes computed values into the original system.',
  'Checks solver output against original equations, units, and constraints.',
  'Always verify against the original system, not only the row-reduced form.'
);

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

This registry keeps Gaussian elimination tied to row equivalence, pivot selection, rank, consistency, free variables, numerical tolerance, and solution verification.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports row reduction audits, Gaussian elimination examples, echelon-form diagnostics, RREF checks, pivot reports, rank comparisons, consistency classification, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Gaussian elimination is exact in symbolic mathematics and powerful in computation, but it does not guarantee that a model is adequate. Row reduction preserves the algebraic solution set of the equations supplied. It does not validate the equations, coefficients, units, assumptions, omissions, targets, or data sources.

A unique solution may still be infeasible. A free variable may represent useful flexibility or missing information. A contradiction may reveal an impossible target or simply a data-entry error. A zero row may represent legitimate redundancy or duplicated information. A small pivot may indicate numerical instability. A rank decision may depend on tolerance.

Responsible use requires documenting the original equations, the meaning of every row and column, the row-operation logic, pivot choices, numerical tolerances, units, solution verification, feasibility constraints, and the distinction 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
• Systems of Linear Equations
• 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.
• 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.
• 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.) LU Factorization: scipy.linalg.lu_factor. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lu_factor.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.) Gaussian Elimination. MathWorks Documentation. Available at: https://www.mathworks.com/help/symbolic/gaussian-elimination.html.
• MATLAB Documentation (n.d.) Systems of Linear Equations. MathWorks Documentation. Available at: https://www.mathworks.com/help/matlab/math/systems-of-linear-equations.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/.
• 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/.
• MATLAB Documentation (n.d.) Gaussian Elimination. MathWorks Documentation. Available at: https://www.mathworks.com/help/symbolic/gaussian-elimination.html.
• 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/.
• 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.) LU Factorization: scipy.linalg.lu_factor. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lu_factor.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 ↑