Span, Linear Independence, and Basis: How Linear Algebra Finds Essential System Directions

Last Updated June 28, 2026

Span, linear independence, and basis explain what a model can generate, what information is redundant, and which directions are essential for representing a system. Span describes the states or directions that can be built from a set of vectors. Linear independence asks whether any vector is unnecessary because it can be built from the others. A basis is a compact, nonredundant set of vectors that can represent an entire space.

This article connects these ideas to systems modeling. It shows how span clarifies reachable states, intervention coverage, feature representation, scenario construction, and solution structure. It explains how linear dependence reveals redundancy, hidden duplication, or overcounted information. It shows why a basis matters for coordinates, dimension, efficient representation, interpretable modeling, and responsible simplification.

The central modeling question is not only “Do these vectors span a space?” It is “What system possibilities do these vectors make representable, what do they leave out, and which directions are truly necessary?”

Linear algebra becomes powerful for systems modeling when vectors are not treated as isolated objects. A collection of vectors can generate a space of possible states, scenarios, changes, interventions, or outputs. Some vectors add genuinely new directions. Others merely repeat information already contained in the collection. The difference determines whether a model has enough structure, too little structure, or unnecessary redundancy.

Span, linear independence, and basis provide a language for these questions. They help modelers ask whether selected indicators cover the relevant system dimensions, whether intervention vectors can reach desired states, whether feature sets contain redundant information, whether constraints reduce possible solutions, and whether a smaller representation can preserve the structure that matters.

Why Span, Independence, and Basis Matter

Span, linear independence, and basis matter because they explain the representational power of a vector collection. A model may include many variables, indicators, scenarios, interventions, or features. But the number of listed components does not automatically reveal how much structure the model can express. Some vectors may point in genuinely different directions. Others may be combinations of what is already present.

In systems modeling, this distinction is crucial. If a set of policy interventions all move the system in nearly the same direction, the intervention set may look broad while offering little real variety. If a dataset contains many features that are mostly linear combinations of one another, the model may appear information-rich while being redundant. If a matrix has low rank, its outputs may occupy only a smaller subspace even when many variables are listed.

For systems modeling, span asks what is reachable, expressible, constructible, or representable. Linear independence asks whether each vector contributes a genuinely new direction. A basis combines both ideas: it is a set that spans the space without redundancy.

Back to top ↑

Span as Generative Capacity

Span is a generative concept. It describes what a set of vectors can produce through linear combination. If vectors represent interventions, span describes the range of combined intervention effects. If vectors represent features, span describes the representational space those features can generate. If vectors represent scenarios, span describes the family of blended or constructed scenarios available to the model.

A span claim should always be interpreted relative to the chosen representation. Saying that a set of vectors spans \(\mathbb{R}^3\) means that every three-component vector can be generated mathematically. It does not mean that every generated vector is meaningful, feasible, ethical, physically possible, or empirically plausible.

Span therefore acts as an audit of possibility. It asks what the model can generate from the elements it has been given.

Back to top ↑

Linear Combinations and System Possibility

Linear combinations are the mechanism behind span. By assigning coefficients to vectors and adding them, a model constructs new vectors from existing ones. The coefficients may represent weights, proportions, intensities, policy levels, scenario shares, basis coordinates, or purely mathematical parameters.

When coefficients are unconstrained, span may include vectors that are mathematically valid but substantively unrealistic. For example, negative coefficients may be meaningful in some settings, such as subtracting a baseline, but invalid in others, such as allocating negative funding or negative population. Systems modeling often supplements span with feasibility constraints.

The algebraic operation is simple. The modeling interpretation is not. Linear combinations become meaningful only when the vectors and coefficients have documented roles.

Back to top ↑

Linear Dependence and Redundancy

A set of vectors is linearly dependent if at least one vector can be written as a linear combination of the others. In systems modeling, linear dependence often signals redundancy: a variable, indicator, intervention, feature, or scenario may not add a new independent direction.

Dependence is not always bad. Redundant measurements can improve reliability, support validation, or express the same phenomenon in different institutional languages. But dependence should be recognized. If a model treats dependent vectors as independent evidence, it may overcount information, exaggerate dimensionality, or produce unstable estimates.

Linear dependence helps identify where a model is less independent than it appears. It is a structural warning, not merely a numerical inconvenience.

Back to top ↑

Linear Independence and New Directions

A set of vectors is linearly independent when no vector in the set can be generated from the others. Each vector contributes a genuinely new direction to the representation.

In systems modeling, independence means that each vector adds a direction that was not already available. This matters for representation, estimation, intervention design, scenario analysis, feature selection, and model reduction. Independent vectors expand what the model can express.

Linear independence is not the same as substantive independence, causal independence, or ethical adequacy. Two vectors can be mathematically independent while still reflecting the same institutional bias or measurement limitation. But mathematical independence is a necessary structural check when the model claims independent representational directions.

Back to top ↑

Basis as Nonredundant Representation

A basis is a set of vectors that spans a space and is linearly independent. It has enough vectors to represent everything in the space, but no unnecessary vectors. This makes basis one of the most important ideas in linear algebra.

A basis gives coordinates. Once a basis is chosen, every vector in the space can be represented by a unique set of coefficients.

For systems modeling, a basis is a representational frame. It decides which directions count as fundamental. A standard basis may represent original variables. A policy basis may represent intervention levers. A principal-component basis may represent dominant patterns in data. A network basis may represent modes of flow or connectivity. Each basis has different interpretive consequences.

A basis is not only a computational convenience. It is a modeling decision about what counts as a fundamental direction in the system.

Back to top ↑

Coordinates and System Meaning

Coordinates express a vector relative to a basis. The same vector can have different coordinates under different bases. This is why basis choice matters: it changes how system states are described, even when the underlying state remains the same.

In a standard basis, coordinates may correspond directly to observed quantities. In a transformed basis, coordinates may correspond to abstract directions, latent factors, components, modes, or reduced features. These transformed coordinates can be mathematically useful, but their system meaning must be interpreted with care.

Coordinates are not neutral labels. They are basis-dependent descriptions of a system state.

Back to top ↑

Rank, Span, and Model Capacity

Rank measures the dimension of the space spanned by a set of vectors, often the columns or rows of a matrix. In systems modeling, rank helps diagnose how much independent structure a matrix or dataset actually contains.

Rank can reveal hidden limitations. A matrix with many columns may still have low rank if the columns are dependent. A system with many equations may contain redundant constraints. A dataset with many features may occupy a lower-dimensional subspace. A policy portfolio with many interventions may offer only a few distinct directions of change.

Rank should be interpreted as a structural diagnostic. It tells what is independent within the mathematical representation, not whether the model is substantively complete.

Back to top ↑

Overcomplete and Undercomplete Representations

Some representations include more vectors than necessary. Others include too few vectors to span the target space. Both situations matter for systems modeling.

An overcomplete representation may contain redundancy. This can be useful when redundancy provides robustness, multiple measurement channels, or flexible approximation. But it can also cause overcounting, instability, and confusing interpretation. An undercomplete representation is simpler, but it may be unable to represent important states, scenarios, or directions.

The goal is not always the smallest possible representation. The goal is an adequate representation for the modeling purpose, with redundancy, omission, and interpretability made explicit.

Back to top ↑

Span in Systems Modeling

Span appears whenever systems modeling asks what can be produced, reached, represented, or explained by available vectors. These vectors may represent interventions, scenarios, outputs, features, constraints, flows, or state changes.

This idea can be applied to policy planning, system design, data representation, and model validation. If the target lies outside the span, the model cannot reach or represent it using the current vector set. That may reveal a genuine limitation of available actions, or it may reveal a limitation of the chosen representation.

Span helps modelers see not just what the model includes, but what the model is capable of constructing from what it includes.

Back to top ↑

Basis Choice and Interpretability

Basis choice affects interpretation. The same system may be represented in a basis of original variables, intervention levers, statistical components, network modes, or abstract computational features. Each basis can reveal some structure while hiding other structure.

For example, a public-policy model may use a standard basis in which each coordinate is a familiar indicator: employment, housing affordability, emissions, public health, educational attainment, and infrastructure reliability. A transformed basis may combine these into broader patterns. The transformed basis may be useful for computation, but it can be harder to explain to stakeholders.

A basis can make a model elegant, efficient, and powerful. It can also make a model opaque. Responsible modeling requires documenting both the computational advantages and the interpretive costs of the chosen basis.

Back to top ↑

Systems Modeling Interpretation

Span, linear independence, and basis turn vector collections into representational architecture. They help identify what a model can express, where it contains redundancy, which directions are essential, and how states are coordinated. These are not only abstract mathematical questions. They shape model capacity, model limits, interpretability, and governance.

The responsible question is not only “Are the vectors independent?” It is “Independent with respect to what system representation?” A set of vectors may be mathematically independent while still omitting important system dimensions. A set may be dependent while still useful for measurement reliability. A basis may be computationally convenient while difficult to interpret. A span may be mathematically broad while substantively infeasible.

For systems modeling, these concepts should be used as audit tools. They clarify the relationship between formal structure and system meaning. A good model should explain what its vectors span, what they do not span, where redundancy exists, what basis is used, and what interpretive claims are justified by that representation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Span, linear independence, and basis connect linear combinations, generating sets, redundancy, rank, coordinates, dimension, solution spaces, feature selection, model reduction, and representational governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for span, linear independence, and basis should document the vector set, component meanings, matrix orientation, rank method, tolerance, basis selection rule, redundancy findings, generated outputs, and interpretation warnings. A rank computation alone is not enough. The workflow must preserve what the vectors represent.

The companion repository treats span and basis analysis 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 whether candidate vectors span a three-dimensional system representation, identifying rank, and recording whether the vector set is a basis.

Back to top ↑

Python Workflow: Span and Basis Audit

The Python workflow below evaluates a candidate set of vectors, computes rank by row reduction, and records whether the vectors form a basis for the represented space.

from __future__ import annotations

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


@dataclass(frozen=True)
class SpanBasisAudit:
    vector_set_name: str
    ambient_dimension: int
    vector_count: int
    rank: int
    spans_ambient_space: bool
    linearly_independent: bool
    is_basis_for_ambient_space: bool
    modeling_role: str
    interpretation_warning: str


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

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

        if pivot is None:
            continue

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

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

        rank += 1

    return rank


def build_audit() -> SpanBasisAudit:
    candidate_vectors_as_columns = [
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
        [0.5, 0.5, 1.0],
    ]

    matrix = [
        [candidate_vectors_as_columns[col][row] for col in range(len(candidate_vectors_as_columns))]
        for row in range(3)
    ]

    ambient_dimension = 3
    vector_count = len(candidate_vectors_as_columns)
    rank = matrix_rank(matrix)

    spans_ambient_space = rank == ambient_dimension
    linearly_independent = rank == vector_count
    is_basis = spans_ambient_space and linearly_independent

    return SpanBasisAudit(
        vector_set_name="candidate_system_basis",
        ambient_dimension=ambient_dimension,
        vector_count=vector_count,
        rank=rank,
        spans_ambient_space=spans_ambient_space,
        linearly_independent=linearly_independent,
        is_basis_for_ambient_space=is_basis,
        modeling_role="Candidate basis vectors for a simplified system representation.",
        interpretation_warning=(
            "A basis for the mathematical representation is not automatically an adequate "
            "basis for the real system. Component choice and omitted dimensions still matter."
        ),
    )


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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Span and basis audit complete.")

This workflow separates the mathematical basis claim from the systems claim. It can verify that vectors form a basis for the chosen representation, but it cannot prove that the chosen representation captures everything important about the real system.

Back to top ↑

R Workflow: Linear Independence and Rank Check

R can support quick span and independence checks using QR decomposition. The workflow below evaluates whether three candidate vectors form a basis for a three-dimensional representation.

candidate_matrix <- matrix(
  c(
    1.0, 0.0, 0.5,
    0.0, 1.0, 0.5,
    0.0, 0.0, 1.0
  ),
  nrow = 3,
  byrow = TRUE
)

ambient_dimension <- nrow(candidate_matrix)
vector_count <- ncol(candidate_matrix)
rank_value <- qr(candidate_matrix)$rank

spans_ambient_space <- rank_value == ambient_dimension
linearly_independent <- rank_value == vector_count
is_basis_for_ambient_space <- spans_ambient_space && linearly_independent

audit_record <- data.frame(
  vector_set_name = "candidate_system_basis",
  ambient_dimension = ambient_dimension,
  vector_count = vector_count,
  rank = rank_value,
  spans_ambient_space = spans_ambient_space,
  linearly_independent = linearly_independent,
  is_basis_for_ambient_space = is_basis_for_ambient_space,
  modeling_role = "Candidate basis vectors for a simplified system representation.",
  interpretation_warning = paste(
    "A basis for the mathematical representation is not automatically",
    "an adequate basis for the real system."
  )
)

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

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

print(audit_record)

This R workflow is useful for feature diagnostics, indicator review, rank checks, model-reduction workflows, and reproducible reporting.

Back to top ↑

Haskell Workflow: Typed Basis Records

Haskell can represent basis claims with explicit fields for ambient dimension, vector count, rank, span status, independence status, and interpretation warnings. This keeps mathematical claims separate from modeling claims.

module Main where

data SpanBasisAudit = SpanBasisAudit
  { vectorSetName :: String
  , ambientDimension :: Int
  , vectorCount :: Int
  , rankValue :: Int
  , spansAmbientSpace :: Bool
  , linearlyIndependent :: Bool
  , isBasisForAmbientSpace :: Bool
  , modelingRole :: String
  , interpretationWarning :: String
  } deriving (Show)

determinant3x3 :: [[Double]] -> Double
determinant3x3 m =
  let a = (m !! 0) !! 0
      b = (m !! 0) !! 1
      c = (m !! 0) !! 2
      d = (m !! 1) !! 0
      e = (m !! 1) !! 1
      f = (m !! 1) !! 2
      g = (m !! 2) !! 0
      h = (m !! 2) !! 1
      i = (m !! 2) !! 2
  in a * (e * i - f * h)
     - b * (d * i - f * g)
     + c * (d * h - e * g)

rank3x3Simple :: [[Double]] -> Int
rank3x3Simple matrix =
  if abs (determinant3x3 matrix) > 1e-10
  then 3
  else 2

buildAudit :: SpanBasisAudit
buildAudit =
  let matrix =
        [ [1.0, 0.0, 0.5]
        , [0.0, 1.0, 0.5]
        , [0.0, 0.0, 1.0]
        ]
      ambient = 3
      count = 3
      rank = rank3x3Simple matrix
      spans = rank == ambient
      independent = rank == count
      basis = spans && independent
  in SpanBasisAudit
      "candidate_system_basis"
      ambient
      count
      rank
      spans
      independent
      basis
      "Candidate basis vectors for a simplified system representation."
      "A mathematical basis claim does not prove real-world representational adequacy."

main :: IO ()
main =
  print buildAudit

The typed structure makes the model’s claims explicit. It does not collapse “rank equals dimension” into “the system has been adequately represented.”

Back to top ↑

SQL Workflow: Span and Basis Assumption Registry

SQL can document span, independence, and basis assumptions when model inputs support dashboards, institutional reports, reproducible workflows, public policy analysis, machine-learning systems, or infrastructure planning.

CREATE TABLE span_basis_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 span_basis_assumption_registry VALUES
(
  'span_claim',
  'Span claim',
  'States what vectors can generate through linear combination.',
  'Defines which states, interventions, scenarios, or changes are representable.',
  'A span claim is only meaningful relative to the chosen representation.'
);

INSERT INTO span_basis_assumption_registry VALUES
(
  'coefficient_meaning',
  'Coefficient meaning',
  'Defines how linear-combination weights are interpreted.',
  'Controls whether combinations represent proportions, intensities, coordinates, or abstract parameters.',
  'Unconstrained mathematical coefficients may not be feasible or meaningful.'
);

INSERT INTO span_basis_assumption_registry VALUES
(
  'linear_independence',
  'Linear independence',
  'Determines whether vectors contribute distinct directions.',
  'Identifies whether indicators, features, interventions, or scenarios add new structure.',
  'Mathematical independence does not prove substantive independence.'
);

INSERT INTO span_basis_assumption_registry VALUES
(
  'linear_dependence',
  'Linear dependence',
  'Identifies redundancy among vectors.',
  'Flags duplicated indicators, collinear features, redundant constraints, or repeated policy directions.',
  'Redundancy may be useful for validation, but should not be silently overcounted.'
);

INSERT INTO span_basis_assumption_registry VALUES
(
  'basis_choice',
  'Basis choice',
  'Defines a nonredundant spanning set for the representation.',
  'Controls coordinates, interpretability, model reduction, and transformation logic.',
  'A computationally convenient basis may not be substantively transparent.'
);

INSERT INTO span_basis_assumption_registry VALUES
(
  'rank_tolerance',
  'Rank tolerance',
  'Defines numerical threshold used to distinguish independence from dependence.',
  'Controls rank diagnostics and near-dependence warnings.',
  'Numerical rank can be sensitive to scaling, noise, and tolerance choices.'
);

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

This registry keeps formal claims tied to modeling interpretation. It documents what the vector set is supposed to span, what coefficients mean, whether vectors are independent, what basis is used, and how numerical rank is reviewed.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports span diagnostics, linear-independence checks, basis audits, rank calculations, redundancy reviews, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Span, linear independence, and basis are powerful structural concepts, but they can be misused when mathematical representation is confused with real-world adequacy. A set of vectors may span the chosen mathematical space while still omitting critical system dimensions. A set may be linearly independent while still reflecting the same biased measurement framework. A basis may be compact while being opaque to decision-makers or affected communities.

Responsible use requires documenting vector meaning, coefficient meaning, component units, basis choice, numerical tolerance, scaling choices, and excluded dimensions. Modelers should ask whether all vectors in the span are feasible, whether negative coefficients make sense, whether redundancy is harmful or useful, whether rank is stable, whether basis vectors are interpretable, and whether the chosen representation supports the modeling purpose.

The danger is not that span, independence, or basis are abstract. Abstraction is necessary. The danger is treating abstraction as completeness. These concepts help clarify model structure, but they do not eliminate the need for judgment about system boundaries, measurement, feasibility, interpretation, and governance.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Scalars, Vectors, and System States
• Vector Spaces and System Representation
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling
• Calculus for Systems Modeling
• Probability for Systems Modeling
• Statistics for Systems Modeling

Back to top ↑

Further Reading

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra.
• Hefferon, J. (n.d.) Linear Algebra.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin.
• National Institute of Standards and Technology (n.d.) Matrix Market.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage.
• Texas A&M University (n.d.) SuiteSparse Matrix Collection.
• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press.
• Society for Industrial and Applied Mathematics (n.d.) Applied Mathematics and Scientific Computing Books.

Back to top ↑

References

• Axler, S. (2024) Linear Algebra Done Right. 4th edn. Cham: Springer.
• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press.
• Cayley, A. (1858) A Memoir on the Theory of Matrices. London.
• Georgia Institute of Technology (n.d.) Interactive Linear Algebra.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press.
• Grassmann, H. (1844) Die lineale Ausdehnungslehre. Leipzig.
• Hefferon, J. (n.d.) Linear Algebra.
• Horn, R.A. and Johnson, C.R. (2013) Matrix Analysis. 2nd edn. Cambridge: Cambridge University Press.
• Lay, D.C., Lay, S.R. and McDonald, J.J. (2021) Linear Algebra and Its Applications. 6th edn. Boston, MA: Pearson.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare.
• Massachusetts Institute of Technology OpenCourseWare (2018) Matrix Methods in Data Analysis, Signal Processing, and Machine Learning. Cambridge, MA: MIT OpenCourseWare.
• Meyer, C.D. (2000) Matrix Analysis and Applied Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics.
• National Institute of Standards and Technology (n.d.) Matrix Market.
• Netlib (n.d.) LAPACK — Linear Algebra PACKage.
• Newman, M.E.J. (2010) Networks: An Introduction. Oxford: Oxford University Press.
• Strang, G. (2016) Introduction to Linear Algebra. Wellesley, MA: Wellesley-Cambridge Press.
• Texas A&M University (n.d.) SuiteSparse Matrix Collection.
• Treil, S. (2017) Linear Algebra Done Wrong. Providence, RI: Brown University.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: Society for Industrial and Applied Mathematics.
• van de Geijn, R. and Myers, M. (n.d.) Linear Algebra: Foundations to Frontiers. Austin, TX: The University of Texas at Austin.

Back to top ↑