Matrix Multiplication and Interaction Effects: How Linear Algebra Reveals System Pathways

Last Updated June 28, 2026

Matrix multiplication and interaction effects explain how linear transformations combine, how variables influence one another, and how multi-step systems produce indirect behavior. Matrix multiplication is not only a rule for filling entries in a product matrix. It is a way of composing transformations, tracing pathways, combining layers, aggregating interactions, and understanding how one structured operation changes the meaning of another.

This article introduces matrix multiplication as both row-column computation and transformation composition. It connects dimensions, compatibility, dot products, linear combinations, composition order, noncommutativity, associativity, identity matrices, interaction pathways, indirect effects, network structure, state transitions, economic interdependence, ecological coupling, infrastructure dependencies, and responsible systems interpretation.

The central modeling question is not only “Can these matrices be multiplied?” It is “What interaction, sequence, pathway, or layered behavior does this product represent?”

Matrix multiplication is often taught as a mechanical row-column rule. That rule matters, but it is only the surface. A product \(AB\) can represent two transformations applied in sequence, one system layer feeding another, one network pathway followed by a second, or one set of interactions reshaping another. The entries of a product matrix are summaries of multi-step contribution.

For systems modeling, this makes matrix multiplication one of the most important operations in linear algebra. It explains how local relationships combine into global behavior, how indirect effects arise, how transformations interact, and why order matters.

Why Matrix Multiplication Matters

Matrix multiplication matters because systems rarely involve only one isolated transformation. Infrastructure demand becomes network load, then service stress. Economic final demand becomes production requirements, then upstream sector demand. Ecological pressure becomes population response, then food-web change. A policy lever changes indicators, which then affect downstream measures. In each case, one transformation feeds another.

This is why matrix multiplication is not ordinary element-by-element multiplication. It is designed to preserve the logic of transformation composition. The product matrix summarizes how the output of one linear process becomes the input to another.

Matrix multiplication is therefore a language for composition, not just calculation.

Back to top ↑

What Matrix Multiplication Does

If \(A\) and \(B\) are compatible matrices, the product \(AB\) creates a new matrix whose entries summarize how rows of \(A\) interact with columns of \(B\). The product combines one structure with another through dot products.

The index \(k\) is the intermediate layer. In systems terms, it can represent intermediate variables, sectors, nodes, states, features, constraints, or system components. The product entry is not a single direct coefficient. It is the sum of all contributions through the intermediate structure.

The row-column rule is therefore an interaction rule: products follow intermediate pathways and add their contributions.

Back to top ↑

Dimension Compatibility

Matrix multiplication is defined only when the inner dimensions match. If \(A\) is \(m\times n\) and \(B\) is \(n\times p\), then \(AB\) is \(m\times p\).

Dimension compatibility is not only a technical requirement. It is a modeling requirement. It says the outputs of one layer must be meaningful inputs to the next. If the dimensions match numerically but the quantities do not match substantively, the product may be mathematically defined but conceptually wrong.

A product matrix should be checked for both dimensional compatibility and conceptual compatibility.

Back to top ↑

The Row-Column Rule

The row-column rule says that each entry of \(AB\) is the dot product of one row of \(A\) and one column of \(B\). This rule is the computational core of matrix multiplication.

Each dot product is a weighted aggregation. In a system model, those weights may represent influence, flow, demand, transition probability, cost, risk, exposure, contribution, or transformation strength. The product entry therefore carries the modeling meaning of all these intermediate alignments.

When read this way, the row-column rule is not mechanical. It is a compact representation of interaction through shared structure.

Back to top ↑

The Linear Combination View

Matrix multiplication can also be read through linear combinations. The columns of \(AB\) are what happens when \(A\) transforms the columns of \(B\). Each column of the product is an output produced by applying \(A\) to one column of \(B\).

This interpretation is especially useful for model behavior. If the columns of \(B\) represent input patterns, scenarios, basis directions, sector profiles, or network contributions, then \(AB\) shows how \(A\) transforms each of those patterns.

This view connects multiplication to transformation behavior, rank, and reachable system states.

Back to top ↑

Composition of Transformations

The deepest meaning of matrix multiplication is composition. If \(B\) maps from one space into an intermediate space, and \(A\) maps from that intermediate space into another output space, then \(AB\) represents the combined transformation.

This explains why matrix multiplication has the shape it does. The product must be defined so that applying the product matrix to a vector gives the same result as applying two transformations in sequence.

Composition is why matrix multiplication appears throughout dynamics, networks, control systems, simulations, machine learning, economics, and scientific computing.

Back to top ↑

Order and Noncommutativity

Matrix multiplication is generally not commutative. Usually, \(AB\neq BA\). This is not an inconvenience. It reflects a real modeling fact: doing one transformation before another can produce a different result from doing them in the opposite order.

In systems modeling, order can represent time, causality, process sequence, pipeline structure, institutional procedure, or computational architecture. Applying a redistribution matrix before a capacity matrix may differ from applying capacity constraints before redistribution. Measuring a transformed state may differ from transforming a measurement vector.

Noncommutativity forces modelers to be explicit about process order.

Back to top ↑

Associativity and Layered Models

Although matrix multiplication is not generally commutative, it is associative. If the dimensions are compatible, then \((AB)C=A(BC)\). This means the grouping of sequential transformations can change without changing the final transformation, even though the order itself cannot change.

Associativity matters for computation and interpretation. In large systems, one grouping may be more efficient or numerically preferable than another. In modeling, grouping can reflect modules, layers, subsystems, pipelines, or stages of analysis.

Associativity gives flexibility; noncommutativity preserves order.

Back to top ↑

Identity and Neutral Action

The identity matrix acts as a neutral transformation. Multiplying by the identity leaves a vector or compatible matrix unchanged.

Identity matrices matter because they define what it means for a transformation to be unchanged, reversed, or preserved. Inverses are defined through identity behavior. State-transition systems often compare a transformation to the identity. Perturbation analysis asks how far a matrix is from neutral action.

The identity matrix anchors the interpretation of action, reversal, and change.

Back to top ↑

Interaction Effects

In this article, interaction effects do not mean nonlinear statistical interactions in the narrow regression sense. They mean structural effects produced when matrix relationships combine. A product entry can reveal an effect that does not appear as a single direct coefficient in either matrix alone.

For example, if \(B\) maps demand into intermediate production sectors and \(A\) maps intermediate production into resource stress, then \(AB\) maps demand directly into resource stress through all intermediate sector pathways. The product exposes mediated effects.

Matrix multiplication makes these indirect effects computable, visible, and auditable.

Back to top ↑

Pathways and Indirect Effects

The summation in matrix multiplication can be read as a pathway calculation. Each intermediate index \(k\) identifies one channel through which an input can affect an output. The product sums across all such channels.

This is one reason matrix multiplication is so useful in systems modeling. Many system effects are not direct. They travel through supply chains, infrastructure dependencies, ecological webs, institutions, technologies, measurement systems, or computational layers.

Indirect effects are often where system behavior becomes interesting, fragile, or politically consequential.

Back to top ↑

Networks and Adjacency Matrices

Matrix multiplication has a powerful network interpretation. If \(A\) is an adjacency matrix, then entries of \(A^2\) count or weight two-step walks in the network. Higher powers describe longer walks.

This makes matrix products central to network science, graph algorithms, infrastructure modeling, epidemiological contact structures, information diffusion, transport systems, ecological interaction networks, and economic input-output models.

Network interpretation turns multiplication into pathway analysis.

Back to top ↑

Systems Modeling Interpretation

Matrix products should be interpreted as structured compositions. If \(AB\) appears in a model, the product should be accompanied by a statement of what \(B\) does first, what \(A\) does second, what intermediate dimension connects them, and what each product entry means.

This is especially important because matrix multiplication can hide assumptions. A product may look like a single matrix, but it may combine multiple stages of measurement, estimation, transformation, weighting, aggregation, and interpretation. If those stages use different units, variable orderings, assumptions, or data sources, the product can become difficult to justify.

Responsible interpretation asks whether the product represents a real sequence, a computational convenience, a theoretical composition, a network pathway calculation, or a modeling abstraction. Each case requires different validation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Matrix multiplication connects bilinear maps, tensor contraction, transformation composition, associativity, noncommutativity, identity elements, semigroups, matrix algebras, operator products, block matrices, path algebras, adjacency powers, spectral behavior, numerical stability, and algorithmic complexity.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for matrix multiplication should document matrix shapes, row and column meanings, compatibility checks, product entries, product interpretation, noncommutativity tests, associativity checks where relevant, repeated-product behavior, and any unit or scaling warnings. A product matrix should not appear without an explanation of what sequence or interaction it represents.

The companion repository treats matrix multiplication as auditable systems 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 matrix-product analysis.

For this article, the computational examples focus on compatible products, row-column contribution, interaction pathways, product interpretation, noncommutativity, and model-governance records.

Back to top ↑

Python Workflow: Interaction Product Audit

The Python workflow below multiplies two compatible matrices, records the product, checks noncommutativity where the reverse product is possible, and generates an 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 MatrixProductAudit:
    system_name: str
    left_shape: str
    right_shape: str
    product_shape: str
    product_matrix: str
    reverse_product_available: bool
    noncommutative_warning: str
    interaction_interpretation: str
    governance_warning: str


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


def matmul(A: Matrix, B: Matrix) -> Matrix:
    a_rows, a_cols = shape(A)
    b_rows, b_cols = shape(B)

    if a_cols != b_rows:
        raise ValueError(f"incompatible dimensions: {a_rows}x{a_cols} times {b_rows}x{b_cols}")

    return [
        [sum(A[i][k] * B[k][j] for k in range(a_cols)) for j in range(b_cols)]
        for i in range(a_rows)
    ]


def matrix_to_string(A: Matrix) -> str:
    return ";".join(",".join(f"{value:.6f}" for value in row) for row in A)


def build_audit() -> MatrixProductAudit:
    # B maps two demand categories into three intermediate system components.
    B = [
        [0.80, 0.20],
        [0.35, 0.60],
        [0.10, 0.50],
    ]

    # A maps three intermediate system components into two output stress indicators.
    A = [
        [1.10, 0.40, 0.20],
        [0.25, 0.90, 0.70],
    ]

    product = matmul(A, B)

    try:
        reverse_product = matmul(B, A)
        reverse_available = True
        noncommutative_warning = (
            "reverse product is dimensionally available but represents a different transformation order"
            if reverse_product != product
            else "reverse product happens to match in this example"
        )
    except ValueError:
        reverse_available = False
        noncommutative_warning = "reverse product is not dimensionally compatible"

    left_rows, left_cols = shape(A)
    right_rows, right_cols = shape(B)
    product_rows, product_cols = shape(product)

    return MatrixProductAudit(
        system_name="two_stage_demand_to_stress_interaction",
        left_shape=f"{left_rows}x{left_cols}",
        right_shape=f"{right_rows}x{right_cols}",
        product_shape=f"{product_rows}x{product_cols}",
        product_matrix=matrix_to_string(product),
        reverse_product_available=reverse_available,
        noncommutative_warning=noncommutative_warning,
        interaction_interpretation=(
            "B maps demand categories into intermediate components; "
            "A maps intermediate components into stress indicators; "
            "AB maps demand categories directly into stress indicators through all intermediate pathways."
        ),
        governance_warning=(
            "Matrix products should document transformation order, intermediate-layer meaning, "
            "unit compatibility, row-column alignment, and whether indirect effects are substantively valid."
        ),
    )


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


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

This workflow treats matrix multiplication as an auditable interaction claim. It records shapes, product entries, transformation order, reverse-product status, interaction meaning, and governance warnings.

Back to top ↑

R Workflow: Matrix Product Diagnostics

R can support matrix-product analysis by checking dimensions, computing products, comparing reverse products when available, and producing audit-ready outputs.

B <- matrix(
  c(
    0.80, 0.20,
    0.35, 0.60,
    0.10, 0.50
  ),
  nrow = 3,
  byrow = TRUE
)

A <- matrix(
  c(
    1.10, 0.40, 0.20,
    0.25, 0.90, 0.70
  ),
  nrow = 2,
  byrow = TRUE
)

product <- A %*% B

reverse_available <- ncol(B) == nrow(A)

noncommutative_warning <- if (reverse_available) {
  reverse_product <- B %*% A
  "reverse product is dimensionally available but represents a different transformation order"
} else {
  "reverse product is not dimensionally compatible"
}

audit_record <- data.frame(
  system_name = "two_stage_demand_to_stress_interaction",
  left_shape = paste(dim(A), collapse = "x"),
  right_shape = paste(dim(B), collapse = "x"),
  product_shape = paste(dim(product), collapse = "x"),
  product_matrix = paste(apply(round(product, 6), 1, paste, collapse = ","), collapse = ";"),
  reverse_product_available = reverse_available,
  noncommutative_warning = noncommutative_warning,
  interaction_interpretation = paste(
    "B maps demand categories into intermediate components;",
    "A maps intermediate components into stress indicators;",
    "AB maps demand categories into stress indicators through intermediate pathways."
  ),
  governance_warning = paste(
    "Matrix products require transformation order, intermediate-layer meaning,",
    "unit compatibility, and row-column alignment review."
  )
)

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

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

print(audit_record)

This R workflow is useful when products represent system layers, network pathways, economic dependencies, measurement pipelines, or model transformations.

Back to top ↑

Haskell Workflow: Typed Product Records

Haskell can represent matrix-product interpretation as a typed record, keeping shapes, product entries, order warnings, and interaction meaning together.

module Main where

data MatrixProductAudit = MatrixProductAudit
  { systemName :: String
  , leftShape :: String
  , rightShape :: String
  , productShape :: String
  , productMatrix :: String
  , reverseProductAvailable :: Bool
  , noncommutativeWarning :: String
  , interactionInterpretation :: String
  , governanceWarning :: String
  } deriving (Show)

buildAudit :: MatrixProductAudit
buildAudit =
  MatrixProductAudit
    "two_stage_demand_to_stress_interaction"
    "2x3"
    "3x2"
    "2x2"
    "1.040000,0.560000;0.585000,0.940000"
    True
    "reverse product is dimensionally available but represents a different transformation order"
    "B maps demand into intermediate components; A maps intermediate components into stress indicators; AB maps demand into stress through pathways."
    "Matrix products require transformation order, intermediate-layer meaning, units, and row-column alignment review."

main :: IO ()
main =
  print buildAudit

The typed workflow helps prevent a product matrix from being separated from its interpretation.

Back to top ↑

SQL Workflow: Interaction Assumption Registry

SQL can document matrix-product assumptions when interaction workflows support dashboards, planning systems, network models, scientific-computing pipelines, economic models, or institutional reports.

CREATE TABLE matrix_product_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_product_assumption_registry VALUES
(
  'dimension_compatibility',
  'Dimension compatibility',
  'The inner dimensions of two matrices must match for multiplication.',
  'The output layer of the first transformation must feed meaningfully into the input layer of the second.',
  'Matching dimensions do not guarantee matching units or concepts.'
);

INSERT INTO matrix_product_assumption_registry VALUES
(
  'row_column_rule',
  'Row-column rule',
  'Each product entry is a dot product of one row and one column.',
  'Each entry aggregates pathway contributions through intermediate components.',
  'Intermediate indexes should have documented system meaning.'
);

INSERT INTO matrix_product_assumption_registry VALUES
(
  'composition_order',
  'Composition order',
  'In AB, B acts first and A acts second.',
  'Transformation sequence matters for system interpretation.',
  'Reversing order can change meaning or be impossible.'
);

INSERT INTO matrix_product_assumption_registry VALUES
(
  'noncommutativity',
  'Noncommutativity',
  'Matrix multiplication usually satisfies AB not equal BA.',
  'Process order, pipeline order, and pathway direction matter.',
  'Do not swap products unless the transformation meaning permits it.'
);

INSERT INTO matrix_product_assumption_registry VALUES
(
  'indirect_effect',
  'Indirect effect',
  'Product entries sum contributions through intermediate indexes.',
  'Captures mediated or multi-step system relationships.',
  'Indirect effects require substantive validation.'
);

INSERT INTO matrix_product_assumption_registry VALUES
(
  'repeated_product',
  'Repeated product',
  'Matrix powers represent repeated application of a transformation.',
  'Supports pathway, transition, and dynamic-system analysis.',
  'Long-run interpretation requires stability and model-scope review.'
);

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

This registry keeps matrix multiplication tied to dimension compatibility, transformation order, intermediate pathways, indirect effects, noncommutativity, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports matrix-product audits, row-column contribution diagnostics, interaction-pathway reports, noncommutativity checks, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Matrix multiplication is powerful because it compresses layered relationships into product matrices. It is limited because compression can hide assumptions. A product may combine data sources, units, indexing conventions, time scales, causal assumptions, measurement processes, and computational transformations that should not be merged without review.

A product matrix can look precise while concealing weak intermediate definitions. A dimensionally valid product can still be conceptually invalid. A product entry can be interpreted as an indirect effect only if the intermediate pathways correspond to meaningful system relationships. A repeated product may suggest long-run behavior only if the transformation remains stable and appropriate across iterations.

Responsible use requires documenting transformation order, matrix shapes, row and column meanings, intermediate-layer meaning, units, scaling, indexing, direct versus indirect effects, noncommutativity, numerical method, and whether the product represents composition, pathway aggregation, dynamic iteration, or computational convenience.

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 Transformations and Model Behavior
• 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.
• 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 ↑