Calculus for robots: derivatives, gradients, Jacobians

Calculus shows up in robotics roughly four ways: derivatives (velocities), gradients (optimization), Jacobians (kinematics, sensitivity), and the chain rule (backprop). Almost never as symbolic integration. Here's what to know cold.

The derivative — rate of change

For a scalar function $f:\mathbb{R}\to \mathbb{R}$:

$$f^{\prime }(x)=\underset{h\to 0}{\lim }\frac{f(x+h)-f(x)}{h}$$

In robotics, when the input is time, the derivative is a velocity:

• $v(t)=\dot{p}(t)$ — velocity is the time-derivative of position
• $a(t)=\ddot{p}(t)$ — acceleration is the time-derivative of velocity
• $\dot{\theta }(t)$ — joint velocity, the time-derivative of joint angle

You compute these in code via finite differences ($\dot{x}\approx (x_t-x_{t-1})/\Delta t$) or by reading from a sensor that measures velocity directly (gyroscope, encoder).

Partial derivatives — change in one direction

For a function of multiple inputs $f(x_1,x_2,\dots ,x_n)$, the partial derivative $\partial f/\partial x_i$ measures how f changes if you wiggle only $x_i$ and hold the others fixed.

Example: end-effector x-coordinate of a 2-DOF arm:

$$x=L_1\cos {\theta }_1+L_2\cos ({\theta }_1+{\theta }_2)$$ $$\frac{\partial x}{\partial {\theta }_1}=-L_1\sin {\theta }_1-L_2\sin ({\theta }_1+{\theta }_2)$$

Reads as: "if I move θ₁ a little, the end-effector x changes by this much per unit of θ₁."

Gradient — steepest-ascent direction

Stack the partials of a scalar function f with respect to each input into a vector:

$$\nabla f=\left[\begin{array}{c}\partial f/\partial x_1\\ \partial f/\partial x_2\\ ⋮\\ \partial f/\partial x_n\end{array}\right]$$

The gradient points in the direction of steepest increase. Gradient descent — the engine of every neural net trained — takes a step in the direction of the negative gradient:

$$x_{k+1}=x_k-\eta \nabla f(x_k)$$

Where η is the learning rate. That's it. That's gradient descent. Every modern ML framework wraps this in autograd machinery, but the operation is the same.

Jacobian — the matrix-valued partial derivative

For a function $\mathbf{f}:{\mathbb{R}}^n\to {\mathbb{R}}^m$ (vector input, vector output), the Jacobian J is the m×n matrix of partials:

$$J_{ij}=\frac{\partial f_i}{\partial x_j}$$

For an arm's forward kinematics, the Jacobian connects joint velocities to end-effector velocities:

$$\dot{\mathbf{x}}=J(\mathbf{\theta })\dot{\mathbf{\theta }}$$

If you know your robot's Jacobian, you know:

• Forward velocity kinematics: command joint velocities, predict end-effector velocity.
• Inverse velocity kinematics: want a particular end-effector velocity? Solve $\dot{\mathbf{\theta }}=J^{+}\dot{\mathbf{x}}$ (pseudoinverse).
• Manipulability: rank of J tells you in which directions the end-effector can move.
• Force mapping: end-effector forces map to joint torques via $\mathbf{\tau }=J^T\mathbf{f}$.

The Jacobian is the second-most-important matrix in robotics, after the rotation matrix.

Chain rule — the engine of backprop

If $y=f(g(x))$, then $dy/dx=f^{\prime }(g(x))\cdot g^{\prime }(x)$. For vector functions:

$$J_{f\circ g}=J_f\cdot J_g$$

This is how neural networks compute gradients: chain forward through the layers, propagate the Jacobians backward, multiply along the chain. PyTorch and JAX automate this; you almost never apply the chain rule by hand. But understanding it lets you debug autograd when it disagrees with your intuition.

Integrals you actually compute

In robotics, integrals are usually:

• Numerical: integrate a state forward through dynamics. Euler, RK4, etc.
• Symbolic for inertia tensors: ${\int }_V\rho (\mathbf{r}){\mathbf{r}}^T\mathbf{r}dV$ for rigid bodies. CAD tools or formulas, not pencil-and-paper.
• Probabilistic marginalization: $\int p(x,y)dy$. Closed form for Gaussians; otherwise approximate.

If you're solving an integral by integration-by-parts in robotics, you've taken a wrong turn.

Numerical differentiation in code

You will sometimes need a Jacobian without a closed form. Use finite differences:

def numerical_jacobian(f, x, h=1e-6):
    n = len(x)
    fx = f(x)
    m = len(fx)
    J = np.zeros((m, n))
    for j in range(n):
        x_perturbed = x.copy()
        x_perturbed[j] += h
        J[:, j] = (f(x_perturbed) - fx) / h
    return J

Two gotchas:

• Step size h: too small → rounding error; too big → truncation error. $h\approx 10^{-6}$ for double-precision inputs is a reasonable default.
• Central differences: $(f(x+h)-f(x-h))/(2h)$ is more accurate than forward differences but costs 2× function evaluations.

Modern robotics code increasingly uses autodiff (PyTorch, JAX) to get exact derivatives without finite differences. Faster and more accurate.

The 30-minute drill

Make sure you can do these without notes:

1. Compute $\partial /\partial x$ of $\sin (xy+1)$ (chain rule).
2. Compute the gradient of $f(x,y)=x^2+3xy+y^2$.
3. For the 2-DOF arm above, write the 2×2 Jacobian for the end-effector (x, y).
4. Implement gradient descent in 5 lines on a 2D quadratic.

If those land easily, you have enough calculus. Add depth as topics come up.

What you almost never need

• Integration by parts
• Trigonometric substitution
• Surface integrals (unless you're doing fluid sim)
• Differential forms
• Most of "Calculus 2"

Don't grind these. If you ever need them, they take an afternoon to refresh.

Next

Coordinate frames and unit hygiene — the silent source of half of all robotics bugs. After that, you have the math foundations done.