Directional Derivatives and Gradients

Last Updated June 15, 2026

Directional derivatives and gradients extend local sensitivity from coordinate-by-coordinate change to change in any direction through a multivariable input space. Partial derivatives tell how a function changes when one input changes while the others are held fixed. Directional derivatives ask a more general question: how does the output change if the system moves along a specified direction that may combine several input changes at once?

In systems modeling, this matters because real systems rarely move along clean coordinate axes. Exposure, vulnerability, capacity, demand, temperature, cost, infrastructure load, policy intensity, and behavioral response may shift together. The gradient gathers local partial derivatives into a sensitivity vector, while the directional derivative uses that vector to estimate local change along a chosen path, scenario, perturbation, or feasible direction.

This article introduces directional derivatives and gradients as tools for interpreting local change in higher-dimensional systems. It examines directional movement, unit vectors, gradient notation, steepest increase, contour interpretation, feasible directions, scaling, local validity, computational workflows, and responsible interpretation in systems modeling.

A partial derivative answers how a model changes along one coordinate direction. A directional derivative answers how a model changes along any chosen direction. The gradient makes that possible by collecting local sensitivities into a vector. Together, directional derivatives and gradients help modelers interpret scenarios, perturbations, pathways, local optimization, and movement across complex response surfaces.

Why Directional Derivatives Matter

Directional derivatives matter because system movement is often joint, not coordinate-by-coordinate. A partial derivative asks what happens if one variable changes and the others stay fixed. A directional derivative asks what happens if the input state moves in a specified direction through the input space.

For a two-variable function:

A directional derivative measures local change in the direction of a vector \(\mathbf{u}\):

This is more flexible than a partial derivative. Instead of changing only \(x\) or only \(y\), the model can move along a pathway where both change together. That pathway might represent a policy scenario, a disturbance, a feasible adjustment, a transition path, or a stress direction.

Directional derivatives therefore extend local calculus from isolated sensitivity to movement through a modeled system space.

Back to top ↑

What Is a Directional Derivative?

A directional derivative measures the rate of change of a function at a point in a specified direction. For a function \(f:\mathbb{R}^n\to\mathbb{R}\), a point \(\mathbf{x}\), and a unit direction vector \(\mathbf{u}\), the directional derivative is:

If the function is differentiable, the directional derivative can be computed using the gradient:

For example, consider:

The gradient is:

At \((4,3)\), the gradient is:

If the chosen unit direction is:

then the directional derivative is:

The direction matters. A model can have high sensitivity in one direction, low sensitivity in another, and no first-order change along directions tangent to a level curve.

Back to top ↑

What Is the Gradient?

The gradient is the vector of all first partial derivatives of a scalar-valued function. For:

the gradient is:

The gradient has both magnitude and direction. Its magnitude tells how large the local sensitivity is overall:

Its direction points toward steepest local increase:

In systems modeling, the gradient can be understood as a local sensitivity map. It tells which combination of input movements would most increase the modeled output near the current state. But that does not automatically mean the direction is feasible, desirable, causal, or ethical.

The gradient is one of the central objects connecting calculus, optimization, sensitivity analysis, machine learning, control, and scientific computing.

Back to top ↑

From Total Differentials to Directional Change

The directional derivative is closely connected to the total differential. A total differential estimates change from a small displacement \(d\mathbf{x}\):

If the displacement is written as:

then:

This gives the relationship:

This connection matters in modeling. A total differential evaluates a specific small displacement. A directional derivative evaluates the local rate along a normalized direction. If the modeler wants estimated output change, use the displacement magnitude. If the modeler wants local rate per unit movement, use the directional derivative.

Directional derivatives therefore translate the gradient into interpretable movement through the input space.

Back to top ↑

Unit Vectors and Direction Choice

A directional derivative is usually defined using a unit vector. This ensures that the derivative measures rate per unit distance rather than being inflated or reduced by the length of the direction vector.

Given a nonzero vector \(\mathbf{v}\), the corresponding unit vector is:

For example, the vector \((2,1)\) indicates movement twice as strongly in \(x\) as in \(y\). Its unit version is:

In systems modeling, the chosen direction should not be arbitrary. It should represent a meaningful perturbation, scenario, feasible pathway, stress pattern, intervention profile, or transition direction.

The direction vector is part of the modeling claim. It should be documented just as carefully as the function and reference state.

Back to top ↑

Steepest Increase and Decrease

The gradient points in the direction of steepest local increase. The maximum directional derivative is the gradient norm:

The direction of steepest local decrease is the negative gradient:

This is the foundation of gradient-based optimization. To increase an objective, move approximately with the gradient. To reduce a loss, risk, error, or cost, move approximately against the gradient.

However, “steepest” is a mathematical statement under assumptions about scale, units, distance, and feasibility. If one input is measured in dollars and another in degrees, the gradient depends on those units. If movement is constrained, the unconstrained steepest direction may be impossible. If the surface is highly curved, a local steepest direction may not remain useful after a large step.

Gradient reasoning is most responsible when the modeler states whether the direction is mathematical, feasible, policy-relevant, or scenario-based.

Back to top ↑

Contours, Surfaces, and Geometric Meaning

For a function \(f(x,y)\), contours are level curves where the output is constant:

The gradient is perpendicular to level curves where the function is differentiable and the gradient is nonzero. This means:

Movement along a contour produces no first-order change in output:

This geometric interpretation is useful in systems modeling. Contours can represent equal risk, equal cost, equal output, equal temperature response, equal congestion, or equal welfare. The gradient shows how to move most quickly across those contours. A tangent direction shows how to change inputs while preserving the output locally.

Contour and gradient interpretation can be powerful, but it depends on the plotted dimensions and the variables held fixed outside the visualization.

Back to top ↑

Scale, Units, and Normalization

Gradients depend on the units of the input variables. If one input is measured in meters and another in kilometers, the gradient components change. If one input is measured in dollars and another in percentages, the gradient direction may be hard to interpret without scaling.

This matters because the phrase “steepest direction” depends on how distance is measured in input space. The ordinary Euclidean norm treats each coordinate according to its numerical units. That may or may not reflect meaningful system distance.

When variables have different units, modelers may need normalized variables, nondimensionalization, standardized inputs, weighted metrics, or domain-specific scaling. Otherwise, gradient directions can be dominated by arbitrary units rather than meaningful sensitivity.

Gradient interpretation should therefore include scale and unit documentation, especially when used to compare inputs or guide decisions.

Back to top ↑

Constraints and Feasible Directions

Directional derivatives can be computed in any mathematical direction, but systems often allow only some directions. Constraints may come from budgets, capacities, conservation laws, physical boundaries, policy rules, institutional limits, data support, or ethical requirements.

If inputs must satisfy a constraint such as:

then feasible directions must lie tangent to that constraint. A direction that points off the constraint may be mathematically available but systemically impossible.

For a budget constraint:

feasible small movements satisfy:

This changes directional interpretation. The gradient direction may point toward steepest local increase, but if it violates the constraint, it is not a feasible movement. The relevant question becomes: which allowed direction gives the greatest increase or decrease?

Directional derivatives become more responsible when the direction is tied to feasible system movement rather than treated as a purely mathematical vector.

Back to top ↑

Local Validity and Reference States

Directional derivatives and gradients are local. They describe behavior near a reference state:

The same direction can have different directional derivatives at different points because the gradient can change across the input space:

This is essential in systems modeling. A direction that increases risk slowly under normal conditions may increase risk sharply near a capacity boundary. A mitigation direction may be effective near one regime but weak in another. A gradient near an equilibrium may not describe response after a large disturbance.

A directional derivative should therefore be reported with the reference state, direction vector, normalization rule, units, and validity region.

Back to top ↑

Systems Modeling Interpretation

Directional derivatives and gradients help modelers move from “which variable matters?” to “which direction of system movement matters?” That shift is important because real systems often change through combinations of variables. A gradient can identify local sensitivity structure. A directional derivative can evaluate a proposed movement through that structure.

A risk model might be written as:

The gradient might show local sensitivities:

A directional derivative might evaluate a combined scenario:

This can clarify whether a system is more vulnerable to one stress pathway than another. It can also show whether a mitigation pathway moves against the gradient of risk or only weakly changes the output.

Yet the gradient is not the system. It does not automatically encode causality, feasibility, ethics, feedback, delay, path dependence, measurement uncertainty, or institutional adaptation. Those must be added through model design, scenario construction, and interpretation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Directional derivatives, gradients, and local linear maps are closely linked. For differentiable scalar-valued functions, every directional derivative is determined by the gradient through a dot product. But the existence of directional derivatives alone does not always guarantee differentiability. A function can have directional derivatives in many directions and still fail to have a reliable local linear approximation.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for directional derivatives and gradients should record the function, reference state, gradient, chosen direction vector, normalization rule, directional derivative, step size, estimated change, actual change when available, approximation error, feasibility status, and local-validity warning.

Good workflows compare multiple directions at the same reference state, test gradient and negative-gradient directions, evaluate scenario-based directions, and flag directions that violate constraints. When inputs have different units or scales, workflows should also record whether normalization, standardization, or nondimensionalization was used.

Back to top ↑

Python Workflow: Directional Derivative Audit

The Python workflow below computes gradients, normalizes direction vectors, evaluates directional derivatives, compares local estimates with actual changes, and flags infeasible directions.

from __future__ import annotations

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


@dataclass(frozen=True)
class DirectionalDerivativeRecord:
    x: float
    y: float
    direction_x: float
    direction_y: float
    unit_x: float
    unit_y: float
    gradient_x: float
    gradient_y: float
    directional_derivative: float
    step_size: float
    estimated_change: float
    actual_change: float
    absolute_error: float
    feasible_direction: bool
    warning: str


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


def gradient(x: float, y: float) -> tuple[float, float]:
    return (3.0 + 0.5 * y, 2.0 + 0.5 * x)


def normalize(vx: float, vy: float) -> tuple[float, float]:
    norm = math.sqrt(vx * vx + vy * vy)
    if norm == 0:
        raise ValueError("Direction vector must be nonzero.")
    return (vx / norm, vy / norm)


def directional_derivative(x: float, y: float, ux: float, uy: float) -> float:
    gx, gy = gradient(x, y)
    return gx * ux + gy * uy


def feasible_direction(x: float, y: float, ux: float, uy: float, step: float) -> bool:
    return x >= 0 and y >= 0 and x + y <= 10 and x + step * ux >= 0 and y + step * uy >= 0 and x + step * ux + y + step * uy <= 10


def audit_direction(x: float, y: float, vx: float, vy: float, step: float) -> DirectionalDerivativeRecord:
    ux, uy = normalize(vx, vy)
    gx, gy = gradient(x, y)
    derivative = directional_derivative(x, y, ux, uy)
    baseline = f(x, y)
    actual = f(x + step * ux, y + step * uy)
    actual_change = actual - baseline
    estimated_change = step * derivative
    feasible = feasible_direction(x, y, ux, uy, step)

    return DirectionalDerivativeRecord(
        x=x,
        y=y,
        direction_x=vx,
        direction_y=vy,
        unit_x=ux,
        unit_y=uy,
        gradient_x=gx,
        gradient_y=gy,
        directional_derivative=derivative,
        step_size=step,
        estimated_change=estimated_change,
        actual_change=actual_change,
        absolute_error=abs(actual_change - estimated_change),
        feasible_direction=feasible,
        warning="" if feasible else "Direction and step move outside the feasible region."
    )


records = [
    audit_direction(4.0, 3.0, 1.0, 1.0, 0.25),
    audit_direction(4.0, 3.0, 2.0, -1.0, 0.25),
    audit_direction(8.0, 1.0, 1.0, 1.0, 1.0)
]

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" / "directional_derivative_gradient_audit.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" / "directional_derivative_gradient_audit.json").write_text(
    json.dumps([asdict(record) for record in records], indent=2),
    encoding="utf-8"
)

print("Wrote directional derivative and gradient audit.")

This workflow makes the direction, normalization, gradient, local estimate, actual change, approximation error, and feasibility status explicit.

Back to top ↑

R Workflow: Gradient and Direction Diagnostics

The R workflow below compares directional derivatives across several directions at the same reference state.

# Directional Derivatives and Gradients
# Base R workflow for gradient and direction diagnostics.

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

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

normalize <- function(v) {
  norm_value <- sqrt(sum(v^2))
  if (norm_value == 0) {
    stop("Direction vector must be nonzero.")
  }
  v / norm_value
}

directional_derivative <- function(x, y, direction) {
  unit_direction <- normalize(direction)
  sum(gradient(x, y) * unit_direction)
}

feasible_direction <- function(x, y, unit_direction, step) {
  x >= 0 & y >= 0 & x + y <= 10 &
    x + step * unit_direction[1] >= 0 &
    y + step * unit_direction[2] >= 0 &
    x + step * unit_direction[1] + y + step * unit_direction[2] <= 10
}

audit_direction <- function(x, y, direction_x, direction_y, step) {
  direction <- c(direction_x, direction_y)
  unit_direction <- normalize(direction)
  grad <- gradient(x, y)
  derivative <- sum(grad * unit_direction)
  baseline <- f(x, y)
  actual <- f(x + step * unit_direction[1], y + step * unit_direction[2])
  actual_change <- actual - baseline
  estimated_change <- step * derivative
  feasible <- feasible_direction(x, y, unit_direction, step)

  data.frame(
    x = x,
    y = y,
    direction_x = direction_x,
    direction_y = direction_y,
    unit_x = unit_direction[1],
    unit_y = unit_direction[2],
    gradient_x = grad[1],
    gradient_y = grad[2],
    directional_derivative = derivative,
    step_size = step,
    estimated_change = estimated_change,
    actual_change = actual_change,
    absolute_error = abs(actual_change - estimated_change),
    feasible_direction = feasible,
    warning = ifelse(feasible, "", "Direction and step move outside the feasible region.")
  )
}

results <- rbind(
  audit_direction(4.0, 3.0, 1.0, 1.0, 0.25),
  audit_direction(4.0, 3.0, 2.0, -1.0, 0.25),
  audit_direction(8.0, 1.0, 1.0, 1.0, 1.0)
)

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

print(results)

This workflow helps compare scenario directions, gradient-aligned directions, and infeasible directions using the same reference function.

Back to top ↑

Haskell Workflow: Typed Directional Records

Haskell can represent directional derivative calculations with explicit types for reference state, direction, normalized direction, gradient, derivative, approximation error, feasibility, and warning.

module Main where

newtype XInput = XInput Double deriving (Show)
newtype YInput = YInput Double deriving (Show)
newtype DirectionX = DirectionX Double deriving (Show)
newtype DirectionY = DirectionY Double deriving (Show)
newtype UnitX = UnitX Double deriving (Show)
newtype UnitY = UnitY Double deriving (Show)
newtype GradientX = GradientX Double deriving (Show)
newtype GradientY = GradientY Double deriving (Show)
newtype DirectionalDerivative = DirectionalDerivative Double deriving (Show)
newtype StepSize = StepSize Double deriving (Show)
newtype AbsoluteError = AbsoluteError Double deriving (Show)

data Feasibility
  = Feasible
  | Infeasible
  deriving (Show)

data DirectionalDerivativeRecord = DirectionalDerivativeRecord
  { xInput :: XInput
  , yInput :: YInput
  , directionX :: DirectionX
  , directionY :: DirectionY
  , unitX :: UnitX
  , unitY :: UnitY
  , gradientX :: GradientX
  , gradientY :: GradientY
  , derivativeValue :: DirectionalDerivative
  , stepSize :: StepSize
  , absoluteError :: AbsoluteError
  , feasibility :: Feasibility
  , warning :: String
  } deriving (Show)

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

gradient :: Double -> Double -> (Double, Double)
gradient x y = (3.0 + 0.5 * y, 2.0 + 0.5 * x)

normalize :: Double -> Double -> (Double, Double)
normalize vx vy =
  let normValue = sqrt (vx * vx + vy * vy)
  in if normValue == 0
     then error "Direction vector must be nonzero."
     else (vx / normValue, vy / normValue)

directionalDerivative :: Double -> Double -> Double -> Double -> Double
directionalDerivative x y ux uy =
  let (gx, gy) = gradient x y
  in gx * ux + gy * uy

isFeasible :: Double -> Double -> Double -> Double -> Double -> Bool
isFeasible x y ux uy step =
  x >= 0 && y >= 0 && x + y <= 10 &&
  x + step * ux >= 0 && y + step * uy >= 0 &&
  x + step * ux + y + step * uy <= 10

auditDirection :: Double -> Double -> Double -> Double -> Double -> DirectionalDerivativeRecord
auditDirection x y vx vy step =
  let (ux, uy) = normalize vx vy
      (gx, gy) = gradient x y
      derivative = directionalDerivative x y ux uy
      baseline = f x y
      actual = f (x + step * ux) (y + step * uy)
      actualChange = actual - baseline
      estimatedChange = step * derivative
      errorValue = abs (actualChange - estimatedChange)
      feasible = isFeasible x y ux uy step
  in DirectionalDerivativeRecord
      { xInput = XInput x
      , yInput = YInput y
      , directionX = DirectionX vx
      , directionY = DirectionY vy
      , unitX = UnitX ux
      , unitY = UnitY uy
      , gradientX = GradientX gx
      , gradientY = GradientY gy
      , derivativeValue = DirectionalDerivative derivative
      , stepSize = StepSize step
      , absoluteError = AbsoluteError errorValue
      , feasibility = if feasible then Feasible else Infeasible
      , warning = if feasible then "" else "Direction and step move outside the feasible region."
      }

main :: IO ()
main = do
  print (auditDirection 4.0 3.0 1.0 1.0 0.25)
  print (auditDirection 4.0 3.0 2.0 (-1.0) 0.25)
  print (auditDirection 8.0 1.0 1.0 1.0 1.0)

The typed structure helps prevent direction choice, normalization, gradient calculation, and feasibility review from being collapsed into a single derivative value.

Back to top ↑

SQL Workflow: Directional Derivative Assumption Registry

SQL can document directional derivative assumptions when gradients and direction-based sensitivities support model cards, dashboards, reports, or governance reviews.

CREATE TABLE directional_derivative_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 directional_derivative_assumption_registry VALUES
(
  'reference_state',
  'Reference state',
  'Identifies where the gradient and directional derivative are evaluated.',
  'Anchors directional sensitivity to a baseline, scenario, equilibrium, or operating condition.',
  'A directional derivative should not be interpreted without its reference point.'
);

INSERT INTO directional_derivative_assumption_registry VALUES
(
  'direction_vector',
  'Direction vector',
  'Defines the movement direction through input space.',
  'Connects derivative interpretation to a scenario, pathway, perturbation, or intervention profile.',
  'An undocumented direction makes the derivative uninterpretable.'
);

INSERT INTO directional_derivative_assumption_registry VALUES
(
  'normalization_rule',
  'Normalization rule',
  'Specifies how the direction vector is converted to a unit vector.',
  'Allows rate comparisons across directions.',
  'Directional derivatives are not comparable if directions are not normalized consistently.'
);

INSERT INTO directional_derivative_assumption_registry VALUES
(
  'gradient_scale',
  'Gradient scale',
  'Records the units and scaling used for gradient components.',
  'Prevents unit artifacts from being mistaken for meaningful sensitivity.',
  'Gradient direction depends on scaling and the metric used in input space.'
);

INSERT INTO directional_derivative_assumption_registry VALUES
(
  'feasible_direction',
  'Feasible direction',
  'Checks whether movement respects constraints.',
  'Separates arbitrary mathematical direction from plausible system movement.',
  'The steepest mathematical direction may not be feasible, ethical, or implementable.'
);

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

This registry keeps directional-derivative interpretation tied to reference state, direction vector, normalization, gradient scale, and feasible movement.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports directional derivative audits, gradient calculations, direction normalization, gradient-dot-direction estimates, feasible-direction diagnostics, local approximation checks, SQL assumption registries, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Directional derivatives and gradients are useful because they organize local sensitivity and evaluate movement through input space. They are risky when treated as global directions of truth, causality, or policy action. A gradient is local. A directional derivative is tied to a point, a direction, a normalization rule, a metric, and a feasible movement assumption.

Responsible use requires several checks. State the function. Define each input and unit. State the reference point. Report the gradient. Define the direction vector. Explain how it was normalized. Clarify whether the direction is mathematical, scenario-based, constrained, or feasible. Compare local estimates with actual changes when possible. Document scaling choices. Avoid treating steepest mathematical increase or decrease as an automatic recommendation.

The central modeling question is not only “What is the gradient?” It is “At what reference state, under which units and scaling, in which direction, within what feasible region, and for what local-validity claim does this gradient support interpretation?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Functions of Several Variables
• Partial Derivatives and Interaction Effects
• Total Differentials and Local Approximation in Higher Dimensions
• Jacobians and Multivariable Transformation
• Hessians, Curvature, and Local Structure
• Constrained Optimization and Lagrange Multipliers
• Sensitivity Analysis in Systems Models
• 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.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: Dover Publications.
• 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.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University.

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.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: 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.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill.
• Spivak, M. (1965) Calculus on Manifolds: A Modern Approach to Classical Theorems of Advanced Calculus. New York: W.A. Benjamin.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning.

Back to top ↑