Numerical Methods for Mathematical Models: How Computation Approximates Complex Systems

Last Updated June 12, 2026

Numerical methods for mathematical models turn equations, relationships, and dynamic systems into computable approximations. When exact solutions are unavailable, impractical, or too slow, numerical methods use algorithms, discretization, iteration, interpolation, optimization, simulation, and error control to estimate model behavior.

Many mathematical models cannot be solved neatly by hand. Nonlinear equations may resist closed-form solution. Differential equations may describe dynamics that require stepwise approximation. Spatial fields may need grids or meshes. Optimization problems may require iterative search. Stochastic systems may need repeated sampling. Numerical methods make these models usable.

But numerical methods are not neutral machinery. They make modeling choices. Step size, solver tolerance, mesh resolution, convergence criteria, stopping rules, precision, initialization, and algorithm selection all affect results. A numerical answer is not automatically exact simply because it is computed.

Responsible numerical modeling requires more than selecting a solver. It requires understanding what is being approximated, how approximation error enters, how stable the method is, whether results converge, how sensitive outputs are to numerical settings, and whether the computed result supports the model’s intended use.

Why Numerical Methods Matter

Numerical methods matter because mathematical modeling often reaches beyond exact formulas. A model may be clear conceptually but difficult computationally. It may contain nonlinear relationships, feedback loops, stochastic terms, large matrices, spatial fields, constraints, or differential equations that cannot be solved directly.

Numerical methods bridge this gap. They allow modelers to approximate solutions, run scenarios, solve systems, simulate dynamics, estimate integrals, fit parameters, optimize objectives, and evaluate uncertainty. They make mathematical modeling operational.

Numerical methods are therefore central to applied mathematical modeling. They are not an optional programming detail. They determine how a formal model becomes a computable result.

Back to top ↑

What a Numerical Method Is

A numerical method is an algorithm for approximating a mathematical quantity. It may approximate a solution, derivative, integral, trajectory, optimum, distribution, field, or system state. The method specifies a procedure, not merely an answer.

This means a numerical result is conditional on method settings. Two algorithms may approximate the same mathematical model but produce different results if the model is difficult, unstable, poorly scaled, or under-tested.

A numerical method should be chosen for the model’s mathematical structure, not merely for convenience. Smoothness, stiffness, dimensionality, constraints, noise, discontinuities, and scale all affect method choice.

Back to top ↑

Approximation, Not Exactness

Numerical methods produce approximations. Approximation is not a weakness; it is a disciplined way to make complex models usable. The danger comes when approximations are presented as exact truths.

Every approximation has a context. It depends on model specification, input values, algorithm, implementation, numerical settings, and computational environment. A result may be precise in format but uncertain in meaning.

Numerical responsibility begins by acknowledging approximation. A good computational workflow asks not only “what number did the solver produce?” but “how reliable is this approximation for the decision or explanation at hand?”

Back to top ↑

Roots, Equations, and Systems

Many models require solving equations. A root-finding problem asks where a function equals zero. This appears in equilibrium analysis, threshold detection, calibration, break-even analysis, constraint satisfaction, and model balancing.

Common numerical methods for root-finding include bisection, Newton’s method, secant methods, and hybrid solvers. Bisection is slower but robust when a sign change is bracketed. Newton’s method can be fast but sensitive to derivatives and starting points.

Solving an equation numerically is not just pressing “run.” The modeler must check residuals, convergence, starting values, scaling, multiple roots, and whether the solution makes substantive sense.

Back to top ↑

Numerical Differentiation and Integration

Numerical differentiation estimates rates of change from function values or data. Numerical integration estimates accumulated quantities such as total cost, total exposure, total flow, probability, or area under a curve.

These approximations depend on step size, smoothness, noise, and sampling pattern. A very small step may reduce truncation error but increase rounding error. A large step may miss curvature or local variation.

Numerical differentiation and integration are common in modeling because rates and accumulations are central to explanation. They should be paired with diagnostic checks rather than treated as mechanical preprocessing.

Back to top ↑

Numerical Methods for Differential Equations

Differential equations often require numerical solution. A continuous-time model may describe how a state changes, but a computer usually approximates that change through discrete steps.

The simplest method is Euler’s method:

More advanced methods include Runge-Kutta methods, adaptive step-size solvers, implicit methods, finite difference methods, finite element methods, and specialized solvers for stiff systems.

Numerical differential equation modeling should report solver choice, step-size logic, tolerance, boundary conditions, stability checks, and sensitivity to numerical settings.

Back to top ↑

Numerical Optimization Methods

Optimization models often require numerical methods to search for values that minimize or maximize an objective function under constraints. Some problems have analytical solutions, but many practical optimization problems do not.

Numerical optimization methods include gradient descent, Newton-type methods, linear programming algorithms, interior-point methods, evolutionary algorithms, simulated annealing, coordinate search, and stochastic optimization.

An optimizer’s output is not automatically the right decision. It is optimal relative to the objective, constraints, data, assumptions, algorithm, and tolerances used. Numerical optimization requires interpretive review, especially when outputs guide real-world allocation or policy.

Back to top ↑

Interpolation, Approximation, and Surrogate Models

Interpolation estimates values between known points. Approximation fits a simpler representation to a complex function, dataset, or simulation output. Surrogate models approximate expensive models so that analysts can explore scenarios faster.

These methods appear in spatial modeling, engineering design, uncertainty quantification, machine learning, forecasting, simulation emulation, and parameter exploration.

Approximation models should be validated within the domain where they are used. Extrapolation beyond known or simulated conditions can produce confident-looking but unsupported results.

Back to top ↑

Discretization, Grids, and Meshes

Discretization converts continuous time, space, or state into finite computational units. A continuous interval may become time steps. A spatial region may become grid cells. A complex domain may become a mesh. A continuous distribution may be represented by samples.

Discretization makes computation possible, but resolution affects results. A coarse grid may miss local structure. A fine grid may be computationally expensive. Poor mesh quality may distort numerical behavior.

Discretization should be documented as part of model design. A numerical result depends not only on equations, but also on how the model’s domain was cut into computable pieces.

Back to top ↑

Error, Stability, and Convergence

Error, stability, and convergence are central to numerical modeling. Error asks how far the approximation may be from the intended mathematical quantity. Stability asks whether small errors grow uncontrollably. Convergence asks whether the approximation approaches the intended value as computational resolution improves.

In many real models, the exact value is unknown. Modelers then use residuals, convergence tests, step-size comparisons, benchmark problems, conserved quantities, and cross-method comparisons.

Numerical diagnostics should be saved with model outputs. They are evidence about the computation’s credibility, not optional technical appendices.

Back to top ↑

Computational Cost, Precision, and Scalability

Numerical methods involve tradeoffs. More accurate methods may require more computation. Finer grids may require more memory. Larger ensembles may reduce sampling uncertainty but increase runtime. Higher precision may reduce rounding error but slow computation.

Computational cost matters because it shapes what can be tested. A model that is too expensive may discourage sensitivity analysis, uncertainty propagation, or validation. A model that is too simplified may run quickly but mislead.

Computational efficiency should not be pursued at the expense of correctness, interpretability, or validation. The right numerical workflow balances accuracy, transparency, cost, and decision relevance.

Back to top ↑

Mathematical Lens: Approximation as Model Transformation

Numerical methods transform a mathematical problem into a computable problem. The original model may be continuous, infinite-dimensional, implicit, nonlinear, or probabilistic. The numerical model replaces it with a finite procedure.

The computed output is therefore:

Convergence asks whether the approximation approaches the intended model output as numerical resolution improves:

This lens clarifies why numerical methods are part of the model, not merely a technical afterthought. The approximation controls what is actually computed, tested, and interpreted.

Back to top ↑

Example: Numerical Resource Dynamics Model

Consider a resource stock model where stock grows logistically and is reduced by extraction. The continuous form may be written as:

A numerical method approximates the trajectory with time steps:

This approximation allows the modeler to run scenarios. But results may depend on \(h\). A large time step can overshoot depletion, produce unstable behavior, or hide threshold dynamics. A smaller time step may be more accurate but computationally more expensive.

This example shows why numerical methods require accountability. The model’s conclusion should not rely on an untested approximation setting.

Back to top ↑

Verification, Validation, and Numerical Diagnostics

Numerical modeling requires both model validation and numerical verification. Verification asks whether the numerical implementation solves the intended mathematical problem correctly. Validation asks whether the model is credible for the real-world purpose.

A numerical result should be accompanied by diagnostic evidence. This may include residual norms, convergence rates, solver status, step-size comparisons, tolerance checks, runtime logs, and known-case tests.

Back to top ↑

Ethical Stakes of Numerical Modeling

Numerical methods can influence decisions in engineering, medicine, finance, infrastructure, climate policy, logistics, artificial intelligence, public health, and environmental regulation. Their ethical stakes come from the authority that computational outputs often carry.

Responsible numerical modeling treats approximation as a matter of judgment. Numerical outputs should be transparent, reproducible, tested, and communicated with uncertainty.

Back to top ↑

Python Workflow: Numerical Method Register and Solver Diagnostics

The Python workflow below creates a numerical method register, runs Euler approximations for a resource dynamics model at multiple step sizes, compares convergence behavior, and exports diagnostic artifacts.

# numerical_methods_for_mathematical_models_workflow.py
# Dependency-light workflow for numerical method registers and solver diagnostics.

from __future__ import annotations

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


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
OUTPUTS = ARTICLE_ROOT / "outputs"
TABLES = OUTPUTS / "tables"
JSON_DIR = OUTPUTS / "json"


@dataclass(frozen=True)
class NumericalRecord:
    key: str
    component_type: str
    numerical_structure: str
    interpretation: str
    review_question: str
    status: str


@dataclass(frozen=True)
class SolverScenario:
    scenario: str
    initial_stock: float
    growth_rate: float
    carrying_capacity: float
    extraction: float
    horizon: float
    step_size: float


def numerical_register() -> list[NumericalRecord]:
    return [
        NumericalRecord(
            key="euler_step",
            component_type="time_step_method",
            numerical_structure="R_next = R + h * f(R)",
            interpretation="Euler stepping approximates continuous resource dynamics.",
            review_question="Are results stable under smaller step sizes?",
            status="review",
        ),
        NumericalRecord(
            key="step_size",
            component_type="discretization",
            numerical_structure="h in {1.0, 0.5, 0.25, 0.1}",
            interpretation="Step size controls time discretization.",
            review_question="Does the conclusion depend on step size?",
            status="review",
        ),
        NumericalRecord(
            key="convergence_diagnostic",
            component_type="diagnostic",
            numerical_structure="compare final stock across h",
            interpretation="Convergence is assessed by comparing refined approximations.",
            review_question="Do results stabilize as h decreases?",
            status="active",
        ),
        NumericalRecord(
            key="nonnegative_constraint",
            component_type="state_constraint",
            numerical_structure="R = max(0, R)",
            interpretation="Resource stock is constrained to remain nonnegative.",
            review_question="Does the constraint hide numerical overshoot?",
            status="review",
        ),
    ]


def scenario_set() -> list[SolverScenario]:
    base = {
        "scenario": "resource_dynamics",
        "initial_stock": 70.0,
        "growth_rate": 0.18,
        "carrying_capacity": 100.0,
        "extraction": 6.0,
        "horizon": 50.0,
    }
    return [
        SolverScenario(**base, step_size=1.0),
        SolverScenario(**base, step_size=0.5),
        SolverScenario(**base, step_size=0.25),
        SolverScenario(**base, step_size=0.1),
    ]


def derivative(stock: float, growth_rate: float, carrying_capacity: float, extraction: float) -> float:
    return growth_rate * stock * (1.0 - stock / carrying_capacity) - extraction


def run_euler(scenario: SolverScenario) -> list[dict[str, object]]:
    if scenario.step_size <= 0:
        raise ValueError("step_size must be positive.")

    steps = int(round(scenario.horizon / scenario.step_size))
    stock = scenario.initial_stock
    rows: list[dict[str, object]] = []

    for index in range(steps + 1):
        time = index * scenario.step_size
        rows.append({
            "scenario": scenario.scenario,
            "step_size": scenario.step_size,
            "index": index,
            "time": round(time, 8),
            "resource_stock": round(stock, 8),
        })

        if index == steps:
            break

        stock = stock + scenario.step_size * derivative(
            stock,
            scenario.growth_rate,
            scenario.carrying_capacity,
            scenario.extraction,
        )
        stock = max(0.0, stock)

    return rows


def convergence_summary(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    grouped: dict[float, list[dict[str, object]]] = {}
    for row in rows:
        grouped.setdefault(float(row["step_size"]), []).append(row)

    final_rows = []
    for step_size, step_rows in sorted(grouped.items(), reverse=True):
        final = max(step_rows, key=lambda item: int(item["index"]))
        final_rows.append({
            "step_size": step_size,
            "final_stock": float(final["resource_stock"]),
        })

    reference = min(final_rows, key=lambda row: float(row["step_size"]))["final_stock"]

    output = []
    for row in sorted(final_rows, key=lambda item: float(item["step_size"])):
        output.append({
            "step_size": row["step_size"],
            "final_stock": round(row["final_stock"], 8),
            "absolute_difference_from_finest_step": round(abs(row["final_stock"] - reference), 8),
        })

    return output


def numerical_risk_score(record: NumericalRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.component_type} {record.numerical_structure} {record.review_question}".lower()
    for term in ["step", "convergence", "stability", "discretization", "constraint", "error"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows supplied for {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    records = numerical_register()
    scenarios = scenario_set()

    trajectories = []
    for scenario in scenarios:
        trajectories.extend(run_euler(scenario))

    convergence = convergence_summary(trajectories)

    register_rows = [
        {**asdict(record), "numerical_risk_score": numerical_risk_score(record)}
        for record in records
    ]

    write_csv(TABLES / "numerical_method_register.csv", register_rows)
    write_csv(TABLES / "euler_resource_trajectories.csv", trajectories)
    write_csv(TABLES / "step_size_convergence_summary.csv", convergence)

    write_json(JSON_DIR / "numerical_method_audit_card.json", {
        "article": "Numerical Methods for Mathematical Models",
        "method": "Euler time stepping",
        "scenarios": [asdict(scenario) for scenario in scenarios],
        "model_register": register_rows,
        "convergence_summary": convergence,
        "audit_checks": [
            "step size is documented",
            "convergence is checked",
            "state constraints are explicit",
            "numerical approximation is separated from model claim",
            "outputs include diagnostics",
        ],
    })

    print("Numerical methods workflow complete.")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats numerical method selection as an auditable modeling decision. It does not merely compute a trajectory; it compares approximations and preserves diagnostic evidence.

Back to top ↑

R Workflow: Numerical Review and Convergence Diagnostics

The R workflow below reviews generated step-size results, classifies convergence differences, and creates a base R plot comparing numerical trajectories.

# numerical_methods_for_mathematical_models_review.R
# Base R workflow for numerical review and convergence diagnostics.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

trajectory_path <- file.path(tables_dir, "euler_resource_trajectories.csv")
convergence_path <- file.path(tables_dir, "step_size_convergence_summary.csv")
register_path <- file.path(tables_dir, "numerical_method_register.csv")

if (!file.exists(trajectory_path) || !file.exists(convergence_path)) {
  stop("Missing numerical method outputs. Run the Python workflow first.")
}

trajectories <- read.csv(trajectory_path, stringsAsFactors = FALSE)
convergence <- read.csv(convergence_path, stringsAsFactors = FALSE)

trajectories$time <- as.numeric(trajectories$time)
trajectories$resource_stock <- as.numeric(trajectories$resource_stock)
trajectories$step_size <- as.numeric(trajectories$step_size)

convergence$review_class <- ifelse(
  convergence$absolute_difference_from_finest_step > 0.5,
  "step-size sensitivity review",
  "routine convergence review"
)

write.csv(
  convergence,
  file.path(tables_dir, "r_step_size_convergence_review.csv"),
  row.names = FALSE
)

if (file.exists(register_path)) {
  register <- read.csv(register_path, stringsAsFactors = FALSE)

  register$priority <- ifelse(
    register$numerical_risk_score >= 8,
    "high",
    ifelse(register$numerical_risk_score >= 6, "medium", "low")
  )

  write.csv(
    register,
    file.path(tables_dir, "r_numerical_method_review_queue.csv"),
    row.names = FALSE
  )
}

png(file.path(figures_dir, "r_euler_step_size_comparison.png"), width = 1100, height = 720)

step_sizes <- sort(unique(trajectories$step_size), decreasing = TRUE)

if (nrow(trajectories) > 0 && all(is.finite(range(trajectories$time))) && all(is.finite(range(trajectories$resource_stock)))) {
  plot(
    range(trajectories$time),
    range(trajectories$resource_stock),
    type = "n",
    xlab = "Time",
    ylab = "Resource stock",
    main = "Euler Approximation by Step Size"
  )

  for (h in step_sizes) {
    subset_data <- trajectories[trajectories$step_size == h, ]
    lines(subset_data$time, subset_data$resource_stock)
  }

  legend("topright", legend = paste("h =", step_sizes), lty = 1, bty = "n")
  grid()
} else {
  plot.new()
  title(main = "Euler Approximation by Step Size")
  text(0.5, 0.5, "No finite numerical trajectory values available.")
}

dev.off()

print(convergence)

The R layer supports numerical review by separating computed trajectories, convergence diagnostics, and model-register priorities. It helps prevent an approximation setting from becoming an invisible assumption.

Back to top ↑

Haskell Workflow: Typed Numerical Method Records

Haskell is useful here because numerical method components should remain distinct. A step-size rule is not a convergence diagnostic. A state constraint is not a solver. A computed output is not the same as validation evidence.

{-# OPTIONS_GHC -Wall #-}

module Main where

data NumericalComponent
  = TimeStepMethod
  | Discretization
  | SolverTolerance
  | ConvergenceDiagnostic
  | StabilityDiagnostic
  | StateConstraint
  | ValidationDiagnostic
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresValidation
  | RequiresSensitivityTest
  | Revise
  deriving (Eq, Show)

data NumericalRecord = NumericalRecord
  { key :: String
  , component :: NumericalComponent
  , numericalStructure :: String
  , interpretation :: String
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

numericalRegister :: [NumericalRecord]
numericalRegister =
  [ NumericalRecord
      "euler_step"
      TimeStepMethod
      "R_next = R + h * f(R)"
      "Euler stepping approximates continuous resource dynamics."
      "Method suitability."
      RequiresReview
  , NumericalRecord
      "step_size"
      Discretization
      "h in {1.0, 0.5, 0.25, 0.1}"
      "Step size controls time discretization."
      "Step-size sensitivity."
      RequiresSensitivityTest
  , NumericalRecord
      "convergence_diagnostic"
      ConvergenceDiagnostic
      "compare final stock across h"
      "Convergence is assessed by comparing refined approximations."
      "Approximation credibility."
      Active
  , NumericalRecord
      "nonnegative_constraint"
      StateConstraint
      "R = max(0, R)"
      "Resource stock is constrained to remain nonnegative."
      "Constraint interpretation."
      RequiresReview
  ]

needsReview :: NumericalRecord -> Bool
needsReview item =
  case status item of
    Active -> False
    _ -> True

main :: IO ()
main = do
  putStrLn "Typed numerical method records:"
  mapM_ print numericalRegister

  putStrLn "\nNumerical records requiring review:"
  mapM_ print (filter needsReview numericalRegister)

This typed layer supports numerical governance by making approximation choices explicit before model outputs are interpreted as evidence.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for numerical method registers, solver diagnostics, Euler approximation, convergence testing, typed Haskell numerical records, validation planning, and reproducible computational workflows.

Back to top ↑

A Practical Method for Numerical Model Design

Numerical method design should begin by identifying what mathematical quantity is being approximated and why exact solution is unavailable, impractical, or unnecessary.

This method helps keep numerical modeling from becoming solver-driven. It connects computation to mathematical purpose, diagnostic evidence, and responsible interpretation.

Back to top ↑

Common Pitfalls

Numerical methods can fail quietly. A solver may return a number, a plot may look smooth, and a workflow may finish without errors even when the approximation is unreliable.

• Solver worship: trusting output because a recognized algorithm produced it.
• Step-size blindness: failing to test whether results depend on time-step or grid resolution.
• Tolerance neglect: ignoring solver tolerances and residuals.
• False convergence: stopping because iteration ended, not because the solution stabilized.
• Rounding accumulation: ignoring finite-precision effects in sensitive models.
• Unstable discretization: using a method that amplifies numerical error.
• Boundary-condition errors: creating artifacts at domain edges.
• Over-precise reporting: using many decimal places when approximation error is large.
• Method-model mismatch: applying a convenient method to an unsuitable problem.
• Numerical accuracy without model validity: solving the wrong model very precisely.

These pitfalls can be reduced through convergence checks, residual diagnostics, method comparison, unit tests, known-case problems, sensitivity analysis, reproducible workflows, and careful explanation of numerical limitations.

Back to top ↑

Conclusion: Approximation Requires Accountability

Numerical methods make mathematical modeling computationally usable. They allow analysts to solve equations, approximate integrals, simulate differential equations, optimize decisions, represent spatial fields, propagate uncertainty, and explore systems too complex for exact formulas.

Their power comes from approximation. But approximation requires accountability. A computed result depends on method choice, step size, tolerance, precision, discretization, solver behavior, implementation, validation, and model assumptions.

Responsible numerical modeling does not hide these choices. It documents them, tests them, compares alternatives, reports uncertainty, and links computation back to model purpose. Numerical methods should make mathematical reasoning more usable without making it less transparent.

Used well, numerical methods support better modeling across science, engineering, policy, economics, public health, sustainability, infrastructure, artificial intelligence, and complex systems. Used poorly, they can turn hidden assumptions into confident-looking outputs. The difference lies in disciplined diagnostics, reproducibility, and interpretive judgment.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Functional Relationships and Mathematical Structure
• Equations, Inequalities, and Model Logic
• Differential Equations and Dynamic Models
• Discrete Models and Recurrence Relations
• Optimization Models and Objective Functions
• Simulation and Computational Modeling
• Monte Carlo Simulation and Uncertainty Propagation
• Scientific Computing for Modeling Workflows
• Model Repositories, Data, and Reproducible Research

Back to top ↑

Further Reading

• Burden, R.L. and Faires, J.D. (2011) Numerical Analysis. 9th edn. Boston, MA: Brooks/Cole.
• Chapra, S.C. and Canale, R.P. (2015) Numerical Methods for Engineers. 7th edn. New York: McGraw-Hill.
• Press, W.H., Teukolsky, S.A., Vetterling, W.T. and Flannery, B.P. (2007) Numerical Recipes: The Art of Scientific Computing. 3rd edn. Cambridge: Cambridge University Press.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer.
• Atkinson, K.E. (1989) An Introduction to Numerical Analysis. 2nd edn. New York: Wiley.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM.
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations. Philadelphia, PA: SIAM.
• Heath, M.T. (2018) Scientific Computing: An Introductory Survey. Revised 2nd edn. Philadelphia, PA: SIAM.
• Süli, E. and Mayers, D.F. (2003) An Introduction to Numerical Analysis. Cambridge: Cambridge University Press.

Back to top ↑

References

• Atkinson, K.E. (1989) An Introduction to Numerical Analysis. 2nd edn. New York: Wiley.
• Burden, R.L. and Faires, J.D. (2011) Numerical Analysis. 9th edn. Boston, MA: Brooks/Cole.
• Chapra, S.C. and Canale, R.P. (2015) Numerical Methods for Engineers. 7th edn. New York: McGraw-Hill.
• Heath, M.T. (2018) Scientific Computing: An Introductory Survey. Revised 2nd edn. Philadelphia, PA: SIAM.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM.
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations. Philadelphia, PA: SIAM.
• Press, W.H., Teukolsky, S.A., Vetterling, W.T. and Flannery, B.P. (2007) Numerical Recipes: The Art of Scientific Computing. 3rd edn. Cambridge: Cambridge University Press.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer.
• Süli, E. and Mayers, D.F. (2003) An Introduction to Numerical Analysis. Cambridge: Cambridge University Press.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM.

Back to top ↑