Free lesson · Partial derivatives

Gradients, directional derivatives and Jacobians

Open interactive lessonPractice calculationsExplore labs

Start here · the same idea in everyday words

Unpack a technical sentence

Technical wording: The gradient maps an input perturbation to a first-order output change.

Read it as: Find the slope for each input. Multiply each slope by that input’s small change, then add the contributions to estimate the output change.

A slower worked example · one step at a time

1. Use a dimensionless output f=x squared plus 3y at x=2 and y=1. The current output is 4+3=7.
2. Holding y fixed, the x slope is 2 times x, or 4. Holding x fixed, the y slope is 3. The gradient is the list [4,3].
3. Increase x by .01 and decrease y by .02. The x contribution is 4 times .01=.04. The y contribution is 3 times −.02=−.06.
4. Add the contributions: .04−.06=−.02. The predicted new output is 6.98.
5. Calculate directly: 2.01 squared plus 3 times .98 equals 6.9801. The difference .0001 is the quadratic x term omitted by the straight-line approximation.

• For a unit direction u, the directional derivative measures output change per unit distance in the chosen coordinate scale.
• Rescaling an input changes what a unit step means.
• This matters when combining prices, rates and volatility coordinates.
• If a model maps an input vector x to an output vector F, its Jacobian entry Jᵢⱼ is the partial derivative of output i with respect to input j.
• Multiplying J by a small input change gives a first-order output-change vector.
• The rows and columns must match the documented ordering.

Architecture pseudocode

def directional_quadratic(x,y,direction):
    ux,uy=direction
    if abs(ux*ux+uy*uy-1)>1e-9: raise ValueError("Unit direction required")
    return 2*x*ux+4*y*uy

def example_jacobian(x,y):
    return [[1,1],[y,x]]

def linear_output_change(jacobian,change):
    if any(len(row)!=len(change) for row in jacobian): raise ValueError("Dimensions must match")
    return [sum(a*b for a,b in zip(row,change)) for row in jacobian]

print(directional_quadratic(1,1,(.6,.8)),linear_output_change(example_jacobian(2,3),[.1,-.2]))

# Replay the slower, synthetic example above. Units are stated in its steps.
def plain_language_example():
    from math import exp, e  # Standard library; no extra dependency.
    return {
        "start": 2**2+3*1,
        "change": 4*.01+3*(-.02),
        "prediction": 7+4*.01+3*(-.02),
        "actual": 2.01**2+3*.98,
    }

print(plain_language_example())

An analogy to remember

A gradient is a slope map telling you how a hill rises in each coordinate direction. A Jacobian is a table of such responses when you are tracking several outputs at once.

How this becomes a building block

A Jacobian can map market-quote changes into instrument-price changes or map parameter changes into calibration errors. Reverse-mode automatic differentiation efficiently propagates a scalar output’s sensitivities backward through a computational graph; it differentiates the implemented operations, not an independently validated economic truth.

def directional_quadratic(x,y,direction):
    ux,uy=direction
    if abs(ux*ux+uy*uy-1)>1e-9: raise ValueError("Unit direction required")
    return 2*x*ux+4*y*uy

def example_jacobian(x,y):
    return [[1,1],[y,x]]

def linear_output_change(jacobian,change):
    if any(len(row)!=len(change) for row in jacobian): raise ValueError("Dimensions must match")
    return [sum(a*b for a,b in zip(row,change)) for row in jacobian]

print(directional_quadratic(1,1,(.6,.8)),linear_output_change(example_jacobian(2,3),[.1,-.2]))

# Replay the slower, synthetic example above. Units are stated in its steps.
def plain_language_example():
    from math import exp, e  # Standard library; no extra dependency.
    return {
        "start": 2**2+3*1,
        "change": 4*.01+3*(-.02),
        "prediction": 7+4*.01+3*(-.02),
        "actual": 2.01**2+3*.98,
    }

print(plain_language_example())