Jäckel’s LBR Algorithm

• Jäckel’s LBR Algorithm is a high-precision and high-speed method to compute implied volatility using a re-parameterized Black formula.
• It applies region-dependent rational approximations for efficient initial guesses across four option moneyness regimes.
• Householder’s cubic refinement yields sub-microsecond timings and full machine precision across various GPU and CPU backends.

Jäckel’s "Let’s Be Rational" (LBR) algorithm is a high-precision, high-speed method for computing implied volatility (IV) in the context of European options pricing under the Black-76 and Black-Scholes(-Merton) models. The approach leverages a re-parameterization of the standard Black formula and applies region-adapted rational approximations as initial guesses, followed by cubic-order Householder refinement. The algorithm’s design targets element-wise, batched, and GPU-accelerated workflows, as implemented in fast-vollib’s open-source Python library, with available backends in NumPy/Numba, PyTorch, JAX, and CUDA-fused kernels (Saqur, 29 Apr 2026).

1. Mathematical Formulation and Re-parameterization

The LBR algorithm operates in the “forward” (Black-76) variable space, before translating results to Black-Scholes coordinates. For given spot price $S$, strike $K$, risk-free rate $r$, dividend yield $q$, time to expiry $t$, and undiscounted market call price $C_{\mathrm{mkt}}$, define the forward price $F = S\,e^{-qt}$ and discounted factor $D = e^{-rt}$. The Black-76 call price is

$$C_{\mathrm{B76}}(\sigma) = D\, [\, F\,\Phi(d_1) - K\,\Phi(d_2)\,]$$

where

$$d_{1,2} = \frac{\ln(F/K) \pm \tfrac{1}{2}\sigma^2 t}{\sigma\sqrt{t}}$$

The implied volatility $K$0 is uniquely determined by $K$1. Jäckel’s method re-parameterizes this root-finding problem in terms of normalized variables:

• $K$2,
• $K$3,
• $K$4,

with the transformed function:

$K$5

The solution $K$6 to $K$7 directly gives the implied volatility $K$8.

2. Region-dependent Rational Approximations

Jäckel partitions the $K$9 plane—encoding moneyness and normalized call price—into four regimes, assigning a specific rational function $r$0 to each for an initial guess $r$1:

Regime	$r$2 Definition	$r$3 Structure
1. Near-the-money (small $r$4)	$r$5	$r$6
2. Moderate wings	$r$7	$r$8
3. Deep out-of-the-money	$r$9	$q$0
4. Extreme wings / deep ITM	$q$1	$q$2

All coefficients are verbatim from Jäckel 2015, as implemented in the fast-vollib library (Saqur, 29 Apr 2026). The algorithm determines the regime via a sequence of inexpensive threshold tests in $q$3 as a function of $q$4.

3. Region Thresholds and Algorithmic Switches

The switch between rational approximation regimes proceeds by comparing $q$5 to regime thresholds $q$6, $q$7, and $q$8:

• If $q$9: regime 1,
• Else if $t$0: regime 2,
• Else if $t$1: regime 3,
• Else: regime 4.

These thresholds are inexpensive functions of $t$2, derived as approximate constant-$t$3 or constant-$t$4 curves and require only a few floating-point operations to evaluate.

4. Householder(3) Refinement

After computing the regime-appropriate $t$5, the algorithm applies two iterations of Householder’s third-order method:

1. At each step, evaluate $t$6, its first three derivatives $t$7 at the current $t$8.
2. Compute the residual $t$9 and update using

$C_{\mathrm{mkt}}$0

where $C_{\mathrm{mkt}}$1, $C_{\mathrm{mkt}}$2, $C_{\mathrm{mkt}}$3 with respect to $C_{\mathrm{mkt}}$4. Only two iterations are necessary to reach machine precision due to the accuracy of the initial guess.

5. Implementation Details and Backends

The fast-vollib library provides four source-identical backends for the LBR algorithm:

• NumPy + Numba: CPU batch processing ({\tt jackel_iv_black}).
• PyTorch (torch.compile): Tensors on CPU/GPU ({\tt jackel_iv_black_torch}).
• JAX (jax.jit): DeviceArray-accelerated routines ({\tt jackel_iv_black_jax}).
• Triton single-pass GPU kernel: All steps fused into a single kernel, keeping all intermediates in registers and eliminating Python-level loops or branching ({\tt jackel_iv_triton}).

Each backend implements all logic “element-wise,” enabling compiler-level vectorization or fusion, and a dispatch layer ({\tt fast_implied_volatility_black(backend=...)}) selects the variant dynamically (Saqur, 29 Apr 2026).

6. Performance and Accuracy

The LBR algorithm delivers sub-microsecond per-option timings and achieves double-precision (approximately $C_{\mathrm{mkt}}$5) accuracy uniformly across strikes and maturities. The regime-specific rational starting guess $C_{\mathrm{mkt}}$6 lands within a few units in the fourth decimal of the true solution across all regions. As a result, only two Householder(3) steps—each conferring local error $C_{\mathrm{mkt}}$7—are required. This achieves both ultrafast execution and full machine precision. In contrast, Newton or Halley solvers with less accurate initializations may drift in deep wings, requiring additional iterations or sacrificing digits of accuracy (Saqur, 29 Apr 2026).

7. Context and Applications

Jäckel’s LBR algorithm, as realized in fast-vollib’s jackel module, is intended as a drop-in, high-performance alternative to existing py_vollib and py_vollib_vectorized packages. The implementation is compatible with European option pricing under Black-76, Black-Scholes, and Black-Scholes-Merton models, with full batched and GPU-accelerated support. This positions the LBR method as an optimal choice for research and production settings demanding both speed and accuracy in large-scale IV computations for option chains (Saqur, 29 Apr 2026).