Functions of Several Variables: Multivariable Calculus for Systems Modeling

Last Updated June 28, 2026

Functions of several variables extend calculus from single-input change to interacting systems, where outcomes depend on multiple conditions at once. Instead of asking only how \(y=f(x)\) changes as one input changes, multivariable calculus asks how \(z=f(x,y)\), \(u=f(x_1,x_2,\ldots,x_n)\), or a system output changes across many interacting dimensions. This shift is essential for systems modeling because most real systems do not respond to one driver in isolation.

Environmental outcomes depend on temperature, precipitation, land use, emissions, hydrology, and feedback. Public health outcomes depend on exposure, immunity, behavior, infrastructure, policy, time, and vulnerability. Economic outcomes depend on prices, wages, interest rates, expectations, constraints, technology, and institutions. Infrastructure performance depends on demand, capacity, routing, maintenance, shocks, redundancy, and cascading dependencies. Functions of several variables give modelers a formal language for representing those joint dependencies without pretending that one input explains the whole system.

This article introduces functions of several variables as the foundation of multivariable calculus for systems modeling. It examines domains, ranges, surfaces, level curves, feasible regions, interaction, scaling, units, local neighborhoods, high-dimensional input spaces, visualization, computational representation, and responsible interpretation. The goal is not only to define multivariable functions, but to show why they matter for modeling complex systems where causes combine, constraints matter, and local conclusions can fail when moved into a different region of the input space.

Single-variable calculus studies change along a line. Multivariable calculus studies change across spaces. This matters because systems rarely have one cause, one driver, or one independent condition. A model output may change because one input changes, because several inputs change together, because inputs interact, or because the system crosses a boundary where a relationship no longer applies.

The move into several variables also changes the standards of interpretation. A formula may be algebraically simple but domain-sensitive, visually persuasive but high-dimensional underneath, or computationally smooth while hiding constraints and infeasible combinations. Multivariable functions therefore prepare the ground for partial derivatives, gradients, Jacobians, Hessians, constrained optimization, multiple integration, vector fields, and sensitivity analysis, but they also introduce a basic governance question: what input space does the model actually claim to understand?

Why Functions of Several Variables Matter

Functions of several variables matter because complex systems respond to multiple inputs simultaneously. A single-input model can be useful for isolating a relationship, but it often hides interaction, constraint, substitution, feedback, and tradeoff. Multivariable functions make those relationships explicit by representing outputs as functions of several inputs.

A two-input function has the form:

A many-input function has the form:

This shift from one input to many inputs changes the modeling problem. The modeler must now ask which variables are included, which are omitted, which inputs are independent, which are constrained, which interact, and where the function is valid. The result is not merely a more complicated formula. It is a richer representation of system structure.

Functions of several variables therefore provide the conceptual foundation for partial derivatives, gradients, Jacobians, Hessians, constrained optimization, multiple integrals, vector calculus, and many computational modeling workflows.

Back to top ↑

What Is a Function of Several Variables?

A function of several variables assigns one output to each allowed combination of inputs. For two inputs, the function may be written as:

For many inputs, the function may be written as:

For example, a simple production, risk, exposure, or response model might be written as:

The function notation hides an important modeling choice: what counts as an input? Some inputs are variables. Some are parameters. Some are fixed assumptions. Some are background conditions. A model may write \(z=f(x,y)\), but its output may also depend on hidden assumptions about time, scale, units, boundary conditions, measurement, or institutional context.

In systems modeling, a function of several variables is often best understood as a formal representation of dependency. It says that the modeled output is being explained, approximated, or computed through a chosen set of inputs. That choice should be documented.

Back to top ↑

Input Spaces, Domains, and Ranges

The domain of a multivariable function is the set of input combinations for which the function is defined and meaningful. In single-variable calculus, a domain is often an interval. In multivariable calculus, a domain may be a plane region, a three-dimensional volume, a constrained surface, a parameter box, or a more complicated feasible set.

The range is the set of possible output values:

Modeling domains are not purely mathematical. A formula may be defined for many input values that make no real-world sense. A population cannot be negative. A percentage may need to stay between \(0\) and \(100\). A concentration may be nonnegative. A policy scenario may be infeasible. A physical system may be bounded by capacity. A statistical model may be valid only inside the region represented by the data.

A responsible multivariable model should distinguish mathematical domain from modeling domain. A formula may be computable outside the valid system region, but that does not make the result meaningful.

Back to top ↑

Surfaces and Higher-Dimensional Graphs

A function \(z=f(x,y)\) can be visualized as a surface in three-dimensional space. Each input pair \((x,y)\) corresponds to a height \(z\). The graph is:

Surfaces help modelers see how output changes across two inputs. Peaks may indicate high-risk or high-output regions. Valleys may indicate low-response regions. Ridges may show tradeoff pathways. Flat areas may show insensitivity. Steep regions may show high sensitivity. Curvature may reveal nonlinear response.

However, surfaces have limits. They work well for two inputs and one output, but many systems include more than two inputs. A function with three or more inputs cannot be fully visualized as a simple surface. Modelers then use slices, projections, contour maps, parameter grids, pairwise plots, dimensional reduction, sensitivity sweeps, or interactive visualization.

The key modeling lesson is that visualization is also a form of approximation. A surface or contour map can clarify structure, but it shows only selected dimensions of the full input space.

Back to top ↑

Level Curves, Level Surfaces, and Contours

A level curve is the set of input points where a two-variable function has the same output value:

For a function of three variables, a level surface has the form:

Level sets are powerful in systems modeling because they show equivalence, tradeoff, and constraint. Different combinations of emissions and mitigation may produce the same temperature outcome. Different combinations of load and capacity may produce the same congestion risk. Different combinations of price and income may produce the same demand. Different combinations of exposure and vulnerability may produce the same harm level.

Level curves and contours often communicate multivariable functions more clearly than three-dimensional surfaces. They are especially useful when the modeler needs to compare tradeoffs, thresholds, or feasible pathways.

Back to top ↑

Interaction Between Inputs

Interaction means the effect of one input depends on the value of another input. In a purely additive function such as:

the contribution of \(x\) does not depend on \(y\). But in a function with an interaction term:

Interaction is central to systems modeling. A rainfall event may produce little harm in one land-use condition and severe harm in another. A policy may work differently depending on institutional capacity. A health exposure may be more dangerous for vulnerable populations. A network shock may be manageable at low demand and catastrophic near capacity. Interaction terms help represent these combined effects.

Interaction can be linear, nonlinear, threshold-based, multiplicative, conditional, or dynamic. It can also be hidden. A model may appear additive because interactions were omitted, not because they do not exist.

A multivariable function should therefore be read not only for its individual variables but for the relationships among variables.

Back to top ↑

Constraints and Feasible Regions

Many multivariable functions are meaningful only under constraints. Constraints limit the input combinations that can occur or that should be considered. A budget constraint, capacity constraint, conservation law, physical boundary, legal condition, ethical boundary, or data-support region may restrict the feasible space.

A constrained domain might look like:

Constraints are not afterthoughts. They shape the function’s interpretation. A model output may increase when both inputs increase, but if the inputs share a limited resource, increasing one may require decreasing another. A risk model may be defined over many combinations, but only some combinations may be plausible. A policy model may identify a high-performing input combination that is politically, legally, physically, or ethically infeasible.

Functions of several variables become more responsible when they are paired with explicit feasible regions. A formula without a feasible domain can invite impossible or misleading scenarios.

Back to top ↑

Local Neighborhoods and Reference States

Multivariable calculus often studies behavior near a reference point. Instead of a center \(a\) on a line, the reference state may be a point \((a,b)\), a vector \(\mathbf{x}_0\), or an equilibrium state in a larger system.

A local neighborhood contains points near that reference state:

This idea prepares for partial derivatives, gradients, Jacobians, Hessians, local approximation, and stability analysis. It also supports responsible modeling because many multivariable claims are local. A model may describe behavior near a baseline, equilibrium, calibration region, normal operating condition, or policy scenario. That does not mean the same behavior holds across all possible combinations of inputs.

In systems modeling, reference states should be named. Is the point a baseline scenario? A historical average? A current operating condition? A policy target? A steady state? A calibration center? The meaning of local analysis depends on that choice.

Back to top ↑

Coordinate Systems, Scaling, and Units

Multivariable functions depend on how inputs are measured. A model written as \(f(x,y)\) may look neutral, but the meaning of the surface changes when \(x\) is measured in tons instead of kilograms, when \(y\) is annual instead of monthly, or when an input is normalized before computation. Scaling affects visualization, sensitivity, numerical conditioning, and interpretation.

In vector form, the same idea can be written as:

Scaling is especially important when variables have different units or magnitudes. A model involving dollars, degrees Celsius, population counts, and exposure concentrations cannot be interpreted by comparing raw numerical changes alone. A one-unit change in one variable may be trivial, while a one-unit change in another may be system-defining.

Coordinate choice can also change what is easy to see. A geographic model may use latitude and longitude, a transport model may use network coordinates, a physical model may use polar or spherical coordinates, and a statistical model may use standardized or principal-component coordinates. The underlying system may be the same, but the coordinate system changes the geometry of analysis.

A multivariable function is therefore not just a formula over symbols. It is a formula over measured quantities. Without units, scaling, and coordinate discipline, a surface can look mathematically precise while remaining substantively ambiguous.

Back to top ↑

Slices, Projections, and High-Dimensional Views

Most systems have more than two inputs, but human visualization is limited. To understand high-dimensional functions, modelers often inspect slices, projections, pairwise plots, and parameter sweeps. A slice holds some variables fixed while varying others. A projection compresses several dimensions into a lower-dimensional view. These tools are useful, but they are interpretive choices.

The danger is that a slice can look simple while the full function is not. A response may be flat in one slice and steep in another. An interaction may disappear when one variable is fixed at a convenient value. A feasible region may look rectangular in a projection while being curved, disconnected, or sharply constrained in the full input space.

High-dimensional modeling requires humility about visualization. A contour map, surface, or grid is a view into the function, not the function itself.

Back to top ↑

Continuity, Differentiability, and Local Structure

Functions of several variables prepare the way for partial derivatives, gradients, Jacobians, and Hessians. Before those tools are used, the modeler should ask whether the function behaves smoothly enough for local calculus to be meaningful. Continuity asks whether nearby inputs produce nearby outputs. Differentiability asks whether the function can be approximated locally by a linear map.

This local-linear idea is powerful, but it depends on the neighborhood. A function may be smooth in normal operating conditions and nonsmooth near a threshold. It may be continuous but not differentiable along a boundary. It may have different behavior on different sides of a constraint. It may be numerically estimated from data rather than analytically known.

These properties turn multivariable functions into modeling instruments. They determine whether local sensitivity, local approximation, and smooth optimization are legitimate or whether the system requires piecewise, constrained, or nonsmooth analysis.

Back to top ↑

Data, Parameters, and Hidden Assumptions

A multivariable function rarely contains all of its assumptions in the visible variables. A model written as \(f(x,y)\) may also depend on parameters, calibration data, fixed background conditions, measurement conventions, and omitted mechanisms. Some of these are mathematically treated as constants. In system interpretation, they may be decisive.

The semicolon notation is a useful reminder: variables and parameters play different roles. Variables are often varied in the analysis. Parameters are often fixed, estimated, calibrated, or assumed. But a fixed parameter can still be uncertain, contested, or context-dependent. A model can look like a two-variable function while silently depending on dozens of background choices.

Clear multivariable modeling requires more than naming variables. It requires explaining which quantities are varied, which are fixed, which are estimated, which are omitted, and which regions of input space are supported by data or theory.

Back to top ↑

Systems Modeling Interpretation

Functions of several variables are not merely a mathematical generalization. They are a way to represent system dependency. They help modelers ask how outcomes depend on multiple drivers, how those drivers interact, which combinations are feasible, which regions are risky, which variables dominate in different contexts, and where local approximations can be trusted.

A multivariable function can represent a system response:

It can represent a production or performance model:

It can represent a risk model:

The modeling value lies in structure. Which variables are included? Which are excluded? Are inputs independent or constrained? Are interactions additive or nonlinear? Is the domain physically meaningful? Are results supported across the whole input space or only near a local reference state? These questions make multivariable functions part of model governance, not just model construction.

Back to top ↑

Mathematical Deepening

Functions of several variables can be studied as mappings between spaces. Their properties depend on domain, codomain, continuity, differentiability, topology, constraints, and local structure. The formal framework matters because multivariable functions can behave in ways that are not visible from one-dimensional intuition: paths can approach the same point from different directions, constraints can reshape feasible movement, and local behavior can vary across the input space.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for functions of several variables should record input definitions, units, bounds, transformations, domain restrictions, feasible regions, output definitions, interaction terms, sampled grids, reference states, and warnings about extrapolation. The workflow should separate mathematical evaluation from modeling interpretation.

Good workflows evaluate the function over a structured grid, identify high and low output regions, compute level-set approximations, flag infeasible inputs, and store results in auditable formats. They should also make clear which variables are varied and which are held fixed. In high-dimensional functions, slicing and projection choices should be documented because they shape interpretation.

The workflow should also record the resolution of the grid and the reason that resolution was chosen. A coarse grid can miss narrow ridges, steep gradients, small feasible regions, or threshold boundaries. A dense grid can produce a persuasive heat map while still ignoring variables held fixed. Reproducible multivariable computation therefore needs both outputs and a record of how the input space was sampled.

Back to top ↑

Python Workflow: Multivariable Function Audit

The Python workflow below evaluates a two-input system response over a grid, records output values, flags infeasible combinations, and writes auditable outputs.

from __future__ import annotations

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


@dataclass(frozen=True)
class MultivariableFunctionRecord:
    x: float
    y: float
    output: float
    feasible: bool
    warning: str


def system_response(x: float, y: float) -> float:
    return 3.0 * x + 2.0 * y + 0.5 * x * y


def is_feasible(x: float, y: float) -> bool:
    return x >= 0 and y >= 0 and x + y <= 10


def evaluate_grid() -> list[MultivariableFunctionRecord]:
    records: list[MultivariableFunctionRecord] = []
    for x in [0, 2, 4, 6, 8, 10]:
        for y in [0, 2, 4, 6, 8, 10]:
            feasible = is_feasible(x, y)
            records.append(
                MultivariableFunctionRecord(
                    x=x,
                    y=y,
                    output=system_response(x, y),
                    feasible=feasible,
                    warning="" if feasible else "Input combination is outside the feasible region."
                )
            )
    return records


records = evaluate_grid()

output_dir = Path("outputs")
(output_dir / "tables").mkdir(parents=True, exist_ok=True)
(output_dir / "json").mkdir(parents=True, exist_ok=True)

with (output_dir / "tables" / "multivariable_function_grid.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(records[0]).keys())
    writer.writeheader()
    for record in records:
        writer.writerow(asdict(record))

(output_dir / "json" / "multivariable_function_grid.json").write_text(
    json.dumps([asdict(record) for record in records], indent=2),
    encoding="utf-8"
)

print("Wrote multivariable function grid audit.")

This workflow makes input combinations, output values, feasibility, and warnings visible in the generated results.

Back to top ↑

R Workflow: Surface and Contour Diagnostics

The R workflow below evaluates a two-variable response function over a grid and records feasibility status for each input pair.

# Functions of Several Variables
# Base R workflow for surface and contour diagnostics.

system_response <- function(x, y) {
  3.0 * x + 2.0 * y + 0.5 * x * y
}

is_feasible <- function(x, y) {
  x >= 0 & y >= 0 & x + y <= 10
}

grid <- expand.grid(
  x = seq(0, 10, by = 2),
  y = seq(0, 10, by = 2)
)

grid$output <- system_response(grid$x, grid$y)
grid$feasible <- is_feasible(grid$x, grid$y)
grid$warning <- ifelse(
  grid$feasible,
  "",
  "Input combination is outside the feasible region."
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)
write.csv(grid, "outputs/tables/r_multivariable_function_grid.csv", row.names = FALSE)

print(grid)

This workflow supports surface, contour, and feasibility review without hiding which input combinations were outside the modeling domain.

Back to top ↑

Haskell Workflow: Typed Multivariable Records

Haskell can represent multivariable input records with explicit types for variables, outputs, feasibility, and warnings.

module Main where

newtype XInput = XInput Double deriving (Show)
newtype YInput = YInput Double deriving (Show)
newtype Output = Output Double deriving (Show)

data Feasibility
  = Feasible
  | Infeasible
  deriving (Show)

data MultivariableRecord = MultivariableRecord
  { xInput :: XInput
  , yInput :: YInput
  , output :: Output
  , feasibility :: Feasibility
  , warning :: String
  } deriving (Show)

systemResponse :: Double -> Double -> Double
systemResponse x y = 3.0 * x + 2.0 * y + 0.5 * x * y

isFeasible :: Double -> Double -> Bool
isFeasible x y = x >= 0 && y >= 0 && x + y <= 10

makeRecord :: Double -> Double -> MultivariableRecord
makeRecord x y =
  let feasible = isFeasible x y
  in MultivariableRecord
      { xInput = XInput x
      , yInput = YInput y
      , output = Output (systemResponse x y)
      , feasibility = if feasible then Feasible else Infeasible
      , warning = if feasible then "" else "Input combination is outside the feasible region."
      }

main :: IO ()
main = do
  print (makeRecord 2.0 4.0)
  print (makeRecord 8.0 8.0)
  print (makeRecord 6.0 3.0)

The typed structure keeps input values, model output, feasibility, and warning separate rather than collapsing them into a single uninterpreted number.

Back to top ↑

SQL Workflow: Multivariable Assumption Registry

SQL can document multivariable function assumptions when outputs feed reports, dashboards, model cards, or governance reviews.

CREATE TABLE multivariable_function_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 multivariable_function_assumption_registry VALUES
(
  'input_definition',
  'Input definition',
  'Defines each variable in the input space.',
  'Clarifies what each input represents in the modeled system.',
  'A multivariable function should not be interpreted without clear input definitions.'
);

INSERT INTO multivariable_function_assumption_registry VALUES
(
  'domain_region',
  'Domain region',
  'Defines the set of input combinations where the function is defined.',
  'Separates mathematically computable inputs from meaningful system scenarios.',
  'Outputs outside the modeling domain may be invalid even when the formula computes.'
);

INSERT INTO multivariable_function_assumption_registry VALUES
(
  'feasible_region',
  'Feasible region',
  'Records constraints on allowable input combinations.',
  'Prevents impossible scenarios from being treated as valid model outputs.',
  'Inputs may be mathematically valid but infeasible under physical, budgetary, or ethical constraints.'
);

INSERT INTO multivariable_function_assumption_registry VALUES
(
  'interaction_structure',
  'Interaction structure',
  'Identifies whether input effects are additive, multiplicative, nonlinear, or conditional.',
  'Clarifies whether variables act independently or jointly.',
  'Omitted interactions may distort system interpretation.'
);

INSERT INTO multivariable_function_assumption_registry VALUES
(
  'local_validity',
  'Local validity',
  'Defines where the multivariable relationship is intended to hold.',
  'Prevents local response surfaces from being treated as global system truth.',
  'A function calibrated in one region may not be valid under extrapolation.'
);

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

This registry keeps multivariable function interpretation tied to input definition, domain, feasibility, interaction, and local validity.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports multivariable function grids, surface and contour diagnostics, feasible-region checks, interaction-term examples, SQL assumption registries, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Functions of several variables can make models more realistic, but they can also create false confidence. Adding more inputs does not automatically make a model better. A multivariable function may omit important variables, include poorly defined variables, assume independence where interaction exists, extrapolate outside the data region, or compute outputs for infeasible combinations.

Responsible use requires several checks. Define each input clearly. State units and bounds. Distinguish variables from parameters. Identify the mathematical domain and the modeling domain. Document feasible regions and constraints. Explain whether inputs can vary independently. Identify interaction terms or justify their absence. State where the function is calibrated, meaningful, or locally valid. Avoid treating high-dimensional formulas as complete system explanations.

The central modeling question is not only “What is the function?” It is “What system relationship does this function claim to represent, across which input combinations, under which constraints, with which interactions, and within what validity region?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Approximation Error, Truncation, and Local Validity
• Taylor and Maclaurin Series in Modeling
• Partial Derivatives and Interaction Effects
• Total Differentials and Local Approximation in Higher Dimensions
• Directional Derivatives and Gradients
• Jacobians and Multivariable Transformation
• Hessians, Curvature, and Local Structure
• Systems Modeling
• Mathematical Modeling

Back to top ↑

Further Reading

• Apostol, T.M. (1969) Calculus, Volume 2: Multi-Variable Calculus and Linear Algebra, with Applications to Differential Equations and Probability. 2nd edn. New York: Wiley. Available at: Wiley.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: Dover Publications. Available at: Dover Publications.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions. Available at: Matrix Editions.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman.
• Spivak, M. (1965) Calculus on Manifolds: A Modern Approach to Classical Theorems of Advanced Calculus. New York: W.A. Benjamin.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: McGraw Hill.
• Schey, H.M. (2005) Div, Grad, Curl, and All That: An Informal Text on Vector Calculus. 4th edn. New York: W.W. Norton.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning. Available at: Cengage.
• Strang, G. (2016) Introduction to Linear Algebra. 5th edn. Wellesley, MA: Wellesley-Cambridge Press. Available at: MIT Mathematics.
• Strang, G. (2019) Linear Algebra and Learning from Data. Wellesley, MA: Wellesley-Cambridge Press. Available at: MIT Mathematics.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: Stanford University.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer. Available at: Springer.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: SIAM.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: Springer.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: Wiley Online Library.
• Sobol, I.M. (2001) ‘Global sensitivity indices for nonlinear mathematical models and their Monte Carlo estimates’, Mathematics and Computers in Simulation, 55(1–3), pp. 271–280. Available at: https://doi.org/10.1016/S0378-4754(00)00270-6.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Massachusetts Institute of Technology OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: MIT OpenCourseWare.
• Massachusetts Institute of Technology OpenCourseWare (2010) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: MIT OpenCourseWare.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University. Available at: OpenStax.
• NumPy Developers (n.d.) Meshgrid. NumPy Documentation. Available at: NumPy Documentation.
• NumPy Developers (n.d.) Gradient. NumPy Documentation. Available at: NumPy Documentation.
• SciPy Developers (n.d.) Interpolation. SciPy Documentation. Available at: SciPy Documentation.
• SciPy Developers (n.d.) Optimization and Root Finding. SciPy Documentation. Available at: SciPy Documentation.

Back to top ↑

References

• Apostol, T.M. (1969) Calculus, Volume 2: Multi-Variable Calculus and Linear Algebra, with Applications to Differential Equations and Probability. 2nd edn. New York: Wiley. Available at: Wiley.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: Stanford University.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: Dover Publications. Available at: Dover Publications.
• Forrester, J.W. (1961) Industrial Dynamics. Cambridge, MA: MIT Press.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: SIAM.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions. Available at: Matrix Editions.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman.
• Massachusetts Institute of Technology OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: MIT OpenCourseWare.
• Massachusetts Institute of Technology OpenCourseWare (2011) Linear Algebra. Cambridge, MA: MIT OpenCourseWare. Available at: MIT OpenCourseWare.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer. Available at: Springer.
• NumPy Developers (n.d.) Gradient. NumPy Documentation. Available at: NumPy Documentation.
• NumPy Developers (n.d.) Meshgrid. NumPy Documentation. Available at: NumPy Documentation.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University. Available at: OpenStax.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: Springer.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: McGraw Hill.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: Wiley Online Library.
• Schey, H.M. (2005) Div, Grad, Curl, and All That: An Informal Text on Vector Calculus. 4th edn. New York: W.W. Norton.
• SciPy Developers (n.d.) Interpolation. SciPy Documentation. Available at: SciPy Documentation.
• SciPy Developers (n.d.) Optimization and Root Finding. SciPy Documentation. Available at: SciPy Documentation.
• Sobol, I.M. (2001) ‘Global sensitivity indices for nonlinear mathematical models and their Monte Carlo estimates’, Mathematics and Computers in Simulation, 55(1–3), pp. 271–280. Available at: https://doi.org/10.1016/S0378-4754(00)00270-6.
• Spivak, M. (1965) Calculus on Manifolds: A Modern Approach to Classical Theorems of Advanced Calculus. New York: W.A. Benjamin.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning. Available at: Cengage.
• Strang, G. (2016) Introduction to Linear Algebra. 5th edn. Wellesley, MA: Wellesley-Cambridge Press. Available at: MIT Mathematics.
• Strang, G. (2019) Linear Algebra and Learning from Data. Wellesley, MA: Wellesley-Cambridge Press. Available at: MIT Mathematics.

Back to top ↑