Directional Derivatives and Gradients: How Calculus Tracks Local Change Across System Pathways

Last Updated June 29, 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.

The practical question is not simply which variable has the largest partial derivative. It is which direction of movement matters in the actual system. A storm, policy change, investment shift, infrastructure shock, public-health intervention, or market transition usually changes several inputs at once. Directional derivatives give those combined movements a mathematical language, while gradients show how the model locally responds to them.

That language has to be handled carefully. A gradient depends on units, scaling, metric choice, normalization, feasible directions, and the reference state where it is evaluated. A steepest mathematical direction may be a poor policy direction. A feasible direction may be less steep but more meaningful. A direction supported by data may be safer than a visually attractive extrapolation. This article treats gradients as interpretive objects, not just vectors to compute.

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 ↑

Metric Choice, Weighted Gradients, and Unit-Aware Distance

The ordinary gradient uses the ordinary Euclidean idea of distance. That is appropriate in many mathematical settings, but systems models often combine variables with different units, costs, risks, and feasible ranges. A movement of one degree Celsius, one million dollars, one percentage point, one kilometer, and one unit of exposure cannot be treated as equally meaningful merely because each is written as a one-unit coordinate change.

A scaled input can be written as:

In vector form, scaling can be represented by a diagonal matrix:

Gradient interpretation changes under this transformation. If the model is analyzed in scaled coordinates, the gradient answers a different but often more meaningful question: how does the output change per standardized movement, per operating-range movement, or per practically comparable movement? This can make sensitivities more interpretable than raw derivatives when variables have different units or magnitudes.

A weighted distance can also be defined as:

This is why gradient-based claims should name the metric. “Steepest” only has meaning after the modeler specifies how distance through input space is measured.

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 ↑

Projected Gradients and Constraint Geometry

When a system is constrained, the unconstrained gradient may point partly or entirely outside the feasible region. In that case, the relevant local direction is not simply \(\nabla f\). It is the component of the gradient that lies along the feasible set, or a direction chosen from the tangent space of the constraint.

For a smooth equality constraint:

A feasible infinitesimal direction \(\mathbf{v}\) must satisfy:

If the constraint gradient is nonzero, the component of \(\nabla f\) tangent to the constraint can be understood by removing the component normal to the feasible surface. One common projection form is:

This matters because constrained systems have constrained directions of action. A city cannot increase every infrastructure investment independently under a fixed budget. A physical system cannot violate conservation laws. A health intervention cannot treat vulnerability, exposure, behavior, and capacity as freely adjustable if they move through institutional constraints. A projected gradient is often closer to a feasible local improvement direction than the raw gradient.

The projected gradient also prepares the reader for Lagrange multipliers, constrained optimization, and multiplier-based interpretation of tradeoffs. It turns “which direction is steepest?” into the more responsible question: “which direction is steepest among directions the system can actually take?”

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 ↑

Numerical Gradients, Automatic Differentiation, and Gradient Checks

In applied modeling, gradients may come from symbolic calculus, numerical finite differences, automatic differentiation, adjoint methods, or fitted surrogate models. These sources are not interchangeable. Each carries different assumptions about accuracy, smoothness, implementation, computational cost, and auditability.

A finite-difference directional derivative can be estimated by:

A central-difference version is often more accurate for smooth functions:

Finite differences require step-size discipline. If \(h\) is too large, the estimate may reflect curvature rather than local derivative. If \(h\) is too small, roundoff error may dominate. Automatic differentiation can provide highly accurate derivatives of implemented computational graphs, but it differentiates the code that was written, not necessarily the real system the code is meant to represent.

A responsible workflow should compare derivative sources where possible. Analytic gradients can be checked against finite differences. Automatic gradients can be checked at representative points. Scenario derivatives can be checked by small finite movements along the scenario direction. Derivative provenance should be part of the output, not hidden inside the code.

Back to top ↑

High-Dimensional Gradients and Sparse Directional Reasoning

High-dimensional gradients can be informative and overwhelming at the same time. A model with hundreds or thousands of inputs may have a gradient with hundreds or thousands of components. The gradient may technically identify local sensitivity, but the modeling problem becomes interpretation: which components matter, which groups of variables matter together, and which directions correspond to plausible system movement?

One useful decomposition is to compare the contribution of each component to a proposed displacement:

Another useful practice is sparse directional reasoning. Instead of interpreting every possible direction, the modeler evaluates a small set of meaningful directions: a stress pathway, a feasible policy bundle, a principal uncertainty pattern, a worst-case perturbation within constraints, a mitigation pathway, or a transition scenario.

High-dimensional gradient work should therefore move from raw vectors to documented directions, scaled contributions, reference-state comparisons, and feasibility-aware interpretation.

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

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 directional derivatives can exist without a well-behaved total linear approximation, and gradient interpretation depends on the metric, scaling, constraints, and reference state. The formal structure is what keeps sensitivity, movement, and feasibility from being collapsed into one misleading number.

Formal Structure

Directional Derivative

\(D_{\mathbf{u}}f(\mathbf{x})\) measures local change in the unit direction \(\mathbf{u}\).

Gradient

\(\nabla f\) collects all first partial derivatives of a scalar-valued function.

Dot Product

The formula \(D_{\mathbf{u}}f=\nabla f\cdot\mathbf{u}\) connects sensitivity to movement.

Gradient Norm

\(\|\nabla f\|\) gives the maximum directional derivative under unit Euclidean movement.

Geometric Structure

Contours

Level curves identify equal-output combinations in the input space.

Orthogonality

The gradient is perpendicular to level curves where the function is smooth and the gradient is nonzero.

Tangent Directions

Directions tangent to a contour produce zero first-order change.

Steepest Directions

The gradient and negative gradient identify steepest local increase and decrease.

Validity and Constraints

Unit Normalization

Directional derivatives require normalized direction vectors for rate comparison.

Unit Dependence

Gradient interpretation depends on scaling, units, and the metric used in input space.

Feasible Direction

Responsible modeling distinguishes arbitrary directions from allowed system movement.

Local Validity

Directional derivatives are tied to the reference state and local smoothness of the model.

Metric and Computation

Metric Dependence

Steepest direction depends on how distance is measured in the input space.

Projected Gradient

Under constraints, the relevant gradient direction may be the feasible tangent component.

Derivative Provenance

Analytic, numerical, automatic, adjoint, and surrogate gradients carry different audit requirements.

Gradient Checking

Finite-difference directional checks can test whether implemented gradients behave as expected.

Advanced Modeling Implications

State the Direction

Every directional derivative claim should identify the direction vector and its normalization.

State the Metric

Gradient comparison depends on how distance and scale are defined across variables.

State Feasibility

The direction should be identified as arbitrary, scenario-based, constrained, or feasible.

State the Reference Point

The gradient and directional derivative should be reported at a specified point or region.

Back to top ↑

Examples from Systems Modeling

Directional derivatives and gradients appear throughout systems modeling because system change often follows pathways rather than isolated variables.

Risk Pathways

A directional derivative can estimate how risk changes when exposure rises, vulnerability rises, and capacity falls together.

Infrastructure Stress

The gradient can show local sensitivity to demand, capacity, redundancy, and routing under current operating conditions.

Climate Response

Directional movement through forcing, feedback, and uptake variables can approximate local temperature-response changes.

Economic Adjustment

A directional derivative can evaluate a combined shift in labor, capital, technology, and coordination.

Policy Design

Gradient direction may suggest mathematical leverage, while feasible directions restrict movement to implementable pathways.

Uncertainty Analysis

Uncertainty directions can show which correlated input-error patterns create the largest local output change.

Constrained Investment

Projected gradients can compare feasible reallocations when total spending, staffing, or capacity cannot increase freely.

Machine Learning Diagnostics

Gradient directions can reveal which input perturbations most change a model output, while scaling and feasibility determine whether those perturbations are meaningful.

Across these cases, the key question is not only whether the gradient is large, but whether the direction of movement is meaningful, feasible, scaled properly, and locally valid.

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, metric or scaling convention, directional derivative, step size, estimated change, actual change when available, approximation error, feasibility status, derivative provenance, 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, nondimensionalization, or weighted distance was used.

Gradient workflows should also support audit checks. A symbolic or automatic gradient should be compared against finite differences at representative points. A scenario direction should be normalized explicitly. A projected or constrained direction should document the constraint being respected. In high-dimensional models, the workflow should report component contributions so readers can see which inputs drive the directional estimate.

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
    direction_norm: float
    unit_x: float
    unit_y: float
    gradient_x: float
    gradient_y: float
    gradient_norm: float
    component_x: float
    component_y: float
    directional_derivative: float
    forward_difference_estimate: float
    central_difference_estimate: float
    step_size: float
    estimated_change: float
    actual_change: float
    absolute_error: float
    feasible_direction: bool
    derivative_provenance: str
    scaling_note: str
    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 vector_norm(vx: float, vy: float) -> float:
    return math.sqrt(vx * vx + vy * vy)


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


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


def finite_difference_directional(x: float, y: float, ux: float, uy: float, h: float) -> tuple[float, float]:
    forward = (f(x + h * ux, y + h * uy) - f(x, y)) / h
    central = (f(x + h * ux, y + h * uy) - f(x - h * ux, y - h * uy)) / (2.0 * h)
    return forward, central


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, direction_norm = normalize(vx, vy)
    gx, gy = gradient(x, y)
    grad_norm = vector_norm(gx, gy)
    derivative = directional_derivative_from_gradient(x, y, ux, uy)
    forward_fd, central_fd = finite_difference_directional(x, y, ux, uy, h=min(1e-4, max(step / 1000.0, 1e-6)))

    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)

    warnings: list[str] = []
    if not feasible:
        warnings.append("Direction and step move outside the feasible region.")
    if step > 0.5:
        warnings.append("Step is large for a first-order directional approximation; compare against actual change.")
    if abs(forward_fd - derivative) > 1e-3:
        warnings.append("Forward finite-difference check differs from analytic gradient; review step size or derivative implementation.")

    return DirectionalDerivativeRecord(
        x=x,
        y=y,
        direction_x=vx,
        direction_y=vy,
        direction_norm=direction_norm,
        unit_x=ux,
        unit_y=uy,
        gradient_x=gx,
        gradient_y=gy,
        gradient_norm=grad_norm,
        component_x=gx * ux,
        component_y=gy * uy,
        directional_derivative=derivative,
        forward_difference_estimate=forward_fd,
        central_difference_estimate=central_fd,
        step_size=step,
        estimated_change=estimated_change,
        actual_change=actual_change,
        absolute_error=abs(actual_change - estimated_change),
        feasible_direction=feasible,
        derivative_provenance="analytic gradient checked with finite differences",
        scaling_note="raw Euclidean direction; document scaling before comparing unlike units",
        warning=" ".join(warnings)
    )


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(4.0, 3.0, 4.5, 4.0, 0.25),  # gradient-aligned direction
    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, direction, and finite-difference 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)
}

finite_difference_directional <- function(x, y, unit_direction, h) {
  forward <- (f(x + h * unit_direction[1], y + h * unit_direction[2]) - f(x, y)) / h
  central <- (
    f(x + h * unit_direction[1], y + h * unit_direction[2]) -
      f(x - h * unit_direction[1], y - h * unit_direction[2])
  ) / (2 * h)

  c(forward = forward, central = central)
}

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)
  direction_norm <- sqrt(sum(direction^2))
  unit_direction <- normalize(direction)
  grad <- gradient(x, y)
  gradient_norm <- sqrt(sum(grad^2))
  derivative <- sum(grad * unit_direction)
  fd <- finite_difference_directional(x, y, unit_direction, h = min(1e-4, max(step / 1000, 1e-6)))

  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)

  warning <- ifelse(feasible, "", "Direction and step move outside the feasible region.")
  if (step > 0.5) {
    warning <- paste(warning, "Step is large for a first-order approximation; compare against actual change.")
  }

  data.frame(
    x = x,
    y = y,
    direction_x = direction_x,
    direction_y = direction_y,
    direction_norm = direction_norm,
    unit_x = unit_direction[1],
    unit_y = unit_direction[2],
    gradient_x = grad[1],
    gradient_y = grad[2],
    gradient_norm = gradient_norm,
    component_x = grad[1] * unit_direction[1],
    component_y = grad[2] * unit_direction[2],
    directional_derivative = derivative,
    forward_difference_estimate = fd["forward"],
    central_difference_estimate = fd["central"],
    step_size = step,
    estimated_change = estimated_change,
    actual_change = actual_change,
    absolute_error = abs(actual_change - estimated_change),
    feasible_direction = feasible,
    derivative_provenance = "analytic gradient checked with finite differences",
    scaling_note = "raw Euclidean direction; document scaling before comparing unlike units",
    warning = trimws(warning)
  )
}

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(4.0, 3.0, 4.5, 4.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 EstimatedChange = EstimatedChange Double deriving (Show)
newtype ActualChange = ActualChange 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
  , estimatedChange :: EstimatedChange
  , actualChange :: ActualChange
  , absoluteError :: AbsoluteError
  , feasibility :: Feasibility
  , derivativeProvenance :: String
  , 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)
      change = actual - baseline
      estimate = step * derivative
      errorValue = abs (change - estimate)
      feasible = isFeasible x y ux uy step
      warningText =
        if feasible
        then ""
        else "Direction and step move outside the feasible region."
  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
      , estimatedChange = EstimatedChange estimate
      , actualChange = ActualChange change
      , absoluteError = AbsoluteError errorValue
      , feasibility = if feasible then Feasible else Infeasible
      , derivativeProvenance = "analytic gradient from explicit formula"
      , warning = warningText
      }

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
(
  'metric_choice',
  'Metric choice',
  'Defines how distance and steepness are measured in the input space.',
  'Clarifies whether gradients are raw, standardized, cost-weighted, risk-weighted, or constrained.',
  'The steepest direction can change when the metric or scaling changes.'
);

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
(
  'derivative_provenance',
  'Derivative provenance',
  'Documents whether the gradient is analytic, numerical, automatic, adjoint, or surrogate-derived.',
  'Makes derivative calculations reproducible and auditable.',
  'A derivative may be correct for the implemented code but not for the intended system relationship.'
);

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. Available at: https://www.wiley.com/en-us/Calculus%2C+Volume+2%2C+2nd+Edition-p-9780471000075.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning. Available at: https://www.cengage.com/c/calculus-early-transcendentals-8e-stewart/.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman. Available at: https://store.macmillanlearning.com/us/product/Vector-Calculus/p/1429215089.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: Dover Publications. Available at: https://store.doverpublications.com/products/9780486683362.
• Spivak, M. (1965) Calculus on Manifolds: A Modern Approach to Classical Theorems of Advanced Calculus. New York: W.A. Benjamin. Available at: https://www.routledge.com/Calculus-On-Manifolds-A-Modern-Approach-To-Classical-Theorems-Of-Advanced-Calculus/Spivak/p/book/9780805390216.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: https://www.mheducation.com/highered/product/principles-mathematical-analysis-rudin/M9780070542358.html.
• 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: https://matrixeditions.com/5thUnifiedApproach.html.
• Munkres, J.R. (1991) Analysis on Manifolds. Boca Raton, FL: CRC Press. Available at: https://www.routledge.com/Analysis-On-Manifolds/Munkres/p/book/9780201315967.
• Krantz, S.G. and Parks, H.R. (2012) The Implicit Function Theorem: History, Theory, and Applications. Boston, MA: Birkhäuser. Available at: https://link.springer.com/book/10.1007/978-1-4614-5981-1.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-0-387-40065-5.
• Griewank, A. and Walther, A. (2008) Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898717761.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/b98885.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/9780470725184.
• Saltelli, A. et al. (2004) Sensitivity Analysis in Practice: A Guide to Assessing Scientific Models. Chichester: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/0470870958.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill. Available at: https://mitsloan.mit.edu/faculty/directory/john-d-sterman.
• Strogatz, S.H. (2015) Nonlinear Dynamics and Chaos. 2nd edn. Boulder, CO: Westview Press. Available at: https://www.routledge.com/Nonlinear-Dynamics-and-Chaos-With-Student-Solutions-Manual-With-applications-to-Physics-Biology-Chemistry-and-Engineering/Strogatz/p/book/9780813349107.
• Massachusetts Institute of Technology OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-02sc-multivariable-calculus-fall-2010/.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University. Available at: https://openstax.org/details/books/calculus-volume-3.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 1, Algebraic and Analytic Methods. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/1.
• NumPy Developers (n.d.) numpy.gradient. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/generated/numpy.gradient.html.
• SciPy Developers (n.d.) Numerical Differentiation: scipy.differentiate. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/differentiate.html.
• JAX Authors (n.d.) Automatic Differentiation with JAX. JAX Documentation. Available at: https://docs.jax.dev/en/latest/automatic-differentiation.html.

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: https://www.wiley.com/en-us/Calculus%2C+Volume+2%2C+2nd+Edition-p-9780471000075.
• Stewart, J. (2015) Calculus: Early Transcendentals. 8th edn. Boston, MA: Cengage Learning. Available at: https://www.cengage.com/c/calculus-early-transcendentals-8e-stewart/.
• Marsden, J.E. and Tromba, A.J. (2012) Vector Calculus. 6th edn. New York: W.H. Freeman. Available at: https://store.macmillanlearning.com/us/product/Vector-Calculus/p/1429215089.
• Edwards, C.H. (1994) Advanced Calculus of Several Variables. New York: Dover Publications. Available at: https://store.doverpublications.com/products/9780486683362.
• Spivak, M. (1965) Calculus on Manifolds: A Modern Approach to Classical Theorems of Advanced Calculus. New York: W.A. Benjamin. Available at: https://www.routledge.com/Calculus-On-Manifolds-A-Modern-Approach-To-Classical-Theorems-Of-Advanced-Calculus/Spivak/p/book/9780805390216.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: https://www.mheducation.com/highered/product/principles-mathematical-analysis-rudin/M9780070542358.html.
• 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: https://matrixeditions.com/5thUnifiedApproach.html.
• Munkres, J.R. (1991) Analysis on Manifolds. Boca Raton, FL: CRC Press. Available at: https://www.routledge.com/Analysis-On-Manifolds/Munkres/p/book/9780201315967.
• Krantz, S.G. and Parks, H.R. (2012) The Implicit Function Theorem: History, Theory, and Applications. Boston, MA: Birkhäuser. Available at: https://link.springer.com/book/10.1007/978-1-4614-5981-1.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-0-387-40065-5.
• Griewank, A. and Walther, A. (2008) Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898717761.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/b98885.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/9780470725184.
• Saltelli, A. et al. (2004) Sensitivity Analysis in Practice: A Guide to Assessing Scientific Models. Chichester: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/0470870958.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill. Available at: https://mitsloan.mit.edu/faculty/directory/john-d-sterman.
• Strogatz, S.H. (2015) Nonlinear Dynamics and Chaos. 2nd edn. Boulder, CO: Westview Press. Available at: https://www.routledge.com/Nonlinear-Dynamics-and-Chaos-With-Student-Solutions-Manual-With-applications-to-Physics-Biology-Chemistry-and-Engineering/Strogatz/p/book/9780813349107.
• Massachusetts Institute of Technology OpenCourseWare (2010) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-02sc-multivariable-calculus-fall-2010/.
• OpenStax (2016) Calculus Volume 3. Houston, TX: OpenStax, Rice University. Available at: https://openstax.org/details/books/calculus-volume-3.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 1, Algebraic and Analytic Methods. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/1.
• NumPy Developers (n.d.) numpy.gradient. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/generated/numpy.gradient.html.
• SciPy Developers (n.d.) Numerical Differentiation: scipy.differentiate. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/differentiate.html.
• JAX Authors (n.d.) Automatic Differentiation with JAX. JAX Documentation. Available at: https://docs.jax.dev/en/latest/automatic-differentiation.html.

Back to top ↑