Calculus Formulas in LaTeX, Python and Rust

✅ Copy-ready code for calculus formulas in LaTeX, Python and Rust. For each formula, you'll see how to write it in LaTeX and how to calculate it in code. 😻

Every snippet runs on its own with no extra libraries, and the expected output is written in the comments. Use the tabs to switch between LaTeX, Python and Rust. To run a Rust snippet, save it as main.rs and run rustc main.rs, or paste it into the Rust Playground.

📚 Math Formulas in Code series

• Part 1: Algebra Formulas: exponents, logarithms, quadratics, lines and sequences
• Part 2: Linear Algebra Formulas: vectors, matrices and a neural network layer
• Part 3: Descriptive Statistics Formulas: mean, median, spread and correlation
• Part 4: Inferential Statistics Formulas: tests, confidence intervals, probability and regression
• Part 5: Calculus Formulas (you are here): derivatives, integrals and numerical methods

Just click the copy button in the top right corner of each code block!

Summary Overview

#	Formula	Example
1	Limits by Getting Closer	$\underset{x\to 0}{lim}\frac{\sin x}{x}=1$
2	Numerical Derivative	$f(x)=x^2$: $f^{\prime }(3)=6$
3	Second Derivative	$f(x)=x^3$: $f^{″}(2)=12$
4	Newton's Method	$\sqrt{2}\approx 1.414214$
5	Gradient Descent	minimum of $(x-3{)}^2$ at $x=3$
6	Riemann Sum	${\int }_0^2{x}^{2}dx\approx 2.6667$
7	Trapezoid Rule	${\int }_0^{\pi }\sin xdx=2$
8	Simpson's Rule	${\int }_0^1{e}^{x}dx\approx 1.718282$
9	Taylor Series	$e\approx 2.718282$
10	Euler's Method	$y(1)\approx 2.7169$ (exact: $e$)

1. Limits by Getting Closer

Limits by Getting Closer

Formula:

$$\underset{x\to 0}{lim}\frac{\sin x}{x}=1$$

Putting $x=0$ in directly divides by zero, so the code tries values closer and closer to 0 instead.

Where it's used: understanding limits, the idea behind derivatives and integrals.

LaTeX

$$
\lim_{x \to 0} \frac{\sin x}{x} = 1
$$

Python

import math

def f(x: float) -> float:
    return math.sin(x) / x

print(round(f(0.1), 6))    # 0.998334
print(round(f(0.01), 6))   # 0.999983
print(round(f(0.001), 6))  # 1.0

Rust

fn f(x: f64) -> f64 {
    x.sin() / x
}

fn main() {
    println!("{:.6}", f(0.1)); // 0.998334
    println!("{:.6}", f(0.01)); // 0.999983
    println!("{:.6}", f(0.001)); // 1.000000
}

2. Numerical Derivative

Numerical Derivative

Formula:

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

The second form, the central difference, is more accurate than stepping forward only. Here $f(x)=x^2$, so $f^{\prime }(3)=6$.

Where it's used: checking derivatives you worked out by hand, and gradient checking when debugging neural networks.

LaTeX

$$
f'(x) = \lim_{h \to 0} \frac{f(x + h) - f(x)}{h} \approx \frac{f(x + h) - f(x - h)}{2h}
$$

Python

def derivative(f, x: float, h: float = 1e-5) -> float:
    return (f(x + h) - f(x - h)) / (2 * h)

print(round(derivative(lambda x: x**2, 3), 4))  # 6.0

Rust

fn derivative(f: impl Fn(f64) -> f64, x: f64, h: f64) -> f64 {
    (f(x + h) - f(x - h)) / (2.0 * h)
}

fn main() {
    println!("{:.4}", derivative(|x| x * x, 3.0, 1e-5)); // 6.0000
}

3. Second Derivative

Second Derivative

Formula:

$$f^{″}(x)\approx \frac{f(x+h)-2f(x)+f(x-h)}{h^2}$$

Here $f(x)=x^3$, so $f^{″}(x)=6x$ and $f^{″}(2)=12$.

Where it's used: checking concavity, the second derivative test, and the Hessian in optimisation.

LaTeX

$$
f''(x) \approx \frac{f(x + h) - 2f(x) + f(x - h)}{h^2}
$$

Python

def second_derivative(f, x: float, h: float = 1e-4) -> float:
    return (f(x + h) - 2 * f(x) + f(x - h)) / h**2

print(round(second_derivative(lambda x: x**3, 2), 4))  # 12.0

Rust

fn second_derivative(f: impl Fn(f64) -> f64, x: f64, h: f64) -> f64 {
    (f(x + h) - 2.0 * f(x) + f(x - h)) / (h * h)
}

fn main() {
    println!("{:.4}", second_derivative(|x| x * x * x, 2.0, 1e-4)); // 12.0000
}

4. Newton's Method

Newton's Method

Formula:

$$x_{n+1}=x_n-\frac{f(x_n)}{f^{\prime }(x_n)}$$

Each step follows the tangent line down to where it crosses zero. Here $f(x)=x^2-2$, so the root is $\sqrt{2}$.

Where it's used: finding roots of equations, and how calculators work out square roots.

LaTeX

$$
x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}
$$

Python

def newton(f, df, x0: float, steps: int = 20) -> float:
    x = x0
    for _ in range(steps):
        x = x - f(x) / df(x)
    return x

root = newton(lambda x: x**2 - 2, lambda x: 2 * x, x0=1.0)
print(round(root, 6))  # 1.414214

Rust

fn newton(f: impl Fn(f64) -> f64, df: impl Fn(f64) -> f64, x0: f64, steps: usize) -> f64 {
    let mut x = x0;
    for _ in 0..steps {
        x -= f(x) / df(x);
    }
    x
}

fn main() {
    let root = newton(|x| x * x - 2.0, |x| 2.0 * x, 1.0, 20);
    println!("{:.6}", root); // 1.414214
}

5. Gradient Descent

Gradient Descent

Formula:

$$x:=x-\alpha f^{\prime }(x)f(x)=(x-3{)}^2$$

Each step moves downhill against the slope. $\alpha$ is the learning rate, and the minimum of $(x-3{)}^2$ is at $x=3$.

Where it's used: training machine learning models, which do the same thing with millions of parameters.

LaTeX

$$
x := x - \alpha \, f'(x) \qquad f(x) = (x - 3)^2
$$

Python

def gradient_descent(df, x0: float, alpha: float = 0.1, steps: int = 100) -> float:
    x = x0
    for _ in range(steps):
        x = x - alpha * df(x)
    return x

print(round(gradient_descent(lambda x: 2 * (x - 3), x0=0.0), 4))  # 3.0

Rust

fn gradient_descent(df: impl Fn(f64) -> f64, x0: f64, alpha: f64, steps: usize) -> f64 {
    let mut x = x0;
    for _ in 0..steps {
        x -= alpha * df(x);
    }
    x
}

fn main() {
    println!("{:.4}", gradient_descent(|x| 2.0 * (x - 3.0), 0.0, 0.1, 100)); // 3.0000
}

6. Riemann Sum

Riemann Sum

Formula:

$${\int }_a^{b}f(x)dx\approx \sum _{i=1}^{n}f(m_i)\mathrm{\Delta }x,\mathrm{\Delta }x=\frac{b-a}{n}$$

This version uses the midpoint $m_i$ of each rectangle. Here ${\int }_0^2{x}^{2}dx=\frac{8}{3}\approx 2.6667$.

Where it's used: understanding an integral as the area of many thin rectangles.

LaTeX

$$
\int_{a}^{b} f(x) \, dx \approx \sum_{i=1}^{n} f(m_i) \, \Delta x, \qquad \Delta x = \frac{b - a}{n}
$$

Python

def midpoint_sum(f, a: float, b: float, n: int = 1000) -> float:
    dx = (b - a) / n
    return sum(f(a + (i + 0.5) * dx) for i in range(n)) * dx

print(round(midpoint_sum(lambda x: x**2, 0, 2), 4))  # 2.6667

Rust

fn midpoint_sum(f: impl Fn(f64) -> f64, a: f64, b: f64, n: usize) -> f64 {
    let dx = (b - a) / n as f64;
    (0..n).map(|i| f(a + (i as f64 + 0.5) * dx)).sum::<f64>() * dx
}

fn main() {
    println!("{:.4}", midpoint_sum(|x| x * x, 0.0, 2.0, 1000)); // 2.6667
}

7. Trapezoid Rule

Trapezoid Rule

Formula:

$${\int }_a^{b}f(x)dx\approx \frac{\mathrm{\Delta }x}{2}[f(x_0)+2\sum _{i=1}^{n-1}f(x_i)+f(x_n)]$$

Trapezoids follow the curve more closely than rectangles. Here ${\int }_0^{\pi }\sin xdx=2$.

Where it's used: integrating data from measurements, such as the area under a ROC curve.

LaTeX

$$
\int_{a}^{b} f(x) \, dx \approx \frac{\Delta x}{2} \Big[ f(x_0) + 2 \sum_{i=1}^{n-1} f(x_i) + f(x_n) \Big]
$$

Python

import math

def trapezoid(f, a: float, b: float, n: int = 1000) -> float:
    dx = (b - a) / n
    inner = sum(f(a + i * dx) for i in range(1, n))
    return dx / 2 * (f(a) + 2 * inner + f(b))

print(round(trapezoid(math.sin, 0, math.pi), 4))  # 2.0

Rust

use std::f64::consts::PI;

fn trapezoid(f: impl Fn(f64) -> f64, a: f64, b: f64, n: usize) -> f64 {
    let dx = (b - a) / n as f64;
    let inner: f64 = (1..n).map(|i| f(a + i as f64 * dx)).sum();
    dx / 2.0 * (f(a) + 2.0 * inner + f(b))
}

fn main() {
    println!("{:.4}", trapezoid(|x| x.sin(), 0.0, PI, 1000)); // 2.0000
}

8. Simpson's Rule

Simpson's Rule

Formula:

$${\int }_a^{b}f(x)dx\approx \frac{\mathrm{\Delta }x}{3}[f(x_0)+4\sum _{i\text{ odd}}f(x_i)+2\sum _{i\text{ even}}f(x_i)+f(x_n)]$$

Simpson's rule fits curves instead of straight lines, so it is very accurate. $n$ must be even. Here ${\int }_0^1{e}^{x}dx=e-1\approx 1.718282$.

Where it's used: accurate numerical integration in science and engineering.

LaTeX

$$
\int_{a}^{b} f(x) \, dx \approx \frac{\Delta x}{3} \Big[ f(x_0) + 4 \sum_{i \text{ odd}} f(x_i) + 2 \sum_{i \text{ even}} f(x_i) + f(x_n) \Big]
$$

Python

import math

def simpson(f, a: float, b: float, n: int = 100) -> float:
    dx = (b - a) / n  # n must be even
    total = f(a) + f(b)
    for i in range(1, n):
        total += (4 if i % 2 == 1 else 2) * f(a + i * dx)
    return dx / 3 * total

print(round(simpson(math.exp, 0, 1), 6))  # 1.718282

Rust

fn simpson(f: impl Fn(f64) -> f64, a: f64, b: f64, n: usize) -> f64 {
    let dx = (b - a) / n as f64; // n must be even
    let mut total = f(a) + f(b);
    for i in 1..n {
        let weight = if i % 2 == 1 { 4.0 } else { 2.0 };
        total += weight * f(a + i as f64 * dx);
    }
    dx / 3.0 * total
}

fn main() {
    println!("{:.6}", simpson(|x| x.exp(), 0.0, 1.0, 100)); // 1.718282
}

9. Taylor Series

Taylor Series

Formula:

$$e^x=\sum _{n=0}^{\mathrm{\infty }}\frac{x^n}{n!}=1+x+\frac{x^2}{2!}+\frac{x^3}{3!}+\cdots$$

Each new term is the previous one times $\frac{x}{n+1}$, so the code never needs to calculate a factorial directly.

Where it's used: how computers calculate $e^x$, $\sin x$ and other functions.

LaTeX

$$
e^{x} = \sum_{n=0}^{\infty} \frac{x^{n}}{n!} = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \cdots
$$

Python

def exp_taylor(x: float, terms: int = 15) -> float:
    total, term = 0.0, 1.0
    for n in range(terms):
        total += term
        term *= x / (n + 1)
    return total

print(round(exp_taylor(1), 6))  # 2.718282

Rust

fn exp_taylor(x: f64, terms: usize) -> f64 {
    let (mut total, mut term) = (0.0, 1.0);
    for n in 0..terms {
        total += term;
        term *= x / (n as f64 + 1.0);
    }
    total
}

fn main() {
    println!("{:.6}", exp_taylor(1.0, 15)); // 2.718282
}

10. Euler's Method

Euler's Method

Formula:

$$y_{n+1}=y_n+hf(t_n,y_n)\frac{dy}{dt}=y,y(0)=1$$

Euler's method solves a differential equation one small step $h$ at a time. The exact answer here is $y(1)=e\approx 2.7183$, and a smaller $h$ gets closer.

Where it's used: simulating growth and decay, physics, and how neural ODEs work.

LaTeX

$$
y_{n+1} = y_n + h \, f(t_n, y_n) \qquad \frac{dy}{dt} = y, \; y(0) = 1
$$

Python

def euler(f, t0: float, y0: float, h: float, steps: int) -> float:
    t, y = t0, y0
    for _ in range(steps):
        y = y + h * f(t, y)
        t = t + h
    return y

print(round(euler(lambda t, y: y, 0, 1, 0.001, 1000), 4))  # 2.7169

Rust

fn euler(f: impl Fn(f64, f64) -> f64, t0: f64, y0: f64, h: f64, steps: usize) -> f64 {
    let (mut t, mut y) = (t0, y0);
    for _ in 0..steps {
        y += h * f(t, y);
        t += h;
    }
    y
}

fn main() {
    println!("{:.4}", euler(|_t, y| y, 0.0, 1.0, 0.001, 1000)); // 2.7169
}