Linear Transformations and Model Behavior: How Matrices Act on System States

Last Updated June 28, 2026

Linear transformations and model behavior explain how matrices act on system states. A matrix is not only an array of numbers or a coefficient table. It is also a rule for transforming vectors: moving, scaling, rotating, shearing, projecting, mixing, compressing, amplifying, or preserving structure inside a state space.

This article introduces linear transformations as structure-preserving maps between vector spaces. It connects matrix action, state vectors, domain, codomain, image, kernel, rank, nullity, basis behavior, superposition, geometric transformation, system response, sensitivity, and responsible interpretation.

The central modeling question is not only “What are the entries of this matrix?” It is “What does this transformation do to system states, and what behavior does that action reveal?”

Linear transformations are the behavioral side of matrices. A matrix can be read as stored coefficients, but it can also be read as an action: it takes one vector and produces another. That action may preserve dimension, collapse direction, amplify differences, mix variables, rotate coordinates, redistribute quantities, or reveal a system’s reachable outputs.

For systems modeling, this shift is essential. Earlier articles developed vectors, spaces, bases, equations, rank, nullity, determinants, inverses, and least-squares approximation. This article begins Part III by treating matrices as transformations whose behavior can be studied directly.

Why Linear Transformations Matter

Linear transformations matter because many systems models describe how one state becomes another. A population vector may be transformed by a transition matrix. A demand vector may be transformed into production requirements. A sensor vector may be transformed into estimated state variables. A network vector may be transformed into redistributed flow. A feature vector may be transformed into model scores, embeddings, or predictions.

In each case, the matrix is not passive. It acts. It changes a vector according to a structured rule.

This action-oriented view helps modelers ask better questions. What directions are amplified? What directions are collapsed? What combinations are preserved? Which outputs are reachable? Which input changes are invisible? How does the model behave under repeated application?

Linear transformations turn matrix algebra into model behavior.

Back to top ↑

What Is a Linear Transformation?

A linear transformation is a function between vector spaces that preserves vector addition and scalar multiplication. If \(T\) is linear, then transforming a sum is the same as summing the transformations, and transforming a scaled vector is the same as scaling the transformed vector.

Every matrix multiplication \(A\mathbf{x}\) defines a linear transformation. If \(A\) is an \(m\times n\) matrix, then it maps vectors in \(\mathbb{R}^n\) to vectors in \(\mathbb{R}^m\).

The matrix’s shape therefore determines the dimensions of the transformation.

Back to top ↑

Matrix Action on System States

Matrix action is the process of multiplying a matrix by a state vector. Each output component is a weighted combination of input components. This makes matrices natural tools for modeling interaction, dependence, redistribution, response, and transformation.

Rows describe how outputs are assembled. Columns describe how each input direction contributes across the output space. This dual interpretation is especially useful for systems modeling: rows behave like response equations, while columns behave like contribution patterns.

Matrix action is where representation becomes behavior.

Back to top ↑

Linearity and Superposition

Linearity means the transformation respects decomposition. If an input state is built from component states, the transformed output is built from the transformed components. This is the principle of superposition.

Superposition is powerful because it makes systems analyzable. A modeler can study how each component behaves and then combine those effects. But superposition is also a modeling assumption. Many real systems contain thresholds, saturation, feedback, nonlinear interaction, path dependence, or discontinuity. In those settings, a linear transformation may clarify a local or approximate structure while missing important nonlinear behavior.

Linearity is both a mathematical property and a modeling commitment. It should be used deliberately.

Back to top ↑

Domain, Codomain, Image, and Kernel

Every linear transformation has a domain, codomain, image, and kernel. These concepts describe where inputs come from, where outputs are declared to live, which outputs are actually reachable, and which input directions disappear.

The image of \(T\) is the set of all reachable outputs. For a matrix transformation, this is the column space of \(A\). The kernel of \(T\) is the set of all inputs mapped to zero. For a matrix transformation, this is the null space of \(A\).

These ideas connect transformation behavior directly to rank, nullity, solvability, recovery, and approximation.

Back to top ↑

Basis Behavior and Transformation Structure

A linear transformation is completely determined by what it does to a basis. In \(\mathbb{R}^n\), if the standard basis vectors are \(\mathbf{e}_1,\ldots,\mathbf{e}_n\), then the columns of \(A\) are exactly the transformed basis vectors.

This is one of the most important geometric interpretations of a matrix. A matrix does not need to be understood entry by entry first. It can be understood by watching where the basis vectors go. From there, every other vector follows by linear combination.

Studying transformed basis vectors makes matrix behavior visible.

Back to top ↑

Geometry of Transformations

In low dimensions, linear transformations can be visualized as changes to grids, vectors, shapes, and regions. A matrix may stretch space, shrink space, shear it, rotate it, reflect it, project it, or collapse it into a lower-dimensional subspace.

Geometry helps modelers see how a transformation behaves before turning to more abstract diagnostics. A transformed grid can reveal stretching, compression, skew, and collapse that may be hidden inside entries.

For higher-dimensional systems, visual intuition becomes less direct, but the same concepts remain: directions are mapped, volumes may change, some subspaces may be preserved, and other directions may disappear.

Back to top ↑

Rank, Nullity, and Transformation Behavior

Rank and nullity describe the behavior of a transformation. Rank measures how many independent output directions the transformation can produce. Nullity measures how many independent input directions disappear into zero.

Rank and nullity therefore have behavioral meaning. A full-rank transformation preserves maximum independent output structure for its shape. A rank-deficient transformation collapses some directions. A nontrivial kernel means some input changes are invisible to the model.

Rank and nullity tell us not only whether equations can be solved, but also how the transformation behaves.

Back to top ↑

Transformations and Systems Modeling

In systems modeling, a linear transformation may represent a physical process, an accounting relationship, a measurement system, a conversion rule, a state update, a network flow, a policy response, or a computational feature map. Each interpretation changes what the matrix action means.

The same matrix operation can mean different things depending on the model. Responsible interpretation depends on linking transformation behavior to row meanings, column meanings, units, domain assumptions, and system purpose.

Back to top ↑

State Transition Thinking

A linear transformation can describe how a system moves from one state to another. If \(\mathbf{x}_t\) is the state at time \(t\), a matrix \(A\) may define the next state:

Repeated transformation creates dynamic behavior. Some directions may grow, some may decay, some may persist, and some may oscillate or mix. Later articles on eigenvalues, Markov chains, long-run behavior, linear dynamical systems, and control systems will develop this idea in greater depth.

Linear transformations therefore provide the foundation for dynamic systems modeling.

Back to top ↑

Sensitivity and Amplification

A transformation can amplify small differences or dampen them. If two input states are close together, the transformed outputs may remain close, move farther apart, or collapse together. This behavior matters for stability, sensitivity, uncertainty, and decision reliability.

Matrix norms, singular values, condition numbers, and eigenstructure give more precise tools for studying sensitivity. At this stage, the key idea is behavioral: a matrix does not merely transform states; it transforms differences among states.

Sensitivity is transformation behavior under uncertainty.

Back to top ↑

Numerical Workflows and Diagnostics

Computational transformation workflows should not only multiply matrices by vectors. They should also document shape, rank, nullity, matrix norm, determinant when square, condition warning, input-output examples, and interpretation notes. A transformation may be algebraically simple but numerically fragile or substantively misleading.

Transformation analysis should connect computation to interpretation. The question is not only what \(A\mathbf{x}\) equals, but what that output means and whether the transformation is reliable for the model’s purpose.

Back to top ↑

Systems Modeling Interpretation

Linear transformations help modelers describe how systems respond. A transformation may encode a physical process, a measurement pipeline, an accounting relationship, a computational representation, or a policy model. In every case, the matrix acts on a vector, and that action has consequences.

Interpretation should begin with the model’s row and column meanings. What does each input component represent? What does each output component represent? Are the units compatible? Does linearity make sense? Are variables expected to combine additively? Are negative values meaningful? Is the transformation static or dynamic? Is it exact, approximate, empirical, or conceptual?

Responsible transformation analysis also asks whether the matrix preserves, collapses, amplifies, or distorts system structure. A transformation can be useful even when it is not invertible, but its limits must be clear.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Linear transformations connect vector spaces, homomorphisms, matrix representations, bases, coordinates, kernels, images, quotient structure, rank-nullity, operator norms, singular values, eigenstructure, invariant subspaces, and dynamical behavior.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for linear transformations should document the input vector, transformation matrix, output vector, domain dimension, codomain dimension, rank, nullity, determinant when square, matrix norm, input-output examples, sensitivity notes, and interpretation warnings. A matrix-vector product should be paired with enough context to explain what has changed and why it matters.

The companion repository treats transformation behavior 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 matrix action, transformed states, rank/nullity diagnostics, amplification warnings, and model-governance records.

Back to top ↑

Python Workflow: Transformation Behavior Audit

The Python workflow below transforms a system state vector, records the output, estimates rank and nullity, computes a simple amplification ratio, and attaches 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 TransformationBehaviorAudit:
    system_name: str
    row_count: int
    column_count: int
    input_state: str
    output_state: str
    rank: int
    nullity: int
    input_norm: float
    output_norm: float
    amplification_ratio: float
    behavior_warning: str
    interpretation_warning: str


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


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


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

    return rows, pivot_columns


def build_audit() -> TransformationBehaviorAudit:
    A = [
        [1.20, 0.10, 0.00],
        [0.20, 0.85, 0.15],
        [0.00, 0.25, 0.90],
    ]
    x = [100.0, 60.0, 30.0]

    y = matvec(A, x)
    _, pivots = rref(A)
    rank = len(pivots)
    nullity = len(A[0]) - rank
    input_norm = norm2(x)
    output_norm = norm2(y)
    amplification_ratio = output_norm / input_norm if input_norm else float("nan")

    if amplification_ratio > 1.10:
        behavior_warning = "transformation amplifies this input state"
    elif amplification_ratio < 0.90:
        behavior_warning = "transformation dampens this input state"
    else:
        behavior_warning = "transformation keeps this input norm at a similar scale"

    return TransformationBehaviorAudit(
        system_name="three_component_system_response",
        row_count=len(A),
        column_count=len(A[0]),
        input_state=",".join(f"{value:.6f}" for value in x),
        output_state=",".join(f"{value:.6f}" for value in y),
        rank=rank,
        nullity=nullity,
        input_norm=round(input_norm, 12),
        output_norm=round(output_norm, 12),
        amplification_ratio=round(amplification_ratio, 12),
        behavior_warning=behavior_warning,
        interpretation_warning=(
            "Matrix action shows modeled behavior, but interpretation requires row meanings, "
            "column meanings, units, scaling, linearity assumptions, and sensitivity 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" / "linear_transformation_behavior_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_transformation_behavior_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


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

This workflow treats matrix action as an auditable transformation. It reports input state, output state, rank, nullity, norms, amplification ratio, and interpretation warnings.

Back to top ↑

R Workflow: Matrix Action and State Response

R can support transformation behavior analysis by multiplying matrices and vectors, computing rank, reviewing norms, and producing audit-ready outputs.

A <- matrix(
  c(
    1.20, 0.10, 0.00,
    0.20, 0.85, 0.15,
    0.00, 0.25, 0.90
  ),
  nrow = 3,
  byrow = TRUE
)

x <- c(100, 60, 30)
y <- as.vector(A %*% x)

input_norm <- sqrt(sum(x^2))
output_norm <- sqrt(sum(y^2))
amplification_ratio <- output_norm / input_norm
rank_A <- qr(A)$rank
nullity_A <- ncol(A) - rank_A

behavior_warning <- if (amplification_ratio > 1.10) {
  "transformation amplifies this input state"
} else if (amplification_ratio < 0.90) {
  "transformation dampens this input state"
} else {
  "transformation keeps this input norm at a similar scale"
}

audit_record <- data.frame(
  system_name = "three_component_system_response",
  row_count = nrow(A),
  column_count = ncol(A),
  input_state = paste(round(x, 6), collapse = ","),
  output_state = paste(round(y, 6), collapse = ","),
  rank = rank_A,
  nullity = nullity_A,
  input_norm = input_norm,
  output_norm = output_norm,
  amplification_ratio = amplification_ratio,
  behavior_warning = behavior_warning,
  interpretation_warning = paste(
    "Matrix action should be interpreted with row meanings, column meanings,",
    "units, scaling, linearity assumptions, and sensitivity review."
  )
)

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

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

print(audit_record)

This R workflow is useful when transformation behavior supports systems analysis, state response, calibration, scientific computing, or policy modeling.

Back to top ↑

Haskell Workflow: Typed Transformation Records

Haskell can represent transformation behavior as a typed record with fields for input state, output state, rank, nullity, amplification, and interpretation warning.

module Main where

data TransformationBehaviorAudit = TransformationBehaviorAudit
  { systemName :: String
  , rowCount :: Int
  , columnCount :: Int
  , inputState :: String
  , outputState :: String
  , rankValue :: Int
  , nullityValue :: Int
  , inputNorm :: Double
  , outputNorm :: Double
  , amplificationRatio :: Double
  , behaviorWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: TransformationBehaviorAudit
buildAudit =
  TransformationBehaviorAudit
    "three_component_system_response"
    3
    3
    "100.000000,60.000000,30.000000"
    "126.000000,75.500000,42.000000"
    3
    0
    120.415946
    152.750205
    1.268531
    "transformation amplifies this input state"
    "Matrix action requires row meanings, column meanings, units, scaling, and linearity review."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps transformation outputs attached to behavioral and interpretive context rather than treating \(A\mathbf{x}\) as a self-explanatory calculation.

Back to top ↑

SQL Workflow: Transformation Assumption Registry

SQL can document transformation assumptions when matrix-action workflows support dashboards, planning systems, scientific-computing pipelines, network analysis, calibration records, or institutional reports.

CREATE TABLE linear_transformation_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_transformation_assumption_registry VALUES
(
  'linear_transformation',
  'Linear transformation',
  'A map preserving addition and scalar multiplication.',
  'Represents a structured input-output behavior rule.',
  'Linearity should be justified for the modeled range and purpose.'
);

INSERT INTO linear_transformation_assumption_registry VALUES
(
  'matrix_action',
  'Matrix action',
  'The product A times x transforms an input vector into an output vector.',
  'Shows modeled system response to a specific state.',
  'Output interpretation depends on row meanings, column meanings, and units.'
);

INSERT INTO linear_transformation_assumption_registry VALUES
(
  'image',
  'Image',
  'The set of all reachable outputs of the transformation.',
  'Shows what behaviors the model can produce.',
  'The codomain may include outputs the model cannot actually reach.'
);

INSERT INTO linear_transformation_assumption_registry VALUES
(
  'kernel',
  'Kernel',
  'The set of inputs mapped to zero.',
  'Shows invisible input directions or collapsed variation.',
  'A nontrivial kernel prevents unique recovery.'
);

INSERT INTO linear_transformation_assumption_registry VALUES
(
  'basis_behavior',
  'Basis behavior',
  'The columns of a matrix show transformed basis vectors.',
  'Shows how each input direction contributes to system response.',
  'Basis-dependent interpretation should be documented.'
);

INSERT INTO linear_transformation_assumption_registry VALUES
(
  'amplification',
  'Amplification',
  'The transformation may increase the norm of state differences.',
  'Small input uncertainty can become larger output uncertainty.',
  'Sensitivity and conditioning should be reviewed before decision use.'
);

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

This registry keeps transformation analysis tied to linearity, matrix action, image, kernel, basis behavior, amplification, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports transformation-behavior audits, matrix-action diagnostics, state-response outputs, rank and nullity reports, amplification warnings, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Linear transformations are powerful because they make matrix behavior analyzable. They are limited because linearity is an assumption. Real systems may include nonlinear thresholds, feedback, saturation, discontinuity, path dependence, capacity limits, strategic behavior, or measurement distortions that are not captured by a single linear map.

A transformation can be mathematically correct and still substantively misleading if variables are poorly chosen, units are incompatible, rows and columns are not meaningful, data are biased, or outputs are interpreted beyond the model’s scope. A rank-deficient transformation may be intentional reduction or accidental information loss. A full-rank transformation may still be poorly conditioned or inappropriate for decision use.

Responsible use requires documenting domain, codomain, row meanings, column meanings, units, basis choices, rank, nullity, sensitivity, scaling, whether linearity is local or global, and whether the transformation is descriptive, predictive, causal, operational, or decision-oriented.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Scalars, Vectors, and System States
• Vector Spaces and System Representation
• Span, Linear Independence, and Basis
• Dimension and the Structure of Solution Spaces
• Matrices and the Organization of Multivariable Systems
• Matrix Arithmetic and the Logic of Combination
• Systems of Linear Equations
• Gaussian Elimination and Row Reduction
• Pivot Structure and Solvability
• Rank, Nullity, and Structural Dependence
• Determinants and Invertibility
• Inverse Matrices and Structural Recovery
• Overdetermined Systems and Least Squares Thinking
• Linear 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/.
• 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.
• 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/.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra. Georgia Institute of Technology. Available at: https://textbooks.math.gatech.edu/ila/.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Hefferon, J. (n.d.) Linear Algebra. Saint Michael’s College. Available at: https://joshua.smcvt.edu/linearalgebra/.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/matrix-analysis/FDA3627DC2B9F5C3DF2FD8C3CC136B48.
• 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/.
• 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 ↑