Eigenvalues, Eigenvectors, and System Modes: How Linear Algebra Reveals System Behavior

Last Updated June 28, 2026

Eigenvalues, eigenvectors, and system modes explain how linear algebra identifies the directions in which a system acts most clearly. A matrix can mix variables, rotate state space, amplify some directions, dampen others, reverse signs, or leave special directions unchanged except for scaling. Eigenvectors reveal those special directions. Eigenvalues measure how strongly the system acts along them.

This article introduces eigenstructure as a way to understand system behavior. It connects eigenvalues, eigenvectors, invariant directions, characteristic equations, dominant modes, stability, growth, decay, oscillation, equilibrium behavior, network centrality, Markov chains, dynamical systems, diagonalization, numerical computation, and responsible interpretation.

The central modeling question is not only “What are the eigenvalues?” It is “Which system modes do they reveal, and what do those modes mean for the behavior, stability, sensitivity, and interpretation of the model?”

Eigenvalues and eigenvectors are among the most important tools in linear algebra because they identify hidden structure inside transformations. A general matrix may mix all coordinates together. But along certain directions, the matrix may behave simply: it stretches, shrinks, reverses, or leaves the direction unchanged. Those directions are eigenvectors, and the scaling factors are eigenvalues.

For systems modeling, this matters because many systems have modes. A mode is a pattern of motion, variation, growth, decay, circulation, influence, instability, or equilibrium behavior. Eigenstructure helps reveal these patterns in dynamical systems, networks, Markov processes, coupled variables, structural models, ecological systems, economic systems, infrastructure models, and scientific-computing workflows.

Why Eigenstructure Matters

Eigenstructure matters because it reveals how a transformation behaves along its natural directions. Instead of describing a matrix only by its entries, eigenvalues and eigenvectors describe its action: which patterns are amplified, which are damped, which remain stable, which reverse direction, and which may produce oscillatory behavior.

This is especially important in systems modeling because complex systems often combine many interacting variables. Eigenstructure can identify dominant patterns, slow modes, unstable modes, equilibrium tendencies, network influence, long-run distributions, and directions of sensitivity.

Eigenstructure turns matrix behavior into mode-based interpretation.

Back to top ↑

Matrices and Invariant Directions

A matrix usually changes both the length and direction of a vector. But some vectors are special. When the matrix acts on them, their direction does not change. Only their length, sign, or complex phase changes. These are invariant directions.

Invariant directions are important because they simplify transformation behavior. Instead of tracking complicated mixing among coordinates, the model can describe how each mode behaves under the transformation.

Eigenvectors identify the directions where a matrix behaves most simply.

Back to top ↑

What Is an Eigenvector?

An eigenvector is a nonzero vector whose direction is preserved by a matrix transformation. The zero vector is excluded because every matrix maps the zero vector to the zero vector, which would make the definition meaningless.

Eigenvectors are direction objects, not single unique arrows. If \(\mathbf{v}\) is an eigenvector, then any nonzero scalar multiple of \(\mathbf{v}\) is also an eigenvector for the same eigenvalue.

Eigenvectors identify system patterns that remain structurally recognizable under transformation.

Back to top ↑

What Is an Eigenvalue?

An eigenvalue is the scalar associated with an eigenvector. It tells how the transformation scales that eigenvector direction.

The magnitude and sign of an eigenvalue affect interpretation. Large magnitudes indicate amplification. Small magnitudes indicate damping. Negative eigenvalues indicate reversal. Complex eigenvalues often indicate rotation or oscillation when interpreted over real state space.

Eigenvalues translate matrix action into mode behavior.

Back to top ↑

The Eigenvalue Equation

The eigenvalue equation can be rearranged to show that an eigenvector lies in the null space of a shifted matrix:

For a nonzero solution to exist, the matrix \(A-\lambda I\) must be singular. That means its determinant must be zero.

The eigenvalue equation links transformations, null spaces, determinants, and system modes.

Back to top ↑

The Characteristic Equation

The characteristic polynomial of a square matrix \(A\) is:

Solving the characteristic equation gives eigenvalues:

For small matrices, the characteristic equation can be solved symbolically. For large matrices, numerical algorithms are used. In applied systems modeling, eigenvalues are usually computed through numerical linear algebra rather than by expanding determinants by hand.

The characteristic equation is conceptually central, but serious computation usually relies on stable numerical methods.

Back to top ↑

System Modes

A system mode is a pattern of behavior that evolves in a structured way. In linear systems, eigenvectors often represent modes. The associated eigenvalues describe how those modes grow, decay, persist, reverse, or oscillate.

In a repeated linear transformation, a state evolves by:

If the initial state is an eigenvector, then repeated application is simple:

Modes help translate repeated matrix action into system behavior over time.

Back to top ↑

Dominant Modes

A dominant mode is associated with an eigenvalue whose magnitude is larger than the others. Under repeated application, this mode may eventually dominate the state, provided the initial condition contains a component in that direction and the matrix has suitable structure.

Dominant modes are important in network centrality, population dynamics, epidemic models, economic systems, stability analysis, Markov chains, iterative algorithms, and dimensional reduction. However, dominance is not always simple. Complex eigenvalues, defective matrices, repeated eigenvalues, nonlinear effects, forcing terms, constraints, and changing parameters can complicate interpretation.

Dominant modes can reveal long-run tendencies, but the assumptions behind the matrix must be reviewed.

Back to top ↑

Stability, Growth, and Decay

Eigenvalues are central to stability analysis. In discrete-time systems, repeated application of \(A\) depends on the magnitudes of eigenvalues. If all eigenvalues have magnitude less than one, many systems decay toward the origin, assuming the matrix is diagonalizable or otherwise well-behaved in the relevant sense.

Stability claims require care. Eigenvalues of a linearized model describe local linear behavior, not necessarily global nonlinear system behavior.

Back to top ↑

Complex Eigenvalues and Oscillation

Real matrices can have complex eigenvalues. These often arise in conjugate pairs. In real state space, complex eigenvalues commonly indicate rotation, oscillation, spiraling, or cyclic behavior.

The magnitude of a complex eigenvalue affects growth or decay, while its angle affects oscillation. If the magnitude is less than one in a discrete-time system, oscillations may decay. If the magnitude is greater than one, oscillations may grow.

Complex eigenvalues remind us that not all system modes are simple growth or decay. Some modes turn, cycle, or oscillate.

Back to top ↑

Eigenvectors and Basis Change

If a matrix has enough independent eigenvectors, those eigenvectors can form a basis. In that basis, the transformation may become diagonal. This is the bridge from eigenstructure to diagonalization.

In the eigenvector basis, each coordinate evolves independently by its eigenvalue. This is why eigenvectors are so useful for decoupling systems. A complicated interaction matrix can become a set of independent mode equations when the right basis exists.

Eigenvectors connect invariant directions to alternative representations of system behavior.

Back to top ↑

Networks and Centrality

Eigenvalues and eigenvectors are central to network analysis. If a matrix represents connections among nodes, eigenvectors can reveal patterns of influence, centrality, diffusion, clustering, or flow.

Eigenvector centrality is based on a recursive idea: a node is important if it is connected to important nodes. This can be expressed as an eigenvector equation for an adjacency-like matrix.

Eigenstructure can reveal network patterns, but network modeling choices determine what those patterns mean.

Back to top ↑

Markov Chains and Steady States

In Markov chains, state-transition matrices describe how probability distributions evolve. A steady-state distribution is a vector that remains unchanged under the transition process.

Markov-chain eigenstructure helps analyze long-run behavior, convergence, mixing, absorbing states, persistence, and equilibrium distributions.

Steady-state eigenvectors are useful only when the transition assumptions are valid for the system being modeled.

Back to top ↑

Numerical Computation and Diagnostics

Eigenvalues and eigenvectors can be sensitive to numerical error, especially for nearly defective matrices, repeated eigenvalues, nonnormal matrices, poorly scaled matrices, or matrices with clustered spectra. A computed eigenvalue should not be interpreted without diagnostic review.

Useful diagnostics include residual error, condition estimates, spectral gap, eigenvector stability, scaling review, matrix symmetry, normality, and whether the matrix is appropriate for eigenanalysis in the first place.

Eigenanalysis should be treated as a numerical workflow, not only a symbolic calculation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Eigenvalues and eigenvectors connect invariant subspaces, characteristic polynomials, eigenspaces, algebraic and geometric multiplicity, diagonalization, spectral radius, power iteration, Markov chains, Perron-Frobenius theory, symmetric matrix theory, Schur decomposition, Jordan structure, matrix powers, stability, and modal analysis.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for eigenvalues, eigenvectors, and system modes should document the matrix, units, scaling, eigenvalues, eigenvectors, eigenpair residuals, spectral radius, dominant mode, spectral gap, stability classification, complex-pair interpretation, normalization convention, numerical method, and interpretation notes.

The companion repository treats eigenstructure 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 eigenvalue and system-mode analysis.

For this article, the computational examples focus on eigenpair diagnostics, spectral-radius checks, dominant-mode interpretation, stability warnings, and model-governance records.

Back to top ↑

Python Workflow: Eigenstructure Audit

The Python workflow below computes a two-variable system’s eigenvalues and eigenvectors using a closed-form routine for teaching purposes, then records spectral radius, dominant eigenvalue, and interpretation warnings.

from __future__ import annotations

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


Matrix2 = list[list[float]]
Vector = list[float]


@dataclass(frozen=True)
class EigenstructureAudit:
    system_name: str
    matrix_entries: str
    trace: float
    determinant: float
    eigenvalue_1: float
    eigenvalue_2: float
    spectral_radius: float
    dominant_eigenvalue: float
    stability_classification: str
    eigenpair_residual_warning: str
    interpretation_warning: str


def trace_2x2(A: Matrix2) -> float:
    return A[0][0] + A[1][1]


def determinant_2x2(A: Matrix2) -> float:
    return A[0][0] * A[1][1] - A[0][1] * A[1][0]


def eigenvalues_2x2(A: Matrix2) -> tuple[float, float]:
    tr = trace_2x2(A)
    det = determinant_2x2(A)
    discriminant = tr * tr - 4.0 * det
    if discriminant < 0:
        raise ValueError("This teaching routine handles real eigenvalues only.")
    root = math.sqrt(discriminant)
    return ((tr + root) / 2.0, (tr - root) / 2.0)


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


def classify_stability(spectral_radius: float) -> str:
    if spectral_radius < 1.0:
        return "asymptotically_damped_discrete_time"
    if abs(spectral_radius - 1.0) <= 1e-10:
        return "marginal_or_persistent_discrete_time"
    return "amplifying_or_unstable_discrete_time"


def build_audit() -> EigenstructureAudit:
    A = [
        [0.82, 0.12],
        [0.18, 0.76],
    ]

    tr = trace_2x2(A)
    det = determinant_2x2(A)
    lambda_1, lambda_2 = eigenvalues_2x2(A)
    spectral_radius = max(abs(lambda_1), abs(lambda_2))
    dominant = lambda_1 if abs(lambda_1) >= abs(lambda_2) else lambda_2

    return EigenstructureAudit(
        system_name="two_sector_mode_audit",
        matrix_entries=matrix_to_string(A),
        trace=round(tr, 12),
        determinant=round(det, 12),
        eigenvalue_1=round(lambda_1, 12),
        eigenvalue_2=round(lambda_2, 12),
        spectral_radius=round(spectral_radius, 12),
        dominant_eigenvalue=round(dominant, 12),
        stability_classification=classify_stability(spectral_radius),
        eigenpair_residual_warning=(
            "For production workflows, compute eigenpair residuals ||Av-lambda v|| "
            "using a numerical linear algebra library and report sensitivity diagnostics."
        ),
        interpretation_warning=(
            "Eigenvalues describe modes of the specified matrix, not automatic causal mechanisms. "
            "Mode interpretation depends on matrix construction, units, scaling, domain meaning, "
            "and whether linear dynamics are appropriate."
        ),
    )


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


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

This workflow treats eigenvalues as mode diagnostics. It records the matrix, trace, determinant, eigenvalues, spectral radius, stability classification, and interpretation warnings.

Back to top ↑

R Workflow: Eigenvalue and Mode Diagnostics

R can support eigenstructure diagnostics by computing eigenvalues, eigenvectors, spectral radius, dominant mode, and eigenpair residuals.

A <- matrix(
  c(
    0.82, 0.12,
    0.18, 0.76
  ),
  nrow = 2,
  byrow = TRUE
)

eigen_result <- eigen(A)
eigenvalues <- eigen_result$values
eigenvectors <- eigen_result$vectors

spectral_radius <- max(Mod(eigenvalues))
dominant_index <- which.max(Mod(eigenvalues))
dominant_eigenvalue <- eigenvalues[dominant_index]
dominant_eigenvector <- eigenvectors[, dominant_index]

residual <- A %*% dominant_eigenvector - as.numeric(dominant_eigenvalue) * dominant_eigenvector
eigenpair_residual_norm <- sqrt(sum(Mod(residual)^2))

stability_classification <- ifelse(
  spectral_radius < 1,
  "asymptotically_damped_discrete_time",
  ifelse(abs(spectral_radius - 1) <= 1e-10, "marginal_or_persistent_discrete_time", "amplifying_or_unstable_discrete_time")
)

audit_record <- data.frame(
  system_name = "two_sector_mode_audit",
  matrix_entries = paste(round(as.vector(t(A)), 6), collapse = ","),
  eigenvalues = paste(round(Re(eigenvalues), 6), collapse = ","),
  spectral_radius = spectral_radius,
  dominant_eigenvalue = Re(dominant_eigenvalue),
  dominant_eigenvector = paste(round(Re(dominant_eigenvector), 6), collapse = ","),
  eigenpair_residual_norm = eigenpair_residual_norm,
  stability_classification = stability_classification,
  interpretation_warning = paste(
    "Eigenvalues describe modes of the specified matrix, not automatic causal mechanisms.",
    "Mode interpretation depends on matrix construction, units, scaling, and domain meaning."
  )
)

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

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

print(audit_record)

This R workflow is useful for applied eigenanalysis when eigenvalues, eigenvectors, residual diagnostics, and stability interpretation need to be kept together.

Back to top ↑

Haskell Workflow: Typed Eigenstructure Records

Haskell can represent eigenstructure diagnostics as a typed record with fields for eigenvalues, spectral radius, dominant mode, stability classification, and interpretation warnings.

module Main where

data EigenstructureAudit = EigenstructureAudit
  { systemName :: String
  , matrixEntries :: String
  , traceValue :: Double
  , determinantValue :: Double
  , eigenvalueOne :: Double
  , eigenvalueTwo :: Double
  , spectralRadius :: Double
  , dominantEigenvalue :: Double
  , stabilityClassification :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: EigenstructureAudit
buildAudit =
  EigenstructureAudit
    "two_sector_mode_audit"
    "0.820000,0.120000;0.180000,0.760000"
    1.58
    0.6016
    0.94
    0.64
    0.94
    0.94
    "asymptotically_damped_discrete_time"
    "Eigenvalues describe modes of the specified matrix; interpretation depends on construction, units, scaling, and domain meaning."

main :: IO ()
main =
  print buildAudit

The typed workflow keeps eigenstructure attached to modeling interpretation, rather than treating eigenvalues as isolated numerical outputs.

Back to top ↑

SQL Workflow: Eigenstructure Assumption Registry

SQL can document eigenstructure assumptions when modal analysis supports dashboards, system audits, scientific-computing pipelines, network reports, stability reviews, or institutional decisions.

CREATE TABLE eigenstructure_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 eigenstructure_assumption_registry VALUES
(
  'matrix_definition',
  'Matrix definition',
  'Defines the transformation whose eigenstructure is analyzed.',
  'Determines what system behavior the modes can represent.',
  'Eigenmodes inherit meaning from matrix construction, units, and weights.'
);

INSERT INTO eigenstructure_assumption_registry VALUES
(
  'eigenvalue',
  'Eigenvalue',
  'Scaling factor along an eigenvector direction.',
  'Represents growth, decay, persistence, reversal, or oscillatory structure.',
  'Eigenvalue meaning depends on time scale, model type, and transformation definition.'
);

INSERT INTO eigenstructure_assumption_registry VALUES
(
  'eigenvector',
  'Eigenvector',
  'Invariant direction of a linear transformation.',
  'Represents a system mode or pattern that evolves by scaling.',
  'Eigenvectors are not automatically causal mechanisms.'
);

INSERT INTO eigenstructure_assumption_registry VALUES
(
  'spectral_radius',
  'Spectral radius',
  'Largest eigenvalue magnitude.',
  'Often controls asymptotic behavior in repeated linear systems.',
  'Nonnormal matrices may have important transient behavior not captured by eigenvalues alone.'
);

INSERT INTO eigenstructure_assumption_registry VALUES
(
  'dominant_mode',
  'Dominant mode',
  'Mode associated with the largest eigenvalue magnitude.',
  'May dominate long-run behavior under suitable assumptions.',
  'Dominance depends on initial conditions, spectral gap, and model validity.'
);

INSERT INTO eigenstructure_assumption_registry VALUES
(
  'eigenpair_residual',
  'Eigenpair residual',
  'Measures how well Av equals lambda v numerically.',
  'Supports auditability of computed eigenvalues and eigenvectors.',
  'Small numerical residual does not guarantee substantive interpretation.'
);

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

This registry keeps eigenanalysis tied to matrix definition, eigenvalue behavior, eigenvector meaning, spectral-radius interpretation, dominant-mode assumptions, and numerical diagnostics.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports eigenvalue audits, eigenvector diagnostics, spectral-radius reports, dominant-mode analysis, stability classification, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Eigenvalues and eigenvectors are powerful because they identify system modes. They are limited because modes inherit meaning from the matrix being analyzed. If the matrix is poorly constructed, badly scaled, outdated, biased, oversimplified, or disconnected from the real system, its eigenstructure can be mathematically correct but substantively misleading.

Eigenvectors are not automatically causal mechanisms. A dominant eigenvector may reveal a pattern of influence, centrality, growth, or variation, but that pattern may reflect data encoding, measurement choices, network construction, normalization, or modeling assumptions. Eigenvalues can suggest stability or instability, but nonlinear behavior, constraints, thresholds, feedback, external forcing, and time-varying parameters may change the real system’s behavior.

Responsible use requires documenting the matrix definition, units, scaling, time step, data source, transformation meaning, numerical method, eigenpair residuals, spectral gap, conditioning, stability assumptions, and whether eigenstructure is being used for explanation, approximation, prediction, simulation, network analysis, control, optimization, or decision support.

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
• Matrix Multiplication and Interaction Effects
• Change of Basis and Alternative Representations
• Projections, Reflections, and Geometric Interpretation
• Orthogonality and Structured Simplification
• Inner Products, Norms, and Distance in State Space
• 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/.
• 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/.
• 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.
• 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 ↑

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.
• 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 ↑