Matrix Arithmetic and the Logic of Combination: How Linear Algebra Combines System Structure

Last Updated June 28, 2026

Matrix arithmetic explains how multivariable system representations can be combined, compared, scaled, weighted, and transformed without losing their row and column structure. Matrix addition, subtraction, scalar multiplication, and linear combination are not just formal operations. In systems modeling, they describe how scenarios are combined, how differences are measured, how weights are applied, how indicators are aggregated, and how structured relationships are adjusted.

This article introduces matrix arithmetic as the logic of combination for multivariable systems. It explains when matrices can be added, what subtraction means, how scalar multiplication changes scale, how matrix linear combinations support weighted models, and why compatible dimensions, units, orientation, and entry meanings are essential for responsible interpretation.

The central modeling question is not only “Can these matrices be combined?” It is “Do these matrices represent the same kind of system structure, measured on compatible scales, with aligned rows, columns, units, and meaning?”

Matrix arithmetic begins with simple operations: adding matrices, subtracting matrices, and multiplying a matrix by a scalar. These operations look straightforward, but they carry strong modeling assumptions. Two matrices can be added only when their shapes match. More importantly, they should be added only when their rows, columns, units, orientation, and entry meanings are compatible.

For systems modeling, this matters because matrices often represent structured realities: infrastructure networks, ecological interactions, economic sectors, policy indicators, transportation flows, climate variables, risk exposures, or machine-learning features. Combining such matrices can be useful, but only when the combination is meaningful.

Why Matrix Arithmetic Matters

Matrix arithmetic matters because systems modeling often requires comparing or combining structured information. A planner may compare current and projected infrastructure condition matrices. An ecologist may combine species-interaction matrices under different climate scenarios. An economist may add sectoral flow matrices from multiple regions. A policy analyst may weight several indicator matrices to form a composite score. A machine-learning workflow may scale a feature matrix before modeling.

These operations depend on more than mathematics. They depend on whether the matrices represent the same kind of thing. Matrix addition can be valid as an operation and invalid as interpretation. Scalar multiplication can be computationally simple but substantively dangerous if it changes units or hides value judgments.

Matrix arithmetic is therefore a bridge between formal structure and applied judgment. It provides a disciplined way to combine multivariable representations, but it also forces modelers to ask whether those combinations make sense.

Matrix arithmetic is simple in notation but powerful in modeling. Its responsible use begins with interpretation.

Back to top ↑

Matrices as Structured Quantities

A matrix is a structured quantity. Its entries are organized by row and column, and those positions carry meaning. When matrices are added or subtracted, the operation happens position by position. The entry in row \(i\), column \(j\) of the result depends on the entries in row \(i\), column \(j\) of the original matrices.

This means that row and column alignment is essential. If row 1 in one matrix represents a water system and row 1 in another matrix represents an energy system, adding them entry by entry may produce a meaningless result. If columns are sorted differently, the operation may combine the wrong variables.

Matrix arithmetic therefore depends on semantic alignment. The mathematical operation only knows position. The modeler must know meaning.

Back to top ↑

Compatible Dimensions

Matrix addition and subtraction require matrices of the same shape. If \(A\) is an \(m\times n\) matrix, then \(B\) must also be an \(m\times n\) matrix for \(A+B\) or \(A-B\) to be defined.

Same shape is necessary but not sufficient. Two matrices may both be \(10\times 5\), but one might represent counties by infrastructure variables while another represents schools by education indicators. These matrices are formally compatible but substantively incompatible.

Compatible dimensions are a formal gate. Compatible meaning is a modeling gate.

Back to top ↑

Matrix Addition

Matrix addition combines corresponding entries. In systems modeling, addition can represent combining flows, summing exposures, aggregating compatible effects, merging scenario layers, or adding system components.

For example, two transportation flow matrices may be added if they use the same origin-destination ordering and units. A weekday freight matrix and a weekday passenger matrix might be combined to estimate total vehicle movement only if their entries are comparable. If one matrix counts vehicles and another counts people, addition requires conversion or careful interpretation.

Addition is a model of combination. It should be used only when corresponding entries can reasonably be combined.

Back to top ↑

Matrix Subtraction

Matrix subtraction compares corresponding entries. It can represent change, difference, residual, deviation, loss, improvement, gap, or error.

In systems modeling, subtraction is useful for comparing observed and predicted matrices, current and future states, pre-intervention and post-intervention conditions, or target and actual performance. But subtraction requires aligned baselines. A difference matrix is meaningful only when the two matrices are comparable.

Subtraction does not automatically explain why a difference exists. It identifies where differences occur, but causal interpretation requires additional analysis.

Back to top ↑

Scalar Multiplication

Scalar multiplication multiplies every entry in a matrix by the same number. In systems modeling, scalar multiplication can represent scaling, weighting, discounting, growth, decay, unit conversion, amplification, or scenario adjustment.

For example, a demand matrix might be multiplied by \(1.10\) to represent a 10 percent increase under a growth scenario. A cost matrix might be multiplied by a discount factor. A risk matrix might be weighted by a policy priority. A unit conversion might multiply all entries by a fixed constant.

Scalar multiplication is often treated as mechanical. In applied modeling, the scalar may carry assumptions about growth, importance, uncertainty, value, or time.

Back to top ↑

Linear Combinations of Matrices

A linear combination of matrices combines scaled matrices of the same shape. This is one of the most important forms of matrix arithmetic for systems modeling.

Linear combinations support weighted scenarios, blended forecasts, composite indicators, multi-criteria decision models, portfolio analysis, and ensemble modeling. The weights \(\alpha\) and \(\beta\) may represent probability, importance, confidence, policy priority, cost share, exposure, or scenario weight.

A linear combination is more than arithmetic. It is a statement about how model components should count together.

Back to top ↑

Scenario Combination

Matrix arithmetic is useful for scenario analysis because each scenario can be represented as a structured matrix. A baseline matrix may describe current conditions. An intervention matrix may describe expected changes. A stress matrix may describe shocks. A combined scenario may be built by adding or weighting these matrices.

This structure is common in infrastructure planning, climate adaptation, energy modeling, transportation analysis, public health planning, and risk assessment. The arithmetic is useful because it preserves row and column structure while changing entries.

Scenario arithmetic is transparent when each component matrix is documented. It becomes opaque when change matrices are added without explaining what their entries mean.

Back to top ↑

Weights, Indices, and Composite Measures

Weighted matrix combinations are common in composite indicators and multi-criteria modeling. A model may combine several normalized indicator matrices into one score matrix. This can be useful, but it requires careful documentation because weights often encode judgments about importance.

Composite measures can clarify complex systems, but they can also hide disagreement. A single combined matrix may obscure tradeoffs among dimensions. For example, an infrastructure priority matrix might combine cost, condition, equity, climate exposure, and service importance. The final score may appear objective, but the weights determine how priorities are balanced.

Matrix arithmetic can build composite measures, but governance must explain what the combination means.

Back to top ↑

Elementwise Operations

Matrix addition, subtraction, and scalar multiplication are entrywise operations. Other entrywise operations also appear in applied modeling, including elementwise multiplication, division, masking, thresholding, and transformation. These are not the same as matrix multiplication.

Elementwise operations are useful when each entry should be adjusted by a corresponding factor. A risk matrix might be multiplied elementwise by an exposure mask. A demand matrix might be adjusted by location-specific growth factors. A network matrix might be filtered by a capacity matrix.

Elementwise logic is powerful because it preserves matrix shape. It is risky when the entrywise transformation is treated as neutral or obvious.

Back to top ↑

Units, Scaling, and Normalization

Matrix arithmetic depends heavily on units and scale. Adding incompatible units produces meaningless results. Weighting unnormalized matrices can let one component dominate simply because its values are larger. Subtracting matrices measured on different scales can create false differences.

Before combining matrices, modelers should ask whether entries are measured in the same units, whether they have been normalized, whether scaling changes interpretation, whether negative values are meaningful, and whether zero has a consistent meaning.

Scaling is not a housekeeping step. It is part of the model’s logic of combination.

Back to top ↑

Systems Modeling Interpretation

Matrix arithmetic helps systems modelers combine structured representations. It allows models to add compatible layers, compare states, scale values, weight components, and construct composite scenarios. But it also reveals a fundamental rule: formal compatibility is not the same as substantive compatibility.

Two matrices of the same shape may still represent different entities, different units, different time periods, different orientations, or different entry meanings. A weighted sum may look mathematically clean but hide assumptions about value, uncertainty, priority, or probability. A difference matrix may reveal change but not explain causation. A scalar may represent a unit conversion, a growth assumption, a discount factor, or a normative weight.

The responsible use of matrix arithmetic requires documenting why matrices are being combined, what corresponding entries mean, how units and scales were aligned, what weights represent, and what interpretation should not be drawn from the combined result.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Matrix arithmetic connects vector-space structure, matrix spaces, linear combinations, scalar fields, elementwise operations, matrix norms, residuals, affine combinations, convex combinations, and model governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for matrix arithmetic should document matrix shapes, row labels, column labels, units, entry meanings, scaling methods, weights, operation type, and interpretation warnings. A reproducible workflow should not only compute \(A+B\), \(A-B\), or \(\alpha A+\beta B\). It should explain why those operations are meaningful.

The companion repository treats matrix arithmetic as auditable modeling work. 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 compatibility, performing addition, subtraction, scalar multiplication, and weighted combination, then generating an audit record.

Back to top ↑

Python Workflow: Matrix Arithmetic Audit

The Python workflow below checks shape compatibility, performs matrix addition, subtraction, scalar multiplication, and weighted combination, then records the interpretation warning.

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 MatrixArithmeticAudit:
    operation_name: str
    matrix_shape: str
    row_meaning: str
    column_meaning: str
    units: str
    weights: str
    compatible_shape: bool
    output_entry_sum: float
    interpretation_warning: str


def shape(matrix: Matrix) -> tuple[int, int]:
    return (len(matrix), len(matrix[0]) if matrix else 0)


def same_shape(*matrices: Matrix) -> bool:
    if not matrices:
        return False
    first_shape = shape(matrices[0])
    return all(shape(matrix) == first_shape for matrix in matrices)


def add(A: Matrix, B: Matrix) -> Matrix:
    if not same_shape(A, B):
        raise ValueError("Matrices must have the same shape.")
    return [[a + b for a, b in zip(row_a, row_b)] for row_a, row_b in zip(A, B)]


def subtract(A: Matrix, B: Matrix) -> Matrix:
    if not same_shape(A, B):
        raise ValueError("Matrices must have the same shape.")
    return [[a - b for a, b in zip(row_a, row_b)] for row_a, row_b in zip(A, B)]


def scale(alpha: float, A: Matrix) -> Matrix:
    return [[alpha * value for value in row] for row in A]


def linear_combination(alpha: float, A: Matrix, beta: float, B: Matrix) -> Matrix:
    return add(scale(alpha, A), scale(beta, B))


def entry_sum(matrix: Matrix) -> float:
    return sum(sum(row) for row in matrix)


def build_audit() -> MatrixArithmeticAudit:
    baseline = [
        [10.0, 2.0, 0.0],
        [1.0, 12.0, 3.0],
        [0.0, 4.0, 8.0],
    ]

    intervention_effect = [
        [1.0, 0.5, 0.0],
        [0.2, 1.5, 0.4],
        [0.0, 0.7, 1.2],
    ]

    stress_effect = [
        [-0.5, -0.2, 0.0],
        [-0.1, -0.8, -0.3],
        [0.0, -0.4, -0.9],
    ]

    combined_change = linear_combination(
        1.0,
        intervention_effect,
        0.5,
        stress_effect,
    )

    future = add(baseline, combined_change)
    difference = subtract(future, baseline)

    return MatrixArithmeticAudit(
        operation_name="baseline_plus_weighted_intervention_and_stress",
        matrix_shape=f"{shape(baseline)[0]}x{shape(baseline)[1]}",
        row_meaning="infrastructure subsystem",
        column_meaning="performance relationship or dependency category",
        units="normalized condition-effect score",
        weights="1.0 intervention effect plus 0.5 stress effect",
        compatible_shape=same_shape(baseline, intervention_effect, stress_effect),
        output_entry_sum=round(entry_sum(difference), 4),
        interpretation_warning=(
            "The arithmetic is shape-compatible, but the weighted combination is "
            "meaningful only if rows, columns, units, baselines, and effect definitions align."
        ),
    )


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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Matrix arithmetic audit complete.")

This workflow treats matrix arithmetic as an auditable operation. It checks shape compatibility, but it also records row meaning, column meaning, units, weights, and interpretation warnings.

Back to top ↑

R Workflow: Matrix Combination Check

R can support matrix arithmetic, scenario comparison, and reproducible audit records. The workflow below combines a baseline matrix, intervention matrix, and stress matrix.

baseline <- matrix(
  c(
    10.0, 2.0, 0.0,
    1.0, 12.0, 3.0,
    0.0, 4.0, 8.0
  ),
  nrow = 3,
  byrow = TRUE
)

intervention_effect <- matrix(
  c(
    1.0, 0.5, 0.0,
    0.2, 1.5, 0.4,
    0.0, 0.7, 1.2
  ),
  nrow = 3,
  byrow = TRUE
)

stress_effect <- matrix(
  c(
    -0.5, -0.2, 0.0,
    -0.1, -0.8, -0.3,
    0.0, -0.4, -0.9
  ),
  nrow = 3,
  byrow = TRUE
)

same_shape <- identical(dim(baseline), dim(intervention_effect)) &&
  identical(dim(baseline), dim(stress_effect))

combined_change <- intervention_effect + 0.5 * stress_effect
future <- baseline + combined_change
difference <- future - baseline

audit_record <- data.frame(
  operation_name = "baseline_plus_weighted_intervention_and_stress",
  matrix_shape = paste(dim(baseline), collapse = "x"),
  row_meaning = "infrastructure subsystem",
  column_meaning = "performance relationship or dependency category",
  units = "normalized condition-effect score",
  weights = "1.0 intervention effect plus 0.5 stress effect",
  compatible_shape = same_shape,
  output_entry_sum = round(sum(difference), 4),
  interpretation_warning = paste(
    "The arithmetic is shape-compatible, but the weighted combination is meaningful",
    "only if rows, columns, units, baselines, and effect definitions align."
  )
)

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

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

print(audit_record)

This R workflow is useful when matrix arithmetic needs to connect with statistical reporting, indicator modeling, scenario comparison, or reproducible public-facing analysis.

Back to top ↑

Haskell Workflow: Typed Matrix Combination Records

Haskell can represent matrix arithmetic audits with explicit fields for operation type, matrix shape, row meaning, column meaning, units, weights, and warnings. This helps separate computation from interpretation.

module Main where

data MatrixArithmeticAudit = MatrixArithmeticAudit
  { operationName :: String
  , matrixShape :: String
  , rowMeaning :: String
  , columnMeaning :: String
  , units :: String
  , weights :: String
  , compatibleShape :: Bool
  , outputEntrySum :: Double
  , interpretationWarning :: String
  } deriving (Show)

type Matrix = [[Double]]

sameShape :: Matrix -> Matrix -> Bool
sameShape a b =
  length a == length b &&
  all (\(rowA, rowB) -> length rowA == length rowB) (zip a b)

addMatrices :: Matrix -> Matrix -> Matrix
addMatrices a b =
  zipWith (zipWith (+)) a b

scaleMatrix :: Double -> Matrix -> Matrix
scaleMatrix alpha =
  map (map (* alpha))

entrySum :: Matrix -> Double
entrySum matrix =
  sum (map sum matrix)

buildAudit :: MatrixArithmeticAudit
buildAudit =
  let baseline =
        [ [10.0, 2.0, 0.0]
        , [1.0, 12.0, 3.0]
        , [0.0, 4.0, 8.0]
        ]
      intervention =
        [ [1.0, 0.5, 0.0]
        , [0.2, 1.5, 0.4]
        , [0.0, 0.7, 1.2]
        ]
      stress =
        [ [-0.5, -0.2, 0.0]
        , [-0.1, -0.8, -0.3]
        , [0.0, -0.4, -0.9]
        ]
      combinedChange = addMatrices intervention (scaleMatrix 0.5 stress)
      future = addMatrices baseline combinedChange
      difference = addMatrices future (scaleMatrix (-1.0) baseline)
  in MatrixArithmeticAudit
      "baseline_plus_weighted_intervention_and_stress"
      "3x3"
      "infrastructure subsystem"
      "performance relationship or dependency category"
      "normalized condition-effect score"
      "1.0 intervention effect plus 0.5 stress effect"
      (sameShape baseline intervention && sameShape baseline stress)
      (entrySum difference)
      "Shape compatibility is not enough; rows, columns, units, baselines, and effect definitions must align."

main :: IO ()
main =
  print buildAudit

The typed workflow makes the modeling claim explicit. It does not allow matrix arithmetic to appear as a context-free numerical operation.

Back to top ↑

SQL Workflow: Matrix Arithmetic Assumption Registry

SQL can document matrix arithmetic assumptions when matrices support dashboards, decision systems, public reports, planning workflows, risk models, or machine-learning pipelines.

CREATE TABLE matrix_arithmetic_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 matrix_arithmetic_assumption_registry VALUES
(
  'shape_compatibility',
  'Shape compatibility',
  'Requires matrices to have the same row and column dimensions for addition or subtraction.',
  'Ensures entries can be combined position by position.',
  'Same shape is necessary but not sufficient for meaningful combination.'
);

INSERT INTO matrix_arithmetic_assumption_registry VALUES
(
  'row_alignment',
  'Row alignment',
  'Requires corresponding rows to index the same modeled entities.',
  'Prevents unrelated observations, nodes, regions, or equations from being combined.',
  'Row order must be documented and checked before arithmetic.'
);

INSERT INTO matrix_arithmetic_assumption_registry VALUES
(
  'column_alignment',
  'Column alignment',
  'Requires corresponding columns to index the same variables or components.',
  'Prevents unrelated features, destinations, sectors, or state variables from being combined.',
  'Column order and labels must be documented and checked before arithmetic.'
);

INSERT INTO matrix_arithmetic_assumption_registry VALUES
(
  'unit_compatibility',
  'Unit compatibility',
  'Requires entries to have compatible units or documented transformations.',
  'Supports meaningful addition, subtraction, scaling, and weighting.',
  'Combining dollars, percentages, counts, and probabilities requires careful conversion.'
);

INSERT INTO matrix_arithmetic_assumption_registry VALUES
(
  'weight_interpretation',
  'Weight interpretation',
  'Defines the meaning of scalar weights in linear combinations.',
  'Connects matrix arithmetic to probabilities, priorities, sensitivities, or policy choices.',
  'Weights should be justified, documented, and tested for sensitivity.'
);

INSERT INTO matrix_arithmetic_assumption_registry VALUES
(
  'component_traceability',
  'Component traceability',
  'Preserves links between combined matrices and source matrices.',
  'Allows composite results to be audited, decomposed, and interpreted.',
  'A combined matrix should not hide its components or transformations.'
);

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

This registry keeps matrix arithmetic tied to compatibility, alignment, units, weights, traceability, and interpretive review.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports matrix arithmetic audits, addition and subtraction checks, scalar multiplication, weighted linear combinations, elementwise operations, compatibility diagnostics, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Matrix arithmetic can make complex systems easier to combine and compare, but it can also create false clarity. Adding matrices may suggest that system layers are compatible when they are not. Subtracting matrices may suggest meaningful change when baselines differ. Scaling a matrix may hide assumptions about growth, discounting, priority, or uncertainty. Weighting matrices may turn contested values into apparently objective scores.

Responsible use requires more than checking dimensions. Modelers should document row labels, column labels, units, orientation, entry meaning, baseline assumptions, weights, scaling methods, missing-value rules, and component traceability. Combined matrices should remain auditable. Component matrices should often be reported alongside aggregate results.

The danger is not that matrix arithmetic is complicated. The danger is that it looks too simple. Matrix arithmetic should be treated as the logic of combination, and every combination should be justified.

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
• 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.
• 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.
• R Core Team and Matrix Package Authors (n.d.) Matrix Package Reference Manual. CRAN. Available at: https://cran.r-project.org/web/packages/Matrix/refman/Matrix.html.
• R Core Team and Matrix Package Authors (n.d.) Introduction to the Matrix Package. CRAN. Available at: https://cran.r-project.org/web/packages/Matrix/vignettes/Intro2Matrix.pdf.
• 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.) Linear Algebra — MATLAB Documentation. MathWorks. Available at: https://www.mathworks.com/help/matlab/linear-algebra.html.
• 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.
• scikit-learn Developers (n.d.) Decomposing Signals in Components. scikit-learn Documentation. Available at: https://scikit-learn.org/stable/modules/decomposition.html.
• pandas Developers (n.d.) DataFrame.to_numpy. pandas Documentation. Available at: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_numpy.html.
• Apache Arrow Developers (n.d.) Apache Arrow Documentation. Apache Software Foundation. Available at: https://arrow.apache.org/docs/.

Back to top ↑

References

• Apache Arrow Developers (n.d.) Apache Arrow Documentation. Apache Software Foundation. Available at: https://arrow.apache.org/docs/.
• 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.
• 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.) Linear Algebra — MATLAB Documentation. MathWorks. Available at: https://www.mathworks.com/help/matlab/linear-algebra.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/.
• 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 (n.d.) LAPACK Users’ Guide. 3rd edn. Netlib Repository. 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.
• pandas Developers (n.d.) DataFrame.to_numpy. pandas Documentation. Available at: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_numpy.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.) 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.
• 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 ↑