stochvolmodels 1.1.6__tar.gz → 1.1.7__tar.gz

{stochvolmodels-1.1.6/stochvolmodels.egg-info → stochvolmodels-1.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.6
+Version: 1.1.7
 Summary: Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models including log-normal SV model, Heston
 Author-email: Artur Sepp <artursepp@gmail.com>
 Maintainer-email: Artur Sepp <artursepp@gmail.com>, Parviz Rakhmonov <ParvizRZ@gmail.com>
@@ -727,9 +727,10 @@ Requires-Dist: jupyterlab>=3.0.0; extra == "jupyter"
 Requires-Dist: ipykernel>=6.0.0; extra == "jupyter"
 Requires-Dist: ipywidgets>=8.0.0; extra == "jupyter"
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest>=8.4.2; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: pytest-regressions>=2.8.3; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: flake8>=5.0.0; extra == "dev"

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stochvolmodels"
-version = "1.1.6"
+version = "1.1.7"
 description = "Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models including log-normal SV model, Heston"
 readme = "README.md"
 license = {file = "LICENSE.txt"}
@@ -95,9 +95,10 @@ jupyter = [
 
 # Development tools and testing
 dev = [
-    "pytest>=7.0.0",
+    "pytest>=8.4.2",
     "pytest-cov>=4.0.0",
     "pytest-mock>=3.10.0",
+    "pytest-regressions>=2.8.3",
     "pytest-xdist>=3.0.0",
     "black>=22.0.0",
     "flake8>=5.0.0",
@@ -276,4 +277,4 @@ exclude = [
     "venv",
     ".eggs",
     "*.egg",
-]
+]

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7}/stochvolmodels/pricers/logsv_pricer.py

@@ -875,12 +875,14 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
                                               weights: np.ndarray,
                                               nodes: np.ndarray,
                                               timegrids: List[np.ndarray],
-                                              variable_type: VariableType = VariableType.LOG_RETURN
+                                              variable_type: VariableType = VariableType.LOG_RETURN,
+                                              debug: bool = True
                                               ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
     assert weights.shape == nodes.shape and weights.ndim == 1
     # assert kappa2 == 0.0
     N = nodes.size
-    v0 = sigma0 / np.sum(weights) * np.ones((N,))
+    dtype = weights.dtype
+    v0 = np.full((N,), sigma0 / np.sum(weights), dtype=dtype)
 
     # need to redenote coefficients
     volvol = np.sqrt(beta ** 2 + orthog_vol ** 2)
@@ -889,7 +891,9 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
     nb_path = Z0.shape[1]
     v0_vec = np.repeat(v0[:, None], nb_path, axis=1)
     v_init = v0_vec.copy()
-    log_s0 = 0.0
+    log_s0 = dtype.type(0.0)
+    weight_vec = np.repeat(weights[:, None], nb_path, axis=1)
+    nodes_vec = np.repeat(nodes[:, None], nb_path, axis=1)
 
     # outputs as numpy lists
     option_prices_ttm = List()
@@ -902,12 +906,11 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
         nb_steps = timegrid.size - 1
         Z0_ = Z0[:nb_steps]
         Z1_ = Z1[:nb_steps]
-        weight_vec = np.repeat(weights[:, None], nb_path,axis=1)
-        nodes_vec = np.repeat(nodes[:, None], nb_path,axis=1)
         log_spot_str, vol_str, qv_str = log_spot_full_combined(nodes_vec, weight_vec, v0_vec, theta, kappa1, kappa2, log_s0,
                                                                v_init, rho, volvol, timegrid, nb_path, Z0_, Z1_)
-        print(f"Number of paths with negative vol: {np.sum(weights @ vol_str < 0.0)}, nan vol: {np.count_nonzero(np.isnan(weights @ vol_str))}")
-        print(f"Mean spot Strand: {np.mean(np.exp(log_spot_str))}, nan spots: {np.count_nonzero(np.isnan(log_spot_str))}")
+        if debug:
+            print(f"Number of paths with negative vol: {np.sum(weights @ vol_str < 0.0)}, nan vol: {np.count_nonzero(np.isnan(weights @ vol_str))}")
+            print(f"Mean spot Strand: {np.mean(np.exp(log_spot_str))}, nan spots: {np.count_nonzero(np.isnan(log_spot_str))}")
 
         option_prices, option_std = compute_mc_vars_payoff(x0=log_spot_str, sigma0=vol_str, qvar0=qv_str,
                                                            ttm=ttm,
@@ -921,7 +924,6 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
 
     return option_prices_ttm, option_std_ttm
 
-
 class LocalTests(Enum):
     CHAIN_PRICER = 1
     SLICE_PRICER = 2

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7}/stochvolmodels/pricers/rough_logsv/split_simulation.py

@@ -126,6 +126,43 @@ def drift_ode_solve2(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: fl
     return zh
 
 
+@njit(cache=False, fastmath=True)
+def drift_ode_solve2_f32(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
+                         z0: np.ndarray, weight: np.ndarray, h: float):
+    """
+    Float32-friendly variant of drift_ode_solve2 (avoids float64 literals promoting intermediates).
+    """
+    assert nodes.shape == v0.shape == z0.shape == weight.shape
+    n, nb_path = weight.shape
+
+    half = np.float32(0.5)
+    two = np.float32(2.0)
+    six = np.float32(6.0)
+
+    z0w = np.sum(weight * z0, axis=0)
+    c1 = (kappa1 + kappa2 * z0w) * (theta - z0w)
+    s1 = -nodes * (z0 - v0) + c1
+
+    z_tmp = z0 + (half * h) * s1
+    z1w = np.sum(weight * z_tmp, axis=0)
+    c2 = (kappa1 + kappa2 * z1w) * (theta - z1w)
+    s2 = -nodes * (z_tmp - v0) + c2
+
+    z_tmp = z0 + (half * h) * s2
+    z2w = np.sum(weight * z_tmp, axis=0)
+    c3 = (kappa1 + kappa2 * z2w) * (theta - z2w)
+    s3 = -nodes * (z_tmp - v0) + c3
+
+    z_tmp = z0 + h * s3
+    z3w = np.sum(weight * z_tmp, axis=0)
+    c4 = (kappa1 + kappa2 * z3w) * (theta - z3w)
+    s4 = -nodes * (z_tmp - v0) + c4
+
+    zh = z0 + (h / six) * (s1 + two * s2 + two * s3 + s4)
+
+    return zh
+
+
 @njit(cache=False, fastmath=True)
 def drift_ode_solve3(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
                     z0: np.ndarray, weight: np.ndarray, h: float):
@@ -193,9 +230,9 @@ def drift_ode_solve3(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: fl
 
 
 @njit(cache=False, fastmath=True)
-def diffus_sde_solve(y0: np.ndarray, weight: np.ndarray, volvol: float, h: float, nb_path: int,
-                     z_rand: np.ndarray):
-    assert y0.shape == weight.shape  and y0.shape[-1] == nb_path
+def diffus_sde_solve_f64(y0: np.ndarray, weight: np.ndarray, volvol: float, h: float, nb_path: int,
+                         z_rand: np.ndarray):
+    assert y0.shape == weight.shape and y0.shape[-1] == nb_path
     assert z_rand.shape == (nb_path,)
     weight_sum = np.sum(weight, axis=0)
     volvol_ = volvol * weight_sum
@@ -212,10 +249,11 @@ def diffus_sde_solve(y0: np.ndarray, weight: np.ndarray, volvol: float, h: float
 
     return Yh_vec
 
+
 @njit(cache=False, fastmath=True)
-def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
-                        volvol: float, v_init: np.ndarray, weight: np.ndarray, h: float,
-                        nb_path: int, z_rand: np.ndarray):
+def drift_diffus_strand_f64(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
+                            volvol: float, v_init: np.ndarray, weight: np.ndarray, h: float,
+                            nb_path: int, z_rand: np.ndarray):
     """
 
     Parameters
@@ -237,18 +275,18 @@ def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1:
 
     """
     D_inn = drift_ode_solve2(nodes, v0, theta, kappa1, kappa2, v_init, weight, 0.5 * h)
-    S_inn = diffus_sde_solve(D_inn, weight, volvol, h, nb_path, z_rand)
+    S_inn = diffus_sde_solve_f64(D_inn, weight, volvol, h, nb_path, z_rand)
     sol = drift_ode_solve2(nodes, v0, theta, kappa1, kappa2, S_inn, weight, 0.5 * h)
 
     return sol
 
 
 @njit(cache=False, fastmath=True)
-def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
-                         v0: np.ndarray, y0: np.ndarray,
-                         theta: float, kappa1: float, kappa2: float, log_s: np.ndarray, v: np.ndarray, y: np.ndarray,
-                         rho: float, volvol: float, h: float, nb_path: int,
-                         z0: np.ndarray, z1: np.ndarray):
+def log_spot_full_solve2_f64(nodes: np.ndarray, weight: np.ndarray,
+                             v0: np.ndarray, y0: np.ndarray,
+                             theta: float, kappa1: float, kappa2: float, log_s: np.ndarray, v: np.ndarray, y: np.ndarray,
+                             rho: float, volvol: float, h: float, nb_path: int,
+                             z0: np.ndarray, z1: np.ndarray):
     # raise ValueError
     assert nodes.shape == weight.shape and weight.ndim == 2
     assert v.shape == weight.shape and v.shape[-1] == nb_path
@@ -258,7 +296,7 @@ def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
     assert y0.shape == (1, nb_path)
     assert z0.shape == (nb_path,) and z1.shape == (nb_path,)
 
-    vol_h = drift_diffus_strand(nodes, v0, theta, kappa1, kappa2, volvol, v, weight, h, nb_path, z0)
+    vol_h = drift_diffus_strand_f64(nodes, v0, theta, kappa1, kappa2, volvol, v, weight, h, nb_path, z0)
     w_vol_h = np.sum(weight * vol_h, axis=0)
     idx_bad = np.nonzero(np.logical_or(np.isnan(w_vol_h), w_vol_h <= 0.0))[0]
     vol_h[:, idx_bad] = 1e-6
@@ -290,12 +328,13 @@ def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
 
     return vol_h, y_h, log_spot_h
 
+
 @njit(cache=False, fastmath=True)
-def log_spot_full_combined(nodes: np.ndarray, weight: np.ndarray,
-                           v0: np.ndarray,
-                           theta: float, kappa1: float, kappa2: float, log_s0: float, v_init: np.ndarray,
-                           rho: float, volvol: float, timegrid: np.ndarray, nb_path: int,
-                           Z0: np.ndarray, Z1: np.ndarray):
+def log_spot_full_combined_f64(nodes: np.ndarray, weight: np.ndarray,
+                               v0: np.ndarray,
+                               theta: float, kappa1: float, kappa2: float, log_s0: float, v_init: np.ndarray,
+                               rho: float, volvol: float, timegrid: np.ndarray, nb_path: int,
+                               Z0: np.ndarray, Z1: np.ndarray):
     h = timegrid[1] - timegrid[0]
     # assert np.all(np.isclose(np.diff(timegrid)[1:], h)) and timegrid[0] == 0.0
     # assert Z0.shape == (timegrid.size - 1, nb_path) and Z1.shape == (timegrid.size - 1, nb_path)
@@ -306,11 +345,138 @@ def log_spot_full_combined(nodes: np.ndarray, weight: np.ndarray,
     y_h = np.zeros((1, nb_path))
     log_spot_h = np.ones((1, nb_path)) * log_s0
 
-    # a, b, c = solve_coeffs(nodes, weight, v0[:, 0], theta, lamda, rho, volvol)
+    for idx, _ in enumerate(timegrid[:-1]):
+        vol_h, y_h, log_spot_h = log_spot_full_solve2_f64(nodes, weight, v0, y0, theta, kappa1, kappa2,
+                                                          log_spot_h, vol_h, y_h, rho, volvol, h, nb_path,
+                                                          Z0[idx], Z1[idx])
+
+    return log_spot_h, vol_h, y_h
+
+
+@njit(cache=False, fastmath=True)
+def diffus_sde_solve_f32(y0: np.ndarray, weight: np.ndarray, weight_sum: np.ndarray,
+                         volvol_weight_sum: np.ndarray, h: float, sqrt_h: float, nb_path: int,
+                         z_rand: np.ndarray):
+    assert y0.shape == weight.shape and y0.shape[-1] == nb_path
+    assert z_rand.shape == (nb_path,)
+    yw = np.sum(weight * y0, axis=0)
+
+    half = np.float32(0.5)
+    one = np.float32(1.0)
+    dW = z_rand * sqrt_h
+    Yh = yw * np.exp(-half * volvol_weight_sum * volvol_weight_sum * h + volvol_weight_sum * dW)
+
+    Q = one / weight_sum * (Yh - yw)
+    Yh_vec = y0.copy()
+    for i in range(Yh_vec.shape[0]):
+        Yh_vec[i] += Q
+
+    return Yh_vec
+
+
+@njit(cache=False, fastmath=True)
+def drift_diffus_strand_f32(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
+                            volvol_weight_sum: np.ndarray, v_init: np.ndarray, weight: np.ndarray, h: float,
+                            sqrt_h: float, weight_sum: np.ndarray, nb_path: int, z_rand: np.ndarray):
+    half = np.float32(0.5)
+    D_inn = drift_ode_solve2_f32(nodes, v0, theta, kappa1, kappa2, v_init, weight, half * h)
+    S_inn = diffus_sde_solve_f32(D_inn, weight, weight_sum, volvol_weight_sum, h, sqrt_h, nb_path, z_rand)
+    sol = drift_ode_solve2_f32(nodes, v0, theta, kappa1, kappa2, S_inn, weight, half * h)
+
+    return sol
+
+
+@njit(cache=False, fastmath=True)
+def log_spot_full_solve2_f32(nodes: np.ndarray, weight: np.ndarray, wlam: np.ndarray, w_inv: np.ndarray,
+                             w_lam_v0: np.ndarray, weight_sum: np.ndarray, v0: np.ndarray, y0: np.ndarray,
+                             theta: float, kappa1: float, kappa2: float, log_s: np.ndarray, v: np.ndarray, y: np.ndarray,
+                             rho: float, rho_comp: float, inv_volvol: float, volvol_weight_sum: np.ndarray,
+                             h: float, sqrt_h: float, nb_path: int, z0: np.ndarray, z1: np.ndarray):
+    assert nodes.shape == weight.shape and weight.ndim == 2
+    assert v.shape == weight.shape and v.shape[-1] == nb_path
+    assert y.shape == (1, nb_path)
+    assert log_s.shape == (1, nb_path)
+    assert v0.shape == weight.shape and v0.shape[-1] == nb_path
+    assert y0.shape == (1, nb_path)
+    assert z0.shape == (nb_path,) and z1.shape == (nb_path,)
+
+    half = np.float32(0.5)
+    eps = np.float32(1e-6)
+
+    vol_h = drift_diffus_strand_f32(nodes, v0, theta, kappa1, kappa2, volvol_weight_sum, v, weight, h, sqrt_h, weight_sum, nb_path, z0)
+    volw_h = np.sum(weight * vol_h, axis=0)
+    idx_bad = np.nonzero(np.logical_or(np.isnan(volw_h), volw_h <= 0.0))[0]
+    vol_h[:, idx_bad] = eps
+
+    vw = np.sum(weight * v, axis=0)
+
+    c1 = half
+    c2 = half
+
+    sq_vw = np.square(vw)
+    sq_vhw = np.square(volw_h)
+
+    w_lam_vol = np.sum(wlam * v, axis=0)
+    w_lam_vol_h = np.sum(wlam * vol_h, axis=0)
+
+    term1 = inv_volvol * (((volw_h - vw) / h + c1 * w_lam_vol + c2 * w_lam_vol_h - w_lam_v0) * w_inv
+                          - kappa1 * theta + (kappa1 - kappa2 * theta) * (c1 * vw + c2 * volw_h)
+                          + kappa2 * (c1 * sq_vw + c2 * sq_vhw)) * h
+
+    term2 = c1 * h * sq_vw + c2 * h * sq_vhw
+    log_spot_h = log_s - half * term2 + rho * term1 + rho_comp * np.sqrt(term2) * z1
+
+    y_h = y + half * h * (vw * vw + volw_h * volw_h)
+
+    return vol_h, y_h, log_spot_h
+
+
+@njit(cache=False, fastmath=True)
+def log_spot_full_combined_f32(nodes: np.ndarray, weight: np.ndarray,
+                               v0: np.ndarray,
+                               theta: float, kappa1: float, kappa2: float, log_s0: float, v_init: np.ndarray,
+                               rho: float, volvol: float, timegrid: np.ndarray, nb_path: int,
+                               Z0: np.ndarray, Z1: np.ndarray):
+    one = np.float32(1.0)
+    h = timegrid[1] - timegrid[0]
+    sqrt_h = np.sqrt(h)
+    wlam = weight * nodes
+    weight_sum = np.sum(weight, axis=0)
+    w_inv = one / weight_sum
+    w_lam_v0 = np.sum(wlam * v0, axis=0)
+    rho_comp = np.sqrt(one - rho * rho)
+    inv_volvol = one / volvol
+    volvol_weight_sum = volvol * weight_sum
+
+    y0 = np.zeros_like(v0[:1, :])
+
+    vol_h = v_init.copy()
+    y_h = np.zeros_like(y0)
+    log_spot_h = np.empty_like(y0)
+    log_spot_h[:] = log_s0
 
     for idx, _ in enumerate(timegrid[:-1]):
-        vol_h, y_h, log_spot_h = log_spot_full_solve2(nodes, weight, v0, y0, theta, kappa1, kappa2,
-                                                     log_spot_h, vol_h, y_h, rho, volvol, h, nb_path,
-                                                      Z0[idx], Z1[idx])
+        vol_h, y_h, log_spot_h = log_spot_full_solve2_f32(nodes, weight, wlam, w_inv, w_lam_v0, weight_sum, v0, y0,
+                                                          theta, kappa1, kappa2, log_spot_h, vol_h, y_h, rho,
+                                                          rho_comp, inv_volvol, volvol_weight_sum, h, sqrt_h,
+                                                          nb_path, Z0[idx], Z1[idx])
 
     return log_spot_h, vol_h, y_h
+
+
+def log_spot_full_combined(nodes: np.ndarray, weight: np.ndarray,
+                           v0: np.ndarray,
+                           theta: float, kappa1: float, kappa2: float, log_s0: float, v_init: np.ndarray,
+                           rho: float, volvol: float, timegrid: np.ndarray, nb_path: int,
+                           Z0: np.ndarray, Z1: np.ndarray):
+    """
+    Dispatch to a float64-stable kernel by default; use float32 kernel only when all inputs are float32.
+    """
+    if (nodes.dtype == np.float32 and weight.dtype == np.float32 and v0.dtype == np.float32 and
+            timegrid.dtype == np.float32 and Z0.dtype == np.float32 and Z1.dtype == np.float32):
+        return log_spot_full_combined_f32(nodes, weight, v0, theta, kappa1, kappa2, log_s0, v_init,
+                                          rho, volvol, timegrid, nb_path, Z0, Z1)
+    return log_spot_full_combined_f64(nodes, weight, v0, theta, kappa1, kappa2, log_s0, v_init,
+                                      rho, volvol, timegrid, nb_path, Z0, Z1)
+
+

stochvolmodels-1.1.7/stochvolmodels/tests/rough_logsv_perf.py

@@ -0,0 +1,302 @@
+"""
+Benchmark rough LogSV pricing over parameter perturbations.
+"""
+
+from __future__ import annotations
+
+import gc
+import time
+import tracemalloc
+import threading
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+import stochvolmodels.pricers.logsv_pricer as sv
+from stochvolmodels import LogSvParams
+from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
+from stochvolmodels.utils.funcs import set_time_grid
+
+import psutil
+
+
+@dataclass(frozen=True)
+class PerfResult:
+    name: str
+    cpu_seconds: float
+    mem_current_kib: float
+    mem_peak_kib: float
+    rss_before_kib: Optional[float]
+    rss_after_kib: Optional[float]
+    rss_delta_kib: Optional[float]
+    rss_peak_delta_kib: Optional[float]
+    rss_peak_kib: Optional[float]
+    checksum: float
+
+
+def _perturb_value(value: float, rel: float) -> float:
+    return value * (1.0 + rel)
+
+
+def build_param_variants(base: LogSvParams,
+                         count: int = 100,
+                         rel_scale: float = 0.02,
+                         seed: int = 123,
+                         param_dtype: Optional[np.dtype] = None) -> List[Tuple[str, LogSvParams]]:
+    """Create a deterministic list of slightly perturbed parameter sets."""
+    if param_dtype is not None:
+        param_dtype = np.dtype(param_dtype)
+    rng = np.random.default_rng(seed)
+    keys = ("sigma0", "theta", "kappa1", "kappa2", "beta", "volvol")
+    variants: List[Tuple[str, LogSvParams]] = []
+
+    for i in range(count):
+        params = LogSvParams.copy(base)
+        deltas = rng.uniform(-rel_scale, rel_scale, size=len(keys))
+        # Ensure a non-zero perturbation for each variant.
+        if np.all(np.abs(deltas) < 1e-12):
+            deltas[0] = rel_scale
+        for key, rel in zip(keys, deltas):
+            value = _perturb_value(getattr(base, key), rel)
+            if param_dtype is not None:
+                value = param_dtype.type(value)
+            setattr(params, key, value)
+        # Keep kernel approximation constant across variants.
+        params.H = base.H
+        params.weights = np.array(base.weights, copy=True)
+        params.nodes = np.array(base.nodes, copy=True)
+        variants.append((f"var-{i:03d}", params))
+    return variants
+
+
+def _rough_price_once(option_chain,
+                      Z0: Optional[np.ndarray],
+                      Z1: Optional[np.ndarray],
+                      grid_ttms,
+                      params: LogSvParams,
+                      nb_path: int,
+                      seed: int,
+                      random_mode: str,
+                      float32_mode: bool):
+    sigma0 = params.sigma0
+    theta = params.theta
+    kappa1 = params.kappa1
+    kappa2 = params.kappa2
+    beta = params.beta
+    volvol = params.volvol
+    if float32_mode:
+        sigma0 = np.float32(sigma0)
+        theta = np.float32(theta)
+        kappa1 = np.float32(kappa1)
+        kappa2 = np.float32(kappa2)
+        beta = np.float32(beta)
+        volvol = np.float32(volvol)
+    if random_mode == "seeded":
+        return sv.rough_logsv_mc_chain_pricer_seeded(
+            ttms=option_chain.ttms,
+            forwards=option_chain.forwards,
+            discfactors=option_chain.discfactors,
+            strikes_ttms=option_chain.strikes_ttms,
+            optiontypes_ttms=option_chain.optiontypes_ttms,
+            nb_path=nb_path,
+            seed=seed,
+            sigma0=sigma0,
+            theta=theta,
+            kappa1=kappa1,
+            kappa2=kappa2,
+            beta=beta,
+            orthog_vol=volvol,
+            weights=params.weights,
+            nodes=params.nodes,
+            timegrids=grid_ttms,
+        )
+    return sv.rough_logsv_mc_chain_pricer_fixed_randoms(
+        ttms=option_chain.ttms,
+        forwards=option_chain.forwards,
+        discfactors=option_chain.discfactors,
+        strikes_ttms=option_chain.strikes_ttms,
+        optiontypes_ttms=option_chain.optiontypes_ttms,
+        Z0=Z0,
+        Z1=Z1,
+        sigma0=sigma0,
+        theta=theta,
+        kappa1=kappa1,
+        kappa2=kappa2,
+        beta=beta,
+        orthog_vol=volvol,
+        weights=params.weights,
+        nodes=params.nodes,
+        timegrids=grid_ttms,
+    )
+
+
+def _get_rss_kib() -> Optional[float]:
+    if psutil is None:
+        return None
+    return psutil.Process().memory_info().rss / 1024.0
+
+
+class _RssSampler:
+    def __init__(self, interval_sec: float):
+        self.interval_sec = interval_sec
+        self.max_rss_kib: Optional[float] = None
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def _run(self) -> None:
+        proc = psutil.Process()
+        while not self._stop.is_set():
+            rss = proc.memory_info().rss / 1024.0
+            if self.max_rss_kib is None or rss > self.max_rss_kib:
+                self.max_rss_kib = rss
+            time.sleep(self.interval_sec)
+
+    def start(self) -> None:
+        if psutil is None:
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._thread is None:
+            return
+        self._stop.set()
+        self._thread.join()
+
+
+def run_rough_logsv_loop_bench(nb_path: int = 50000,
+                               nb_steps_per_year: int = 240,
+                               seed: int = 10,
+                               dtype: np.dtype = np.float32,
+                               warmup: int = 1,
+                               variants: int = 100,
+                               rss_sample_interval: float = 0.01,
+                               random_mode: str = "fixed",
+                               float32_mode: bool = True) -> pd.DataFrame:
+    option_chain = get_btc_test_chain_data()
+
+    if random_mode not in ("fixed", "seeded"):
+        raise ValueError("random_mode must be 'fixed' or 'seeded'")
+
+    Z0 = None
+    Z1 = None
+    grid_ttms: List[np.ndarray] = []
+    if random_mode == "fixed":
+        try:
+            Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(
+                ttms=option_chain.ttms,
+                nb_path=nb_path,
+                nb_steps_per_year=nb_steps_per_year,
+                seed=seed,
+                dtype=dtype,
+                chunk_size=2048,
+                use_legacy_rng=False,
+            )
+        except TypeError:
+            # Backward-compatibility: older signatures may not support dtype/chunk_size/use_legacy_rng.
+            Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(
+                ttms=option_chain.ttms,
+                nb_path=nb_path,
+                nb_steps_per_year=nb_steps_per_year,
+                seed=seed,
+            )
+            if Z0.dtype != dtype:
+                Z0 = Z0.astype(dtype, copy=False)
+            if Z1.dtype != dtype:
+                Z1 = Z1.astype(dtype, copy=False)
+        if float32_mode:
+            grid_ttms = [np.asarray(g, dtype=np.float32) for g in grid_ttms]
+    else:
+        for ttm in option_chain.ttms:
+            _, _, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=nb_steps_per_year)
+            if float32_mode:
+                grid_t = np.asarray(grid_t, dtype=np.float32)
+            grid_ttms.append(grid_t)
+
+    base_params = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
+    base_params.H = 0.1
+    base_params.approximate_kernel(T=option_chain.ttms[-1])
+    if float32_mode:
+        base_params.weights = base_params.weights.astype(np.float32, copy=False)
+        base_params.nodes = base_params.nodes.astype(np.float32, copy=False)
+    param_dtype = np.float32 if float32_mode else None
+    variants = build_param_variants(base=base_params, count=variants, param_dtype=param_dtype)
+
+    # Warm up numba kernels before timing.
+    for _ in range(max(0, warmup)):
+        _rough_price_once(option_chain, Z0, Z1, grid_ttms, variants[0][1], nb_path, seed, random_mode, float32_mode)
+
+    tracemalloc.start()
+    results: List[PerfResult] = []
+
+    for name, params in variants:
+        gc.collect()
+        tracemalloc.reset_peak()
+        mem_before, _ = tracemalloc.get_traced_memory()
+        rss_before = _get_rss_kib()
+        sampler = None
+        if rss_sample_interval > 0.0 and psutil is not None:
+            sampler = _RssSampler(interval_sec=rss_sample_interval)
+            sampler.start()
+        cpu_start = time.process_time()
+
+        option_prices_ttm, option_std_ttm = _rough_price_once(option_chain, Z0, Z1, grid_ttms, params, nb_path, seed, random_mode, float32_mode)
+
+        cpu_end = time.process_time()
+        if sampler is not None:
+            sampler.stop()
+        mem_after, mem_peak = tracemalloc.get_traced_memory()
+        rss_after = _get_rss_kib()
+        rss_peak_kib = None
+        if sampler is not None and sampler.max_rss_kib is not None:
+            rss_peak_kib = sampler.max_rss_kib
+        elif rss_before is not None and rss_after is not None:
+            rss_peak_kib = max(rss_before, rss_after)
+
+        # Basic checksum to keep outputs used.
+        checksum = 0.0
+        for arr in option_prices_ttm:
+            checksum += float(np.sum(np.asarray(arr)))
+
+        results.append(
+            PerfResult(
+                name=name,
+                cpu_seconds=cpu_end - cpu_start,
+                mem_current_kib=(mem_after - mem_before) / 1024.0,
+                mem_peak_kib=(mem_peak - mem_before) / 1024.0,
+                rss_before_kib=rss_before,
+                rss_after_kib=rss_after,
+                rss_delta_kib=None if rss_before is None or rss_after is None else rss_after - rss_before,
+                rss_peak_delta_kib=None if rss_before is None or rss_peak_kib is None else rss_peak_kib - rss_before,
+                rss_peak_kib=rss_peak_kib,
+                checksum=checksum,
+            )
+        )
+
+        del option_prices_ttm, option_std_ttm
+
+    tracemalloc.stop()
+
+    df = pd.DataFrame([r.__dict__ for r in results])
+    cols = [
+        "name",
+        "cpu_seconds",
+        "mem_current_kib",
+        "mem_peak_kib",
+        "rss_before_kib",
+        "rss_after_kib",
+        "rss_peak_kib",
+        "rss_delta_kib",
+        "rss_peak_delta_kib",
+        "checksum",
+    ]
+    return df[cols]
+
+
+if __name__ == "__main__":
+    df_results = run_rough_logsv_loop_bench(rss_sample_interval=0.01)
+    pd.set_option("display.max_columns", None)
+    print(df_results.to_string(index=False))

stochvolmodels-1.1.7/stochvolmodels/tests/test_rough_logsv_pricer_regression/test_rough_logsv_pricer_pricing_regression.yml

@@ -0,0 +1,50 @@
+option_prices_ttm:
+- - 50.19425805335426
+  - 85.78123633760005
+  - 116.91358931762213
+  - 162.4580622457345
+  - 372.81329329569274
+  - 802.611749231318
+  - 834.7478904032646
+  - 667.207094669157
+  - 552.2749423049975
+  - 507.62643625299205
+  - 215.6090504645614
+  - 174.53589766819024
+- - 48.450698138440806
+  - 69.10380918456832
+  - 159.1452950831655
+  - 237.7658653770458
+  - 652.8141266564039
+  - 832.9187768846742
+  - 1466.3894567786515
+  - 894.7443513553394
+  - 636.5643533548471
+  - 487.1065297015045
+  - 386.2625424682371
+  - 254.2266569174367
+  - 133.31669638376397
+- - 27.33253410210627
+  - 45.98892670127133
+  - 79.5589437813465
+  - 171.06432274681012
+  - 283.42795051502344
+  - 493.07730134022853
+  - 969.2189310032159
+  - 2424.1298433093352
+  - 1598.9572854456496
+  - 1198.0540185632092
+  - 950.6801089319849
+  - 782.6615652726292
+  - 564.2747342734503
+  - 232.11136113922865
+  - 175.48117302952474
+- - 25.50036622791895
+  - 48.60144007274547
+  - 735.5501966187034
+  - 2115.478840582238
+  - 964.2203951674677
+  - 540.4372248348861
+  - 255.43422271814464
+  - 46.56074959115207
+  - 31.62313590270595

stochvolmodels-1.1.7/stochvolmodels/tests/test_rough_logsv_pricer_regression.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+import stochvolmodels as sv
+from stochvolmodels import LogSVPricer, LogSvParams, LogsvModelCalibrationType
+
+
+def _array_list(values):
+    return [np.asarray(item).tolist() for item in values]
+
+
+def test_rough_logsv_pricer_pricing_regression(data_regression) -> None:
+    btc_option_chain = sv.get_btc_test_chain_data()
+    Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(
+        ttms=btc_option_chain.ttms,
+        nb_path=10000,
+        nb_steps_per_year=360,
+        seed=10,
+    )
+    params0 = LogSvParams(
+        sigma0=0.377,
+        theta=0.347,
+        kappa1=1.29,
+        kappa2=1.93,
+        beta=2.45,
+        volvol=1.81,
+    )
+    params0.H = 0.1
+    params0.approximate_kernel(T=btc_option_chain.ttms[-1])
+
+    option_prices_ttm, _option_std_ttm = sv.rough_logsv_mc_chain_pricer_fixed_randoms(
+        ttms=btc_option_chain.ttms,
+        forwards=btc_option_chain.forwards,
+        discfactors=btc_option_chain.discfactors,
+        strikes_ttms=btc_option_chain.strikes_ttms,
+        optiontypes_ttms=btc_option_chain.optiontypes_ttms,
+        Z0=Z0,
+        Z1=Z1,
+        sigma0=params0.sigma0,
+        theta=params0.theta,
+        kappa1=params0.kappa1,
+        kappa2=params0.kappa2,
+        beta=params0.beta,
+        orthog_vol=params0.volvol,
+        weights=params0.weights,
+        nodes=params0.nodes,
+        timegrids=grid_ttms,
+    )
+
+    data_regression.check({"option_prices_ttm": _array_list(option_prices_ttm)})
+

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7/stochvolmodels.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.6
+Version: 1.1.7
 Summary: Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models including log-normal SV model, Heston
 Author-email: Artur Sepp <artursepp@gmail.com>
 Maintainer-email: Artur Sepp <artursepp@gmail.com>, Parviz Rakhmonov <ParvizRZ@gmail.com>
@@ -727,9 +727,10 @@ Requires-Dist: jupyterlab>=3.0.0; extra == "jupyter"
 Requires-Dist: ipykernel>=6.0.0; extra == "jupyter"
 Requires-Dist: ipywidgets>=8.0.0; extra == "jupyter"
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest>=8.4.2; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: pytest-regressions>=2.8.3; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: flake8>=5.0.0; extra == "dev"

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7}/stochvolmodels.egg-info/SOURCES.txt

@@ -83,6 +83,9 @@ stochvolmodels/pricers/rough_logsv/test_kernel_approx.py
 stochvolmodels/tests/__init__.py
 stochvolmodels/tests/bsm_mgf_pricer.py
 stochvolmodels/tests/qv_pricer.py
+stochvolmodels/tests/rough_logsv_perf.py
+stochvolmodels/tests/test_rough_logsv_pricer_regression.py
+stochvolmodels/tests/test_rough_logsv_pricer_regression/test_rough_logsv_pricer_pricing_regression.yml
 stochvolmodels/utils/__init__.py
 stochvolmodels/utils/config.py
 stochvolmodels/utils/funcs.py

{stochvolmodels-1.1.6 → stochvolmodels-1.1.7}/stochvolmodels.egg-info/requires.txt

@@ -14,9 +14,10 @@ fsspec>=2024.12.0
 stochvolmodels[jupyter,numerical,performance,research,visualization]
 
 [dev]
-pytest>=7.0.0
+pytest>=8.4.2
 pytest-cov>=4.0.0
 pytest-mock>=3.10.0
+pytest-regressions>=2.8.3
 pytest-xdist>=3.0.0
 black>=22.0.0
 flake8>=5.0.0