optPricing 2.5.0__tar.gz → 2.6.0__tar.gz

{optpricing-2.5.0 → optpricing-2.6.0}/CHANGELOG.md

@@ -6,6 +6,28 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+### Performance
+
+- Monte Carlo engine rebuilt: the numba kernels draw their own random numbers from per-chunk
+  `numpy.random.Generator`s (spawned from one seed, fixed chunk size) and run concurrently on a thread pool
+  (`n_jobs`, `chunk_size` options; `OPTPRICING_MC_THREADS`). Results depend only on the seed and chunk size,
+  common-random-number Greeks are preserved, and jump sizes now come from the seeded stream. 100k-path
+  BSM 27.7 → 3.4 ms, Heston (Euler) 88.7 → 7.5 ms on 10 cores.
+- Heston/Bates Monte Carlo defaults to Andersen's Quadratic-Exponential variance scheme with martingale
+  correction (`variance_scheme="qe"`; `"euler"` keeps full truncation). 20 QE steps are more accurate than
+  252 Euler steps; on long-dated, high vol-of-vol parameters Euler was off by several price units.
+- Closed forms use `scipy.special.ndtr` (BSM price 28 → 2 µs); the Merton series is vectorised with log-space
+  Poisson weights (2.7 ms → 14 µs, no overflow past 170 terms).
+- `IntegrationTechnique` evaluates the Gil–Pelaez integrals on a cached composite Gauss–Legendre rule
+  (`method="gauss"`, 0.69 → 0.07 ms; `method="quad"` keeps the adaptive rule); the calibration chain pricer
+  uses the same rule (400 options 19.5 → 1.7 ms). `FFTTechnique` interpolates cubically and defaults to
+  `eta=0.125` (ATM error 5e-4 → 1e-6 at the same cost).
+- Longstaff–Schwartz: parallel power-sum regression on moneyness, time-major path matrices
+  (20k paths 32 → 13 ms); Crank–Nicolson PDE marches in numba with the two constant matrices factorised once
+  (200×200 grid 2.3 → 0.3 ms).
+- Kernel signatures changed: SDE kernels take `(gen, n_paths, n_steps, antithetic, ...)`, path kernels return
+  `(n_steps + 1, n_paths)` arrays, and `longstaff_schwartz_pricer` takes `n_threads`.
+
 ### Changed
 
 - Python 3.10 support dropped (end of life); supported versions are 3.11–3.14, with 3.15 tested as experimental.

{optpricing-2.5.0/src/optpricing.egg-info → optpricing-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optpricing
-Version: 2.5.0
+Version: 2.6.0
 Summary: A financial options pricing and analysis library.
 Author: Diljit Singh
 License-Expression: MIT

{optpricing-2.5.0 → optpricing-2.6.0}/benchmarks/run_benchmarks.py

@@ -83,6 +83,22 @@ def _lsmc_bsm_20k() -> float:
     return amc.price(PUT, STOCK, BSM, RATE).price
 
 
+def _heston_chain_400() -> float:
+    import pandas as pd
+
+    from optpricing.calibration.vectorized_pricer import price_options_vectorized
+
+    chain = pd.DataFrame(
+        [
+            {"strike": k, "maturity": t, "optionType": typ}
+            for t in (0.1, 0.25, 0.5, 1.0, 2.0)
+            for k in np.linspace(60, 150, 40)
+            for typ in ("call", "put")
+        ]
+    )
+    return float(price_options_vectorized(chain, STOCK, HESTON, RATE, v0=0.04).sum())
+
+
 CASES: dict[str, tuple[Callable[[], float], str]] = {
     "bsm_closed_form_x1000": (_bsm_closed_form, "1000 closed-form BSM prices"),
     "heston_fft": (_heston_fft, "Carr-Madan FFT, N=4096"),
@@ -91,6 +107,10 @@ CASES: dict[str, tuple[Callable[[], float], str]] = {
     "mc_bsm_100k": (_mc_bsm_100k, "100k paths x 100 steps, antithetic"),
     "mc_heston_100k": (_mc_heston_100k, "100k paths x 100 steps, antithetic"),
     "lsmc_bsm_20k": (_lsmc_bsm_20k, "Longstaff-Schwartz, 20k paths x 50 steps"),
+    "heston_chain_400": (
+        _heston_chain_400,
+        "vectorised chain pricer, 400 options x 5 maturities",
+    ),
 }
 
 

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/calibration/vectorized_bsm_iv.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import numpy as np
 import pandas as pd
-from scipy.stats import norm
+from scipy.special import ndtr
 
 from optpricing.atoms import Rate, Stock
 
@@ -78,13 +78,14 @@ class BSMIVSolver:
                 sqrt_T = np.sqrt(T)
                 d1 = (np.log(S / K) + (r - q + 0.5 * iv**2) * T) / (iv * sqrt_T)
                 d2 = d1 - iv * sqrt_T
-                vega = S * np.exp(-q * T) * sqrt_T * norm.pdf(d1)
-                call_prices = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(
-                    -r * T
-                ) * norm.cdf(d2)
-                put_prices = K * np.exp(-r * T) * norm.cdf(-d2) - S * np.exp(
-                    -q * T
-                ) * norm.cdf(-d1)
+                pdf_d1 = np.exp(-0.5 * d1 * d1) / np.sqrt(2.0 * np.pi)
+                vega = S * np.exp(-q * T) * sqrt_T * pdf_d1
+                call_prices = S * np.exp(-q * T) * ndtr(d1) - K * np.exp(-r * T) * ndtr(
+                    d2
+                )
+                put_prices = K * np.exp(-r * T) * ndtr(-d2) - S * np.exp(-q * T) * ndtr(
+                    -d1
+                )
             model_prices = np.where(is_call, call_prices, put_prices)
             error = model_prices - target_prices
             if np.all(np.abs(error) < self.tolerance):

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/calibration/vectorized_pricer.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
-from scipy import integrate
+
+from optpricing.techniques.integration import IntegrationTechnique
 
 if TYPE_CHECKING:
     import pandas as pd
@@ -64,15 +65,12 @@ def price_options_vectorized(
         phi = model.cf(t=T, spot=S, r=r, q=q, **kwargs)
         lnK = np.log(K)
 
-        def _integrand_p2(u: float) -> np.ndarray:
-            return (np.exp(-1j * u * lnK) * phi(u)).imag / u
-
-        def _integrand_p1(u: float) -> np.ndarray:
-            return (np.exp(-1j * u * lnK) * phi(u - 1j)).imag / u
-
-        # Vectorised quad once per maturity
-        p2, _ = integrate.quad_vec(_integrand_p2, 1e-15, upper_bound)
-        p1, _ = integrate.quad_vec(_integrand_p1, 1e-15, upper_bound)
+        # Composite Gauss-Legendre (same rule as IntegrationTechnique): one CF
+        # evaluation per maturity, integrands as a (strikes x nodes) matrix.
+        u, w = IntegrationTechnique.gauss_nodes(upper_bound, 24)
+        twist = np.exp(-1j * np.outer(lnK, u)) / u  # (n_strikes, n_nodes)
+        p2 = (twist * phi(u)).imag @ w
+        p1 = (twist * phi(u - 1j)).imag @ w
 
         denom = np.real(phi(-1j))
         denom = 1.0 if abs(denom) < 1e-12 else denom

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/models/bsm.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable
 
 import numpy as np
-from scipy.stats import norm
+from scipy.special import ndtr
 
 from optpricing.models.base import CF, BaseModel, ParamValidator, PDECoeffs
 
@@ -11,6 +11,13 @@ __doc__ = """
 Defines the Black-Scholes-Merton (BSM) model for pricing European options.
 """
 
+_INV_SQRT_2PI = 0.3989422804014327
+
+
+def _npdf(x):
+    """Standard normal density (scalar or array), without scipy.stats overhead."""
+    return _INV_SQRT_2PI * np.exp(-0.5 * x * x)
+
 
 class BSMModel(BaseModel):
     """
@@ -104,9 +111,9 @@ class BSMModel(BaseModel):
         df_rate = np.exp(-r * t)
 
         if call:
-            price = spot * df_div * norm.cdf(d1) - strike * df_rate * norm.cdf(d2)
+            price = spot * df_div * ndtr(d1) - strike * df_rate * ndtr(d2)
         else:
-            price = strike * df_rate * norm.cdf(-d2) - spot * df_div * norm.cdf(-d1)
+            price = strike * df_rate * ndtr(-d2) - spot * df_div * ndtr(-d1)
         return price
 
     def delta_analytic(
@@ -125,7 +132,7 @@ class BSMModel(BaseModel):
             sigma * np.sqrt(t)
         )
         df_div = np.exp(-q * t)
-        return df_div * norm.cdf(d1) if call else -df_div * norm.cdf(-d1)
+        return df_div * ndtr(d1) if call else -df_div * ndtr(-d1)
 
     def gamma_analytic(
         self,
@@ -141,7 +148,7 @@ class BSMModel(BaseModel):
         sqrt_t = np.sqrt(t)
         d1 = (np.log(spot / strike) + (r - q + 0.5 * sigma**2) * t) / (sigma * sqrt_t)
         df_div = np.exp(-q * t)
-        return df_div * norm.pdf(d1) / (spot * sigma * sqrt_t)
+        return df_div * _npdf(d1) / (spot * sigma * sqrt_t)
 
     def vega_analytic(
         self,
@@ -156,7 +163,7 @@ class BSMModel(BaseModel):
         sigma = self.params["sigma"]
         sqrt_t = np.sqrt(t)
         d1 = (np.log(spot / strike) + (r - q + 0.5 * sigma**2) * t) / (sigma * sqrt_t)
-        return spot * np.exp(-q * t) * norm.pdf(d1) * sqrt_t
+        return spot * np.exp(-q * t) * _npdf(d1) * sqrt_t
 
     def theta_analytic(
         self,
@@ -173,13 +180,13 @@ class BSMModel(BaseModel):
         sqrt_t = np.sqrt(t)
         d1 = (np.log(spot / strike) + (r - q + 0.5 * sigma**2) * t) / (sigma * sqrt_t)
         d2 = d1 - sigma * sqrt_t
-        term1 = -spot * np.exp(-q * t) * norm.pdf(d1) * sigma / (2 * sqrt_t)
+        term1 = -spot * np.exp(-q * t) * _npdf(d1) * sigma / (2 * sqrt_t)
         if call:
-            term2 = q * spot * np.exp(-q * t) * norm.cdf(d1)
-            term3 = -r * strike * np.exp(-r * t) * norm.cdf(d2)
+            term2 = q * spot * np.exp(-q * t) * ndtr(d1)
+            term3 = -r * strike * np.exp(-r * t) * ndtr(d2)
         else:
-            term2 = -q * spot * np.exp(-q * t) * norm.cdf(-d1)
-            term3 = r * strike * np.exp(-r * t) * norm.cdf(-d2)
+            term2 = -q * spot * np.exp(-q * t) * ndtr(-d1)
+            term3 = r * strike * np.exp(-r * t) * ndtr(-d2)
         return term1 + term2 + term3
 
     def rho_analytic(
@@ -197,7 +204,7 @@ class BSMModel(BaseModel):
         sqrt_t = np.sqrt(t)
         d2 = (np.log(spot / strike) + (r - q - 0.5 * sigma**2) * t) / (sigma * sqrt_t)
         df_rate = np.exp(-r * t)
-        return strike * t * df_rate * (norm.cdf(d2) if call else -norm.cdf(-d2))
+        return strike * t * df_rate * (ndtr(d2) if call else -ndtr(-d2))
 
     def _cf_impl(
         self,

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/models/merton_jump.py

@@ -4,7 +4,7 @@ import math
 from typing import Any
 
 import numpy as np
-from scipy.special import factorial
+from scipy.special import gammaln, ndtr
 
 from optpricing.models.base import CF, BaseModel, ParamValidator
 from optpricing.models.bsm import BSMModel
@@ -127,27 +127,39 @@ class MertonJumpModel(BaseModel):
         lambda_prime = lambda_ * (1 + k)
         y_mul = lambda_prime * t
 
-        interval = np.arange(max_sum_terms)
-        weights = np.exp(-y_mul) * (y_mul**interval) / factorial(interval)
-
-        r_n = r - lambda_ * k + (interval * (mu_j + 0.5 * sigma_j**2)) / t
-        sigma_n_sq = self.params["sigma"] ** 2 + (interval * sigma_j**2) / t
-        sigma_n = np.sqrt(np.maximum(sigma_n_sq, 1e-12))
-
-        total_price = 0.0
-        for i in range(max_sum_terms):
-            # Terminate sum early if weights become negligible
-            if weights[i] < 1e-12 and i > lambda_prime * t:
-                break
-
-            temp_bsm_solver = self.bsm_solver.with_params(sigma=sigma_n[i])
-
-            price_term = temp_bsm_solver.price_closed_form(
-                spot=spot, strike=strike, r=r_n[i], q=q, t=t, call=call
-            )
-            total_price += weights[i] * price_term
+        n = np.arange(max_sum_terms)
+        # Poisson weights via logs (factorial overflows past n ~ 170).
+        log_weights = (
+            -y_mul + n * np.log(y_mul) - gammaln(n + 1.0) if y_mul > 0 else None
+        )
+        if log_weights is None:
+            weights = np.zeros(max_sum_terms)
+            weights[0] = 1.0
+        else:
+            weights = np.exp(log_weights)
+        # Truncate once the tail weight is negligible (past the mode).
+        keep = (weights >= 1e-12) | (n <= y_mul)
+        n_terms = int(np.max(np.nonzero(keep)[0])) + 1
+        n, weights = n[:n_terms], weights[:n_terms]
+
+        r_n = r - lambda_ * k + (n * (mu_j + 0.5 * sigma_j**2)) / t
+        sigma_n = np.sqrt(
+            np.maximum(self.params["sigma"] ** 2 + n * sigma_j**2 / t, 1e-12)
+        )
 
-        return total_price
+        # Vectorised Black-Scholes-Merton over the series terms.
+        sqrt_t = math.sqrt(t)
+        d1 = (math.log(spot / strike) + (r_n - q + 0.5 * sigma_n**2) * t) / (
+            sigma_n * sqrt_t
+        )
+        d2 = d1 - sigma_n * sqrt_t
+        df_div = math.exp(-q * t)
+        df_rate = np.exp(-r_n * t)
+        if call:
+            prices = spot * df_div * ndtr(d1) - strike * df_rate * ndtr(d2)
+        else:
+            prices = strike * df_rate * ndtr(-d2) - spot * df_div * ndtr(-d1)
+        return float(np.dot(weights, prices))
 
     def _cf_impl(
         self,

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/models/sabr.py

@@ -5,7 +5,7 @@ import warnings
 from typing import Any
 
 import numpy as np
-from scipy.stats import norm
+from scipy.special import ndtr
 
 from optpricing.models.base import BaseModel, ParamValidator
 
@@ -274,8 +274,8 @@ class SABRModel(BaseModel):
         d2 = d1 - sigma * sqrt_t
         discount = math.exp(-r * t)
         if call:
-            return discount * (f_s * norm.cdf(d1) - k_s * norm.cdf(d2))
-        return discount * (k_s * norm.cdf(-d2) - f_s * norm.cdf(-d1))
+            return discount * (f_s * ndtr(d1) - k_s * ndtr(d2))
+        return discount * (k_s * ndtr(-d2) - f_s * ndtr(-d1))
 
     #  Abstract Method Implementations
     def _sde_impl(self, **kwargs: Any) -> Any:

{optpricing-2.5.0 → optpricing-2.6.0}/src/optpricing/techniques/american_monte_carlo.py

@@ -4,17 +4,25 @@ import math
 from collections.abc import Callable
 from typing import Any
 
+import numba
 import numpy as np
 
 from optpricing.atoms import Option, OptionType, Rate, Stock
 from optpricing.models import BaseModel, SABRJumpModel, SABRModel
 from optpricing.techniques.base import BaseTechnique, GreekMixin, IVMixin, PricingResult
+from optpricing.techniques.base.random_utils import (
+    DEFAULT_CHUNK_SIZE,
+    plan_chunks,
+    run_chunks,
+)
 
 from .kernels.american_mc_kernels import longstaff_schwartz_pricer
 from .kernels.path_kernels import (
     bates_path_kernel,
+    bates_qe_path_kernel,
     bsm_path_kernel,
     heston_path_kernel,
+    heston_qe_path_kernel,
     kou_path_kernel,
     merton_path_kernel,
     sabr_jump_path_kernel,
@@ -40,7 +48,23 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
         antithetic: bool = True,
         seed: int | None = None,
         lsm_degree: int = 2,
+        n_jobs: int | None = None,
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        variance_scheme: str = "qe",
     ):
+        """
+        Parameters
+        ----------
+        n_paths, n_steps, antithetic, seed, variance_scheme
+            As for `MonteCarloTechnique`.
+        lsm_degree : int, optional
+            Polynomial degree of the Longstaff-Schwartz regression, by default 2.
+        n_jobs : int | None, optional
+            Maximum number of threads simulating path chunks concurrently;
+            results do not depend on it.
+        chunk_size : int, optional
+            Paths per chunk and random stream, by default 8192.
+        """
         if antithetic and n_paths % 2 != 0:
             n_paths += 1
         self.n_paths = n_paths
@@ -48,6 +72,11 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
         self.antithetic = antithetic
         self.rng = np.random.default_rng(seed)
         self.lsm_degree = lsm_degree
+        self.n_jobs = n_jobs
+        self.chunk_size = int(chunk_size)
+        if variance_scheme not in ("qe", "euler"):
+            raise ValueError("variance_scheme must be 'qe' or 'euler'.")
+        self.variance_scheme = variance_scheme
 
     def price(
         self,
@@ -69,6 +98,7 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
             r=rate.get_rate(option.maturity),
             is_call=(option.option_type is OptionType.CALL),
             degree=self.lsm_degree,
+            n_threads=numba.get_num_threads(),
         )
         return PricingResult(price=price_val)
 
@@ -87,10 +117,10 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
         if isinstance(model, SABRModel | SABRJumpModel):
             kernel_params.update(
                 {
+                    "v0": kwargs.get("v0", p["alpha"]),
                     "nu": p["nu"],
                     "beta": p["beta"],
                     "rho": p["rho"],
-                    "v0": kwargs.get("v0", p["alpha"]),
                 }
             )
             if model.has_jumps:
@@ -102,29 +132,37 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
         if model.has_variance_process and model.has_jumps:
             kernel_params.update(
                 {
+                    "v0": kwargs.get("v0", p.get("v0")),
                     "kappa": p["kappa"],
                     "theta": p["theta"],
                     "rho": p["rho"],
                     "vol_of_vol": p["vol_of_vol"],
-                    "v0": kwargs.get("v0", p.get("v0")),
+                    "lambda_": p["lambda"],
+                    "mu_j": p["mu_j"],
+                    "sigma_j": p["sigma_j"],
                 }
             )
-            kernel_params.update(
-                {"lambda_": p["lambda"], "mu_j": p["mu_j"], "sigma_j": p["sigma_j"]}
-            )
-            return bates_path_kernel, kernel_params
-        elif model.has_variance_process:
+            return (
+                bates_qe_path_kernel
+                if self.variance_scheme == "qe"
+                else bates_path_kernel
+            ), kernel_params
+        if model.has_variance_process:
             kernel_params.update(
                 {
+                    "v0": kwargs.get("v0", p.get("v0")),
                     "kappa": p["kappa"],
                     "theta": p["theta"],
                     "rho": p["rho"],
                     "vol_of_vol": p["vol_of_vol"],
-                    "v0": kwargs.get("v0", p.get("v0")),
                 }
             )
-            return heston_path_kernel, kernel_params
-        elif model.name == "Kou Double-Exponential Jump":
+            return (
+                heston_qe_path_kernel
+                if self.variance_scheme == "qe"
+                else heston_path_kernel
+            ), kernel_params
+        if model.name == "Kou Double-Exponential Jump":
             kernel_params.update(
                 {
                     "sigma": p["sigma"],
@@ -135,7 +173,7 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
                 }
             )
             return kou_path_kernel, kernel_params
-        elif model.has_jumps:
+        if model.has_jumps:
             kernel_params.update(
                 {
                     "sigma": p["sigma"],
@@ -145,9 +183,8 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
                 }
             )
             return merton_path_kernel, kernel_params
-        else:
-            kernel_params["sigma"] = p.get("sigma")
-            return bsm_path_kernel, kernel_params
+        kernel_params["sigma"] = p["sigma"]
+        return bsm_path_kernel, kernel_params
 
     def _simulate_full_sde_paths(
         self,
@@ -157,61 +194,46 @@ class AmericanMonteCarloTechnique(BaseTechnique, GreekMixin, IVMixin):
         rate: Rate,
         **kwargs: Any,
     ) -> np.ndarray:
-        """Simulates and returns the full matrix of stock price paths."""
+        """Simulates the spot paths, time-major ``(n_steps + 1, n_paths)``."""
         S0, T = stock.spot, option.maturity
         r, q = rate.get_rate(T), stock.dividend
         dt = T / self.n_steps
-        num_draws = self.n_paths // 2 if self.antithetic else self.n_paths
 
         kernel, kernel_params = self._get_path_kernel_and_params(
             model, r, q, dt, **kwargs
         )
-
-        sim_params = {
-            "n_paths": num_draws,
-            "n_steps": self.n_steps,
-            **kernel_params,
-        }
         is_sabr = isinstance(model, SABRModel | SABRJumpModel)
         if is_sabr:
             # SABR evolves the (shifted) forward; the path kernels convert the
             # forward paths back to spot paths for the exercise decision.
-            sim_params["s0"] = S0 * math.exp((r - q) * T) + model.shift
+            kernel_params["f0"] = S0 * math.exp((r - q) * T) + model.shift
         else:
-            sim_params["log_s0"] = math.log(S0)
-
-        # Generate standard normal draws (z) first, then scale by sqrt(dt)
-        if model.has_variance_process:
-            z1 = self.rng.standard_normal(size=(num_draws, self.n_steps))
-            z2 = self.rng.standard_normal(size=(num_draws, self.n_steps))
-            sim_params["dw1"] = z1 * math.sqrt(dt)
-            sim_params["dw2"] = z2 * math.sqrt(dt)
-        else:
-            z = self.rng.standard_normal(size=(num_draws, self.n_steps))
-            sim_params["dw"] = z * math.sqrt(dt)
-
-        if model.has_jumps:
-            sim_params["jump_counts"] = self.rng.poisson(
-                lam=model.params["lambda"] * dt, size=(num_draws, self.n_steps)
-            )
-
-        paths = kernel(**sim_params)
+            kernel_params["log_s0"] = math.log(S0)
 
-        if self.antithetic:
-            if "dw" in sim_params:
-                sim_params["dw"] *= -1
-            if "dw1" in sim_params:
-                sim_params["dw1"] *= -1
-                sim_params["dw2"] *= -1
-
-            paths_anti = kernel(**sim_params)
-            paths = np.concatenate([paths, paths_anti])
+        generators, sizes = plan_chunks(
+            self.rng,
+            self.n_paths,
+            chunk_size=self.chunk_size,
+            antithetic=self.antithetic,
+        )
+        paths = run_chunks(
+            kernel,
+            generators,
+            sizes,
+            n_jobs=self.n_jobs,
+            axis=1,
+            n_steps=self.n_steps,
+            antithetic=self.antithetic,
+            **kernel_params,
+        )
 
         if is_sabr and model.shift:
             # The kernels discount the shifted forward; remove the shift so the
             # exercise decision sees spot prices.
             horizon = self.n_steps * dt
             times = np.arange(self.n_steps + 1) * dt
-            paths = paths - model.shift * np.exp(-(r - q) * (horizon - times))
+            paths = (
+                paths - (model.shift * np.exp(-(r - q) * (horizon - times)))[:, None]
+            )
 
         return paths