Matrix Differential Equations: How Linear Algebra Models Continuous-Time System Change

Last Updated June 29, 2026

Matrix differential equations explain how systems evolve continuously through coupled linear rates of change. Instead of updating a state vector one step at a time, a matrix differential equation describes how the state changes at every instant. The system matrix links each variable’s rate of change to the current state of the full system, making continuous-time dynamics analyzable through eigenvalues, eigenvectors, matrix exponentials, stability, forcing, equilibrium, and numerical simulation.

This article extends linear dynamical systems into continuous time. It connects state vectors, derivative vectors, system matrices, coupled differential equations, matrix exponentials, eigenvalues, eigenvectors, diagonalization, stability, equilibrium, forced response, fundamental matrices, state-space models, numerical integration, stiffness, linearization, and responsible systems interpretation.

The central modeling question is not only “What is the differential equation?” It is “What does the matrix of rates imply about continuous system behavior, and when is a linear differential model a defensible representation of the system being studied?”

A matrix differential equation represents a continuous-time system using a state vector and a matrix of rate relationships. Each coordinate of the state may influence the rate of change of other coordinates. This makes the model useful for coupled physical systems, population dynamics, economic adjustment, infrastructure stress, signal processing, epidemiological approximations, control theory, and scientific computation.

The basic linear form is compact, but its implications can be deep. Eigenvalues classify whether modes decay, amplify, oscillate, or persist. Eigenvectors identify modal directions. The matrix exponential advances the state through time. Forced systems introduce external inputs. Numerical methods approximate trajectories when closed-form analysis is difficult. The modeler must keep the time interpretation, matrix construction, stability rule, and domain assumptions explicit.

Why Matrix Differential Equations Matter

Matrix differential equations matter because many systems change continuously rather than in isolated steps. Temperature, velocity, pressure, stress, concentration, capital adjustment, disease progression, population flow, control response, and signal dynamics often depend on rates of change. When several quantities change together, a matrix can organize how each variable affects the others.

Linear algebra makes continuous-time systems analyzable. A state vector records the current system condition. A derivative vector records the instantaneous rate of change. A matrix connects the current state to those rates. The resulting model can be solved, simulated, decomposed, stabilized, or criticized using matrix methods.

Matrix differential equations turn continuous change into a structured linear algebra problem.

Back to top ↑

State Vectors and Rates of Change

A continuous-time state vector records the system at time \(t\):

The derivative vector records instantaneous rates of change:

In systems modeling, state variables must be carefully chosen. Continuous-time models require units that make rate relationships meaningful. If a state variable is measured in dollars, people, tons, degrees, vehicles, infections, or stress units, its derivative has corresponding units per unit time.

A matrix differential equation begins with a state vector, but the state vector must be meaningful before the mathematics can be trusted.

Back to top ↑

The Basic Matrix Differential Equation

The basic homogeneous linear matrix differential equation is:

The matrix \(A\) is the system matrix. Its entries describe how each state variable contributes to each rate of change. In a two-variable system, this means:

This compact equation is the continuous-time counterpart of discrete linear dynamics. It is simple enough to analyze and rich enough to capture many patterns of coupled system change.

Back to top ↑

Coupled Systems of Differential Equations

A matrix differential equation is a system of coupled scalar differential equations. For example:

Coupling is what makes matrix representation powerful. Instead of studying each equation separately, the modeler can study the system as one linear transformation from state to rate.

Matrix notation does not hide the equations; it organizes them so system-level behavior can be analyzed.

Back to top ↑

The Matrix Exponential

The solution to the homogeneous linear system is written using the matrix exponential:

The matrix exponential is defined by a power series:

This formula connects continuous-time dynamics to matrix powers. In discrete time, \(A^t\) advances the state by repeated steps. In continuous time, \(e^{At}\) advances the state by continuous flow.

The matrix exponential is the continuous-time engine of linear dynamical analysis.

Back to top ↑

Eigenvalues and Continuous-Time Modes

Eigenvalues describe the modes of a matrix differential equation. If \(A\mathbf{v}=\lambda\mathbf{v}\), then along the eigenvector direction \(\mathbf{v}\), the solution behaves like:

This is the continuous-time counterpart of discrete-time modal behavior \(A^t\mathbf{v}=\lambda^t\mathbf{v}\). The difference is crucial: in continuous time, stability depends on the real part of eigenvalues, not on eigenvalue magnitude relative to one.

Eigenvalues convert a coupled continuous-time system into modal growth, decay, and oscillation patterns.

Back to top ↑

Continuous-Time Stability

For the homogeneous system \(\frac{d\mathbf{x}}{dt}=A\mathbf{x}\), asymptotic stability generally requires all eigenvalues of \(A\) to have negative real parts:

This differs from discrete-time stability, where eigenvalues must lie inside the unit circle. The same numeric matrix can mean different things depending on whether it is interpreted as a discrete update matrix or as a continuous-time generator.

Continuous-time stability should always be reported with the time interpretation of the matrix. A matrix used as a generator is not the same kind of object as a one-step transition matrix.

Back to top ↑

Diagonalization and Decoupling

If the system matrix is diagonalizable, it can be written as:

The matrix exponential becomes:

Because \(D\) is diagonal:

Diagonalization can make matrix differential equations interpretable, but only when the modal basis is valid, well-conditioned, and meaningful for the system.

Back to top ↑

Oscillation and Complex Eigenvalues

Complex eigenvalues naturally produce oscillatory behavior. If an eigenvalue has the form:

The corresponding exponential is:

Oscillatory modes are common in systems with exchange, feedback, inertia, predator-prey approximation, economic adjustment, control loops, and physical motion.

Back to top ↑

Forced Matrix Differential Equations

Many systems include external input, forcing, intervention, or control. A forced linear matrix differential equation has the form:

With an input matrix, the state-space form is:

The solution includes both the natural response and the accumulated forced response:

Forced matrix differential equations lead naturally into control systems modeling, where input design, response, controllability, observability, and stabilization become central.

Back to top ↑

Equilibrium and Steady State

An equilibrium occurs when the derivative is zero. For the homogeneous system:

For a constant forced system:

An equilibrium satisfies:

If \(A\) is invertible, then:

Equilibrium is a mathematical condition. Its meaning depends on the system, units, constraints, and values attached to the modeled state.

Back to top ↑

Fundamental Matrix Solutions

A fundamental matrix solution organizes a full set of independent solutions into a matrix. For the homogeneous system:

A fundamental matrix \(\Phi(t)\) satisfies:

When \(\Phi(0)=I\), the fundamental matrix is the matrix exponential:

Fundamental matrices generalize the idea of using a basis to describe all possible system trajectories.

Back to top ↑

Discrete Versus Continuous Time

Discrete-time and continuous-time linear systems are related but not interchangeable. Discrete systems update by steps:

Continuous systems evolve through rates:

Their evolution operators differ:

Confusing discrete and continuous interpretations is one of the most serious errors in matrix dynamics. The matrix’s meaning changes with the time model.

Back to top ↑

Numerical Simulation and Stiffness

Matrix differential equations can sometimes be solved analytically, but computation is often necessary. Numerical workflows may compute the matrix exponential directly, integrate the system using ordinary differential equation solvers, or simulate forced systems over time.

Numerical reliability matters. Some systems are stiff: they contain fast and slow modes together. A stiff system may be stable in theory but difficult to simulate accurately with naive time-stepping methods.

Numerical simulation should be treated as part of the model audit, not merely as a way to produce plots.

Back to top ↑

Matrix Differential Equations in Systems Modeling

Matrix differential equations are useful when system variables change continuously and interact through approximately linear rates. They can describe physical motion, engineering response, control systems, economic adjustment, ecological coupling, epidemiological approximations, chemical systems, infrastructure stress, financial dynamics, signal processing, and scientific computation.

The same form can represent different modeling commitments. In one context, \(A\) may be derived from physical law. In another, it may be estimated from data. In another, it may be a local Jacobian near equilibrium. In another, it may be an exploratory scenario matrix. These are not equivalent uses.

Matrix differential equations are powerful because they make coupled continuous change mathematically transparent. They are risky when the transparency is mistaken for completeness.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Matrix differential equations connect linear ordinary differential equations, state-space representation, matrix exponentials, eigenvalues, eigenvectors, diagonalization, Jordan forms, fundamental matrices, variation of constants, stability theory, stiff systems, numerical integration, local linearization, controllability, observability, and model validation.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for matrix differential equations should document the state variables, units, time scale, system matrix, initial condition, eigenvalues, real parts, stability classification, matrix exponential or numerical solver, trajectory horizon, forced inputs, equilibrium checks, stiffness diagnostics, constraint checks, sensitivity tests, and interpretation warnings.

The companion repository treats matrix differential equations as auditable continuous-time systems models. 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 continuous-time linear dynamics analysis.

For this article, the computational examples focus on matrix-exponential intuition, eigenvalue real-part stability, trajectory diagnostics, equilibrium review, stiffness warnings, and governance records for continuous-time model claims.

Back to top ↑

Python Workflow: Matrix Differential Equation Audit

The Python workflow below audits a two-state continuous-time system, computes real eigenvalues for a teaching matrix, classifies continuous-time stability by eigenvalue real parts, simulates a simple closed-form trajectory for diagonalizable real modes, and writes reproducible outputs.

from __future__ import annotations

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


Matrix = list[list[float]]
Vector = list[float]


@dataclass(frozen=True)
class MatrixDifferentialAudit:
    system_name: str
    state_names: str
    system_matrix: str
    initial_state: str
    time_horizon: float
    eigenvalue_1: float
    eigenvalue_2: float
    max_real_part: float
    stability_classification: str
    final_state_estimate: str
    initial_norm: float
    final_norm: float
    time_model_warning: str
    interpretation_warning: str


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


def vector_to_string(x: Vector) -> str:
    return ",".join(f"{value:.6f}" for value in x)


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


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


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


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


def classify_continuous(max_real_part: float) -> str:
    if max_real_part < 0.0:
        return "asymptotically_stable_continuous_time"
    if abs(max_real_part) <= 1e-10:
        return "boundary_or_marginal_continuous_time"
    return "unstable_continuous_time"


def matvec(A: Matrix, x: Vector) -> Vector:
    return [sum(A[i][j] * x[j] for j in range(len(x))) for i in range(len(A))]


def euler_simulate(A: Matrix, x0: Vector, horizon: float, dt: float) -> Vector:
    steps = int(round(horizon / dt))
    x = x0[:]
    for _ in range(steps):
        dx = matvec(A, x)
        x = [x[i] + dt * dx[i] for i in range(len(x))]
    return x


def build_audit() -> MatrixDifferentialAudit:
    state_names = ["infrastructure_stress", "service_delay"]

    # Continuous-time generator-style matrix:
    # negative diagonal damping with positive cross-coupling.
    A = [
        [-0.28, 0.08],
        [0.12, -0.34],
    ]

    x0 = [10.0, 4.0]
    horizon = 10.0
    dt = 0.01

    eigenvalues = eigenvalues_2x2_real(A)
    max_real_part = max(eigenvalues)
    final_state = euler_simulate(A, x0, horizon, dt)

    return MatrixDifferentialAudit(
        system_name="two_state_matrix_differential_equation_audit",
        state_names="|".join(state_names),
        system_matrix=matrix_to_string(A),
        initial_state=vector_to_string(x0),
        time_horizon=horizon,
        eigenvalue_1=round(eigenvalues[0], 12),
        eigenvalue_2=round(eigenvalues[1], 12),
        max_real_part=round(max_real_part, 12),
        stability_classification=classify_continuous(max_real_part),
        final_state_estimate=vector_to_string(final_state),
        initial_norm=round(norm2(x0), 12),
        final_norm=round(norm2(final_state), 12),
        time_model_warning=(
            "This matrix is interpreted as a continuous-time generator. "
            "Do not apply discrete-time spectral-radius rules to it."
        ),
        interpretation_warning=(
            "Matrix differential equations depend on state definitions, units, time scale, "
            "matrix source, linearity assumptions, solver choices, stiffness review, and domain constraints."
        ),
    )


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


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

This workflow keeps the continuous-time interpretation, eigenvalue real-part classification, trajectory estimate, and modeling warnings together.

Back to top ↑

R Workflow: Continuous-Time Stability Diagnostics

R can support matrix differential equation diagnostics by computing eigenvalues, classifying continuous-time stability, and simulating a trajectory with a simple numerical method.

A <- matrix(
  c(
    -0.28, 0.08,
     0.12, -0.34
  ),
  nrow = 2,
  byrow = TRUE
)

state_names <- c("infrastructure_stress", "service_delay")
x0 <- c(10.0, 4.0)
horizon <- 10.0
dt <- 0.01
steps <- as.integer(round(horizon / dt))

trajectory <- matrix(NA, nrow = steps + 1, ncol = length(x0))
trajectory[1, ] <- x0

for (k in seq_len(steps)) {
  dx <- A %*% trajectory[k, ]
  trajectory[k + 1, ] <- trajectory[k, ] + dt * as.numeric(dx)
}

state_norms <- apply(trajectory, 1, function(row) sqrt(sum(row^2)))
eigen_values <- eigen(A)$values
max_real_part <- max(Re(eigen_values))

stability_classification <- ifelse(
  max_real_part < 0,
  "asymptotically_stable_continuous_time",
  ifelse(abs(max_real_part) <= 1e-10, "boundary_or_marginal_continuous_time", "unstable_continuous_time")
)

audit_record <- data.frame(
  system_name = "two_state_matrix_differential_equation_audit",
  state_names = paste(state_names, collapse = "|"),
  system_matrix = paste(round(as.vector(t(A)), 6), collapse = ","),
  initial_state = paste(round(x0, 6), collapse = ","),
  time_horizon = horizon,
  final_state_estimate = paste(round(trajectory[steps + 1, ], 6), collapse = ","),
  initial_norm = state_norms[1],
  final_norm = state_norms[steps + 1],
  eigenvalues = paste(round(Re(eigen_values), 6), collapse = ","),
  max_real_part = max_real_part,
  stability_classification = stability_classification,
  interpretation_warning = paste(
    "Matrix differential equations require continuous-time stability rules,",
    "time-scale clarity, solver review, stiffness checks, and domain interpretation."
  )
)

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

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

trajectory_record <- data.frame(
  time = seq(0, horizon, by = dt),
  infrastructure_stress = trajectory[, 1],
  service_delay = trajectory[, 2],
  state_norm = state_norms
)

write.csv(
  trajectory_record,
  "outputs/tables/r_matrix_differential_equation_trajectory.csv",
  row.names = FALSE
)

print(audit_record)

This R workflow makes continuous-time stability and finite-horizon trajectory behavior auditable as data.

Back to top ↑

Haskell Workflow: Typed Continuous-Time Records

Haskell can represent matrix differential equation diagnostics as typed records, keeping continuous-time interpretation, stability classification, and domain warnings explicit.

module Main where

data MatrixDifferentialAudit = MatrixDifferentialAudit
  { systemName :: String
  , stateNames :: String
  , systemMatrix :: String
  , initialState :: String
  , timeHorizon :: Double
  , eigenvalues :: String
  , maxRealPart :: Double
  , stabilityClassification :: String
  , finalStateEstimate :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: MatrixDifferentialAudit
buildAudit =
  MatrixDifferentialAudit
    "two_state_matrix_differential_equation_audit"
    "infrastructure_stress|service_delay"
    "-0.280000,0.080000;0.120000,-0.340000"
    "10.000000,4.000000"
    10.0
    "-0.200000,-0.420000"
    (-0.20)
    "asymptotically_stable_continuous_time"
    "1.558000,0.882000"
    "Matrix differential equations depend on state definitions, units, time scale, solver choices, stiffness review, and domain constraints."

main :: IO ()
main =
  print buildAudit

The typed workflow helps prevent a common modeling error: treating a continuous-time generator as though it were a discrete-time transition matrix.

Back to top ↑

SQL Workflow: Matrix Differential Equation Assumption Registry

SQL can document continuous-time modeling assumptions when matrix differential equations support dashboards, simulations, engineering review, infrastructure planning, public-health modeling, scientific workflows, or institutional decision systems.

CREATE TABLE matrix_differential_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_differential_assumption_registry VALUES
(
  'state_vector',
  'State vector',
  'Defines the coordinates of continuous-time system state.',
  'Determines what the model can track through time.',
  'State variables require units, scales, and domain definitions.'
);

INSERT INTO matrix_differential_assumption_registry VALUES
(
  'system_matrix',
  'System matrix',
  'Maps current state into instantaneous rate of change.',
  'Encodes rate coupling among variables.',
  'Matrix entries are rate parameters and require time-unit clarity.'
);

INSERT INTO matrix_differential_assumption_registry VALUES
(
  'continuous_time',
  'Continuous-time interpretation',
  'Uses dx/dt = Ax rather than x_{t+1} = Ax_t.',
  'Determines the correct evolution operator and stability rule.',
  'Do not apply discrete-time spectral-radius rules to a continuous-time generator.'
);

INSERT INTO matrix_differential_assumption_registry VALUES
(
  'matrix_exponential',
  'Matrix exponential',
  'Advances the initial state through continuous time.',
  'Represents the continuous state transition operator.',
  'Numerical computation of exp(At) should use reliable algorithms.'
);

INSERT INTO matrix_differential_assumption_registry VALUES
(
  'stability',
  'Continuous-time stability',
  'Classifies modes using eigenvalue real parts.',
  'Shows whether disturbances decay, persist, oscillate, or amplify.',
  'Stable eigenvalues do not automatically imply practical safety or desirability.'
);

INSERT INTO matrix_differential_assumption_registry VALUES
(
  'solver_review',
  'Solver review',
  'Checks numerical integration method, step size, and stiffness.',
  'Determines whether simulated trajectories are reliable.',
  'Naive time stepping can distort stiff or sensitive continuous systems.'
);

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

This registry keeps matrix differential equation analysis tied to state design, rate interpretation, continuous-time stability, matrix exponentials, solver reliability, 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 differential equation audits, continuous-time stability diagnostics, eigenvalue real-part reports, matrix-exponential interpretation, trajectory simulation, solver review, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Matrix differential equations are powerful because they make continuous coupled change mathematically tractable. They can reveal modal structure, damping, amplification, oscillation, equilibrium, forced response, and stability. Their limits arise because real systems may be nonlinear, threshold-driven, constrained, adaptive, discontinuous, stochastic, delayed, spatially heterogeneous, or institutionally shaped.

A matrix differential equation may represent a physical law, an engineering state-space model, a local Jacobian approximation, an empirical continuous-time fit, a simplified policy model, or a scenario abstraction. These uses require different evidence. A model derived from conservation laws is different from a matrix estimated from sparse observational data. A local linearization near equilibrium is different from a global claim about the whole system.

Responsible use requires documenting state variables, units, time scale, matrix source, rate interpretation, initial conditions, forcing terms, equilibrium assumptions, eigenvalues, stability classification, numerical solver, stiffness diagnostics, constraint checks, uncertainty, sensitivity tests, and the practical horizon over which the linear continuous-time model should be trusted. Matrix differential equations should clarify continuous dynamics without pretending that linear rates fully describe complex systems.

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
• Eigenvalues, Eigenvectors, and System Modes
• Diagonalization and Decoupled System Behavior
• Stability Analysis with Eigenvalues
• Markov Chains and Transition Matrices
• Long-Run Behavior in State Transition Systems
• Linear Dynamical Systems
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Differential Equations for Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• 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/.
• Chen, C.-T. (1999) Linear System Theory and Design. 3rd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/linear-system-theory-and-design-9780195117776.
• 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.
• Hirsch, M.W., Smale, S. and Devaney, R.L. (2013) Differential Equations, Dynamical Systems, and an Introduction to Chaos. 3rd edn. Amsterdam: Academic Press. Available at: https://www.elsevier.com/books/differential-equations-dynamical-systems-and-an-introduction-to-chaos/hirsch/978-0-12-382010-5.
• Higham, N.J. (2008) Functions of Matrices: Theory and Computation. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898717778.
• 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.
• Kailath, T. (1980) Linear Systems. Englewood Cliffs, NJ: Prentice Hall. Available at: https://archive.org/details/linearsystems0000kail.
• Khalil, H.K. (2002) Nonlinear Systems. 3rd edn. Upper Saddle River, NJ: Prentice Hall. Available at: https://www.egr.msu.edu/~khalil/NonlinearSystems/.
• 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 (2011) Dynamic Systems and Control. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/6-241j-dynamic-systems-and-control-spring-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2014) Differential Equations. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-03sc-differential-equations-fall-2011/.
• 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.
• 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.
• SciPy Developers (n.d.) Integration and ODEs: scipy.integrate. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/integrate.html.
• SciPy Developers (n.d.) Matrix Exponential: scipy.linalg.expm. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html.
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos. 2nd edn. Boca Raton, FL: CRC Press. Available at: https://www.routledge.com/Nonlinear-Dynamics-and-Chaos-With-Applications-to-Physics-Biology-Chemistry-and-Engineering/Strogatz/p/book/9780813349107.
• 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.

Back to top ↑

References

• 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/.
• Chen, C.-T. (1999) Linear System Theory and Design. 3rd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/linear-system-theory-and-design-9780195117776.
• 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.
• Hirsch, M.W., Smale, S. and Devaney, R.L. (2013) Differential Equations, Dynamical Systems, and an Introduction to Chaos. 3rd edn. Amsterdam: Academic Press. Available at: https://www.elsevier.com/books/differential-equations-dynamical-systems-and-an-introduction-to-chaos/hirsch/978-0-12-382010-5.
• Higham, N.J. (2008) Functions of Matrices: Theory and Computation. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898717778.
• 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.
• Kailath, T. (1980) Linear Systems. Englewood Cliffs, NJ: Prentice Hall. Available at: https://archive.org/details/linearsystems0000kail.
• Khalil, H.K. (2002) Nonlinear Systems. 3rd edn. Upper Saddle River, NJ: Prentice Hall. Available at: https://www.egr.msu.edu/~khalil/NonlinearSystems/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Dynamic Systems and Control. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/6-241j-dynamic-systems-and-control-spring-2011/.
• Massachusetts Institute of Technology OpenCourseWare (2014) Differential Equations. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-03sc-differential-equations-fall-2011/.
• 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.
• 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.
• SciPy Developers (n.d.) Integration and ODEs: scipy.integrate. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/integrate.html.
• SciPy Developers (n.d.) Matrix Exponential: scipy.linalg.expm. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html.
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos. 2nd edn. Boca Raton, FL: CRC Press. Available at: https://www.routledge.com/Nonlinear-Dynamics-and-Chaos-With-Applications-to-Physics-Biology-Chemistry-and-Engineering/Strogatz/p/book/9780813349107.
• 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.

Back to top ↑