stochvolmodels 1.1.4__tar.gz → 1.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.4
+Version: 1.1.6
 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>

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

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stochvolmodels"
-version = "1.1.4"
+version = "1.1.6"
 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"}

stochvolmodels-1.1.6/stochvolmodels/examples/run_hawkes_pricer.py

@@ -0,0 +1,50 @@
+
+# built in
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import minimize
+from numba.typed import List
+from typing import Tuple, Optional, Dict, Any
+from dataclasses import dataclass, asdict
+from scipy.integrate import solve_ivp
+from scipy.integrate._ivp.ivp import OdeResult
+from enum import Enum
+
+# stochvolmodels pricers
+import stochvolmodels.utils.mgf_pricer as mgfp
+from stochvolmodels.utils.config import VariableType
+from stochvolmodels.utils.mc_payoffs import compute_mc_vars_payoff
+from stochvolmodels.pricers.model_pricer import ModelPricer, ModelParams
+from stochvolmodels.utils.funcs import to_flat_np_array, set_time_grid, timer, set_seed
+
+# data
+from stochvolmodels.data.option_chain import OptionChain
+from stochvolmodels import OptionChain, HawkesJDPricer, HawkesJDParams
+
+pricer = HawkesJDPricer()
+
+params = HawkesJDParams(sigma=0.1,
+                        shift_p=0.25,  # positive jump threshold
+                        mean_p=0.00,
+                        shift_m=-0.25,
+                        mean_m=-0.00,
+                        lambda_p=1.0,
+                        theta_p=0.01,
+                        kappa_p=300.0,
+                        beta1_p=0.0,
+                        beta2_p=0.0,
+                        lambda_m=1.0,
+                        theta_m=0.01,
+                        kappa_m=300.0,
+                        beta1_m=0.0,
+                        beta2_m=0.0)
+
+option_chain = OptionChain.get_uniform_chain(ttms=np.array([1.0/12.0]),
+                                             ids=np.array(['1m']),
+                                             forwards=np.array([100.0]),
+                                             strikes=100.0*np.linspace(0.5, 1.5, 30))
+
+pricer.plot_model_ivols(option_chain=option_chain,
+                        params=params)
+
+plt.show()

{stochvolmodels-1.1.4 → stochvolmodels-1.1.6}/stochvolmodels/examples/run_lognormal_sv_pricer.py

@@ -11,7 +11,7 @@ from enum import Enum
 import stochvolmodels as sv
 from stochvolmodels.utils import plots as plot
 from stochvolmodels import LogSVPricer, LogSvParams, OptionChain, LogsvModelCalibrationType
-
+# from uuid import uuid4
 
 class LocalTests(Enum):
     COMPUTE_MODEL_PRICES = 1
@@ -142,8 +142,8 @@ def run_local_test(local_test: LocalTests):
                                                                              nb_path=10000,
                                                                              nb_steps_per_year=360,
                                                                              seed=10)
-        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
-        params0.H = 0.3
+        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,
@@ -167,9 +167,9 @@ def run_local_test(local_test: LocalTests):
     elif local_test == LocalTests.BENCHM_ROUGH_PRICER:
         btc_option_chain = sv.get_btc_test_chain_data()
         # params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=1.0, beta=0.15, volvol=1.0)
-        params0 = LogSvParams(sigma0=1.32, theta=0.47, kappa1=9.98, kappa2=2.0, beta=0.45, volvol=0.83)
-        nb_path = 1000000
-        H = 0.4
+        params0 = LogSvParams(sigma0=0.377, theta=0.347, kappa1=1.29, kappa2=1.93, beta=2.45, volvol=1.81)
+        nb_path = 10000
+        H = 0.1
         seed = 1
 
         def rough_vol():
@@ -268,23 +268,31 @@ def run_local_test(local_test: LocalTests):
 
     elif local_test == LocalTests.CALIBRATE_MODEL_TO_BTC_OPTIONS_WITH_MC:
         btc_option_chain = sv.get_btc_test_chain_data()
-        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
-        params0.H = 0.3
+        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
+        params0.H = 0.2
         params0.approximate_kernel(T=btc_option_chain.ttms[-1])
         btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(option_chain=btc_option_chain,
                                                                              params0=params0,
                                                                              model_calibration_type=LogsvModelCalibrationType.PARAMS4,
                                                                              constraints_type=sv.ConstraintsType.INVERSE_MARTINGALE,
                                                                              calibration_engine=sv.CalibrationEngine.ROUGH_MC,
-                                                                             nb_path=100000,
+                                                                             nb_path=5000,
                                                                              seed=7)
         print(btc_calibrated_params)
-        logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
-                                                 params=btc_calibrated_params)
+        fig = logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
+                                                 params=btc_calibrated_params,
+                                                       mode='mc',
+                                                       use_rough_mc=True,
+                                                       seed=16,
+                                                       nb_steps=360
+                                                       )
+
+        # uuid = str(uuid4())
+        # plot.save_fig(fig=fig, local_path=r"c:/temp/", file_name=f"fit_quality_{uuid}")
 
     plt.show()
 
 
 if __name__ == '__main__':
 
-    run_local_test(local_test=LocalTests.BENCHM_ROUGH_PRICER)
+    run_local_test(local_test=LocalTests.ROUGH_MC_WITH_FIXED_RANDOMS)

{stochvolmodels-1.1.4 → stochvolmodels-1.1.6}/stochvolmodels/pricers/hawkes_jd_pricer.py

@@ -827,4 +827,4 @@ def run_local_test(local_test: LocalTests):
 
 if __name__ == '__main__':
 
-    run_local_test(local_test=LocalTests.MC_COMPARISION)
+    run_local_test(local_test=LocalTests.SLICE_PRICER)

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

@@ -87,22 +87,44 @@ class LogSVPricer(ModelPricer):
                              **kwargs
                              ) -> (List[np.ndarray], List[np.ndarray]):
         vol_backbone_etas = params.get_vol_backbone_etas(ttms=option_chain.ttms)
-        return logsv_mc_chain_pricer(v0=params.sigma0,
-                                     theta=params.theta,
-                                     kappa1=params.kappa1,
-                                     kappa2=params.kappa2,
-                                     beta=params.beta,
-                                     volvol=params.volvol,
-                                     vol_backbone_etas=vol_backbone_etas,
-                                     ttms=option_chain.ttms,
-                                     forwards=option_chain.forwards,
-                                     discfactors=option_chain.discfactors,
-                                     strikes_ttms=option_chain.strikes_ttms,
-                                     optiontypes_ttms=option_chain.optiontypes_ttms,
-                                     is_spot_measure=is_spot_measure,
-                                     variable_type=variable_type,
-                                     nb_path=nb_path,
-                                     nb_steps_per_year=nb_steps or int(360 * np.max(option_chain.ttms)) + 1)
+        if 'use_rough_mc' in kwargs and kwargs['use_rough_mc']:
+            assert 'seed' in kwargs
+            seed = kwargs['seed']
+            Z0, Z1, grid_ttms = get_randoms_for_rough_vol_chain_valuation(ttms=option_chain.ttms, nb_path=nb_path,
+                                                                          nb_steps_per_year=nb_steps, seed=seed)
+            return 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=params.sigma0,
+                                                             theta=params.theta,
+                                                             kappa1=params.kappa1,
+                                                             kappa2=params.kappa2,
+                                                             beta=params.beta,
+                                                             orthog_vol=params.volvol,
+                                                             weights=params.weights,
+                                                             nodes=params.nodes,
+                                                             timegrids=grid_ttms)
+        else:
+            return logsv_mc_chain_pricer(v0=params.sigma0,
+                                         theta=params.theta,
+                                         kappa1=params.kappa1,
+                                         kappa2=params.kappa2,
+                                         beta=params.beta,
+                                         volvol=params.volvol,
+                                         vol_backbone_etas=vol_backbone_etas,
+                                         ttms=option_chain.ttms,
+                                         forwards=option_chain.forwards,
+                                         discfactors=option_chain.discfactors,
+                                         strikes_ttms=option_chain.strikes_ttms,
+                                         optiontypes_ttms=option_chain.optiontypes_ttms,
+                                         is_spot_measure=is_spot_measure,
+                                         variable_type=variable_type,
+                                         nb_path=nb_path,
+                                         nb_steps_per_year=nb_steps or int(360 * np.max(option_chain.ttms)) + 1)
 
     def set_vol_scaler(self, option_chain: OptionChain) -> float:
         """
@@ -884,8 +906,8 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
         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)}")
-        print(f"Mean spot Strand: {np.mean(np.exp(log_spot_str))}")
+        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,

{stochvolmodels-1.1.4 → stochvolmodels-1.1.6}/stochvolmodels/pricers/model_pricer.py

@@ -331,7 +331,11 @@ class ModelPricer(ABC):
         plot model slice_t vols
         optimized for 2*2 figure
         """
-        model_ivols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, **kwargs)
+        if 'mode' in kwargs and kwargs['mode'] == 'mc':
+            model_ivols = self.compute_mc_chain_implied_vols(option_chain=option_chain, params=params, **kwargs)[3]
+        else:
+            model_ivols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, **kwargs)
+
 
         num_slices = len(option_chain.ttms)
         with sns.axes_style('darkgrid'):

stochvolmodels-1.1.6/stochvolmodels/pricers/rough_logsv/expm.py

@@ -0,0 +1,452 @@
+import numpy as np
+import math
+import cmath
+from numba import njit, prange
+
+
+# ---------- small complex helpers (Numba-friendly) ----------
+
+@njit(cache=True)
+def _cabs(z):
+    return math.hypot(z.real, z.imag)
+
+@njit(cache=True)
+def _csqrt(z):
+    # principal square root
+    r = _cabs(z)
+    if r == 0.0:
+        return 0.0 + 0.0j
+    # sqrt in polar form
+    theta = math.atan2(z.imag, z.real)
+    sr = math.sqrt(r)
+    ht = 0.5 * theta
+    return complex(sr * math.cos(ht), sr * math.sin(ht))
+
+@njit(cache=True)
+def _ccbrt(z):
+    # principal cube root
+    r = _cabs(z)
+    if r == 0.0:
+        return 0.0 + 0.0j
+    theta = math.atan2(z.imag, z.real)
+    cr = r ** (1.0 / 3.0)
+    tt = theta / 3.0
+    return complex(cr * math.cos(tt), cr * math.sin(tt))
+
+
+# ---------- Step 1: cubic roots for p(r)=0 ----------
+
+@njit(cache=True)
+def _cubic_roots_monic(a2, a1, a0):
+    """
+    Solve r^3 + a2*r^2 + a1*r + a0 = 0 (monic cubic).
+    Returns 3 complex roots (principal-branch Cardano).
+    """
+    # Depress: r = y - a2/3
+    one_third = 1.0 / 3.0
+    shift = a2 * one_third
+
+    p = a1 - (a2 * a2) * one_third
+    q = (2.0 * a2 * a2 * a2) / 27.0 - (a2 * a1) / 3.0 + a0
+
+    # Discriminant: Δ = (q/2)^2 + (p/3)^3
+    q2 = 0.5 * q
+    p3 = p * one_third
+    Delta = q2 * q2 + p3 * p3 * p3  # complex-safe
+
+    sqrtD = _csqrt(Delta)
+    u = _ccbrt(-q2 + sqrtD)
+    v = _ccbrt(-q2 - sqrtD)
+
+    y1 = u + v
+
+    # cube roots of unity:
+    # y2 = -(u+v)/2 + i*sqrt(3)/2*(u-v)
+    # y3 = -(u+v)/2 - i*sqrt(3)/2*(u-v)
+    half = 0.5
+    s3_2 = 0.5 * math.sqrt(3.0)
+
+    uv = u - v
+    y2 = -half * y1 + complex(-s3_2 * uv.imag, s3_2 * uv.real)  # i*s3_2*(u-v)
+    y3 = -half * y1 - complex(-s3_2 * uv.imag, s3_2 * uv.real)
+
+    r1 = y1 - shift
+    r2 = y2 - shift
+    r3 = y3 - shift
+    return r1, r2, r3
+
+
+# ---------- Step 2: solve Vandermonde for c0,c1,c2 ----------
+
+@njit(cache=True)
+def _solve_3x3_complex(M, b):
+    """
+    Solve M x = b for 3x3 complex M with partial pivoting.
+    Returns x (complex length-3).
+    """
+    A = M.copy()
+    rhs = b.copy()
+
+    # Forward elimination
+    for k in range(3):
+        # pivot
+        piv = k
+        best = _cabs(A[k, k])
+        for i in range(k + 1, 3):
+            v = _cabs(A[i, k])
+            if v > best:
+                best = v
+                piv = i
+        if piv != k:
+            # swap rows
+            for j in range(3):
+                tmp = A[k, j]
+                A[k, j] = A[piv, j]
+                A[piv, j] = tmp
+            tmp = rhs[k]
+            rhs[k] = rhs[piv]
+            rhs[piv] = tmp
+
+        akk = A[k, k]
+        # If akk is (near) zero, this can blow up; caller should avoid repeated roots.
+        for i in range(k + 1, 3):
+            factor = A[i, k] / akk
+            A[i, k] = 0.0 + 0.0j
+            for j in range(k + 1, 3):
+                A[i, j] = A[i, j] - factor * A[k, j]
+            rhs[i] = rhs[i] - factor * rhs[k]
+
+    # Back substitution
+    x = np.empty(3, dtype=np.complex128)
+    for i in range(2, -1, -1):
+        s = rhs[i]
+        for j in range(i + 1, 3):
+            s = s - A[i, j] * x[j]
+        x[i] = s / A[i, i]
+    return x
+
+
+# ---------- Step 3: build e^A = c0 I + c1 A + c2 A^2 ----------
+
+@njit(cache=True)
+def expA_n3_numba(kappa, lambdas, w, tol=1e-10):
+    """
+    Computes exp(A) for A = -kappa * 1*w^T - diag(lambdas), where 1=(1,1,1)^T.
+    Steps:
+      1) build cubic p(r)=det(rI-A) and find roots r1,r2,r3
+      2) solve Vandermonde for c0,c1,c2 so exp(A)=c0 I + c1 A + c2 A^2
+      3) evaluate polynomial in A
+
+    Returns: 3x3 float64 matrix.
+    """
+    l1, l2, l3 = lambdas[0], lambdas[1], lambdas[2]
+    w1, w2, w3 = w[0], w[1], w[2]
+
+    # --- Build monic cubic coefficients for p(r)=0:
+    # p(r) = (r+λ1)(r+λ2)(r+λ3) + κ[ w1(r+λ2)(r+λ3) + w2(r+λ1)(r+λ3) + w3(r+λ1)(r+λ2) ]
+    s1 = l1 + l2 + l3
+    s2 = l1*l2 + l1*l3 + l2*l3
+    s3 = l1*l2*l3
+
+    W = w1 + w2 + w3
+    B = w1*(l2+l3) + w2*(l1+l3) + w3*(l1+l2)
+    C = w1*(l2*l3) + w2*(l1*l3) + w3*(l1*l2)
+
+    a2 = s1 + kappa * W
+    a1 = s2 + kappa * B
+    a0 = s3 + kappa * C
+
+    r1, r2, r3 = _cubic_roots_monic(a2 + 0.0j, a1 + 0.0j, a0 + 0.0j)
+
+    # Guard against repeated/near-repeated roots (Vandermonde gets unstable)
+    if _cabs(r1 - r2) < tol or _cabs(r1 - r3) < tol or _cabs(r2 - r3) < tol:
+        # Simple fallback: scaling-and-squaring with truncated Taylor (kept Numba-friendly)
+        # This is not "steps 1-2-3" anymore, but prevents crashes when roots collide.
+        A = np.zeros((3, 3), dtype=np.float64)
+        for i in range(3):
+            for j in range(3):
+                A[i, j] = -kappa * w[j]
+            A[i, i] -= lambdas[i]
+
+        # scale
+        # crude bound on ||A||_1
+        colsum_max = 0.0
+        for j in range(3):
+            s = 0.0
+            for i in range(3):
+                s += abs(A[i, j])
+            if s > colsum_max:
+                colsum_max = s
+        s_pow = 0
+        if colsum_max > 0.5:
+            s_pow = int(math.ceil(math.log(colsum_max / 0.5) / math.log(2.0)))
+
+        As = A / (2.0 ** s_pow)
+
+        # exp(As) via Taylor up to N terms
+        E = np.eye(3, dtype=np.float64)
+        term = np.eye(3, dtype=np.float64)
+        N = 30
+        for n in range(1, N + 1):
+            # term = term @ As / n
+            newterm = np.zeros((3, 3), dtype=np.float64)
+            for i in range(3):
+                for j in range(3):
+                    acc = 0.0
+                    for k in range(3):
+                        acc += term[i, k] * As[k, j]
+                    newterm[i, j] = acc / n
+            term = newterm
+            E += term
+
+        # square back
+        for _ in range(s_pow):
+            EE = np.zeros((3, 3), dtype=np.float64)
+            for i in range(3):
+                for j in range(3):
+                    acc = 0.0
+                    for k in range(3):
+                        acc += E[i, k] * E[k, j]
+                    EE[i, j] = acc
+            E = EE
+        return E
+
+    # Vandermonde: [1 r r^2][c0,c1,c2]^T = exp(r)
+    V = np.empty((3, 3), dtype=np.complex128)
+    b = np.empty(3, dtype=np.complex128)
+
+    roots = (r1, r2, r3)
+    for i in range(3):
+        r = roots[i]
+        V[i, 0] = 1.0 + 0.0j
+        V[i, 1] = r
+        V[i, 2] = r * r
+        b[i] = np.exp(r)
+
+    c = _solve_3x3_complex(V, b)
+    c0, c1, c2 = c[0], c[1], c[2]
+
+    # Build A (real)
+    A = np.zeros((3, 3), dtype=np.float64)
+    for i in range(3):
+        for j in range(3):
+            A[i, j] = -kappa * w[j]
+        A[i, i] -= lambdas[i]
+
+    # A^2
+    A2 = np.zeros((3, 3), dtype=np.float64)
+    for i in range(3):
+        for j in range(3):
+            acc = 0.0
+            for k in range(3):
+                acc += A[i, k] * A[k, j]
+            A2[i, j] = acc
+
+    # E = c0 I + c1 A + c2 A^2  (complex -> take real part)
+    E = np.zeros((3, 3), dtype=np.float64)
+    for i in range(3):
+        for j in range(3):
+            val = c1 * (A[i, j] + 0.0j) + c2 * (A2[i, j] + 0.0j)
+            if i == j:
+                val += c0
+            E[i, j] = val.real  # imaginary parts should be ~0 for real A
+    return E
+
+@njit(cache=True)
+def expA_n1_numba (kappa, lambdas, w):
+    """
+    n=1: A = (lambda1 + kappa*w1). Returns scalar
+    lambdas: shape (1,)
+    w: shape (1,)
+    """
+    a = -(lambdas[0] + kappa * w[0])
+    out = math.exp(a)
+    return out
+
+@njit(cache=True)
+def _sinhc(z, tol=1e-12):
+    """sinh(z)/z with small-z series for stability (Numba-friendly)."""
+    if abs(z) < tol:
+        z2 = z * z
+        return 1.0 + 22 / 6.0 + (z2 *z2) / 120.0
+    return cmath.sinh(z) / z
+
+
+@njit(cache=True)
+def expA_n2_numba(kappa, lambdas, w):
+    """n=2: A = -kappa*1*w^T - diag(lambdas). Returns 2x2 exp(A).
+    lambdas: shape (2,)
+    w: shape (2,)
+    """
+    l1, l2 = lambdas[0], lambdas [1]
+    w1, w2 = w[0], w[1]
+
+    # A entries
+    a11 = -l1 - kappa * w1
+    a12 = -kappa * w2
+    a21 = -kappa * w1
+    a22 = -l2 - kappa * w2
+
+    tr = a11 + a22
+    det = a11 * a22 - a12 * a21
+
+    half_tr = 0.5 * tr
+    Delta = cmath.sqrt((half_tr * half_tr) - det + 0.0j)
+
+    ehalf = math.exp(half_tr) # half_tr is real
+    c = cmath.cosh(Delta)
+    s_over = _sinhc(Delta)
+
+    # B = A  - (tr/2) I
+    b11 = a11 - half_tr
+    b22 = a22 - half_tr
+    b12 = a12
+    b21 = a21
+
+    # exp(A) = e^{tr/2} [ c I + (sinh(Delta)/Delta) * B ]
+    E11 = ehalf * (c + s_over * (b11 + 0.0j))
+    E22 = ehalf * (c + s_over * (b22 + 0.0j))
+    E12 = ehalf * (s_over * (b12 + 0.0j))
+    E21 = ehalf * (s_over * (b21 + 0.0j))
+
+    out = np.empty((2, 2), dtype = np.float64)
+    out[0, 0] = E11.real
+    out[0, 1] = E12.real
+    out[1, 0] = E21.real
+    out[1, 1] = E22.real
+    return out
+
+
+
+@njit(parallel=True, cache=True)
+def batch_expA_n3(kappas: np.ndarray, lambdas_all: np.ndarray, w_all: np.ndarray):
+    """
+    kappas: shape (N,)
+    lambdas_all: shape (N,3)
+    w_all: shape (N,3)
+    returns: shape (N,3,3)
+    """
+    N = kappas.shape[-1]
+    out = np.empty((N,3,3), dtype=np.float64)
+    for i in prange(N):
+        out[i] = expA_n3_numba(kappas[i], lambdas_all[i], w_all[i])
+    return out
+
+
+@njit(parallel=True, cache=True)
+def batch_expA_n2(kappas: np.ndarray, lambdas_all: np.ndarray, w_all: np.ndarray):
+    """
+    kappas: shape (N,)
+    lambdas_all: shape (N,2)
+    w_all: shape (N,2)
+    returns: shape (N,2,2)
+    """
+    N = kappas.shape[-1]
+    out = np.empty((N,2,2), dtype=np.float64)
+    for i in prange(N):
+        out[i] = expA_n2_numba(kappas[i], lambdas_all[i], w_all[i])
+    return out
+
+
+@njit(parallel=True, cache=True)
+def batch_expA_n1(kappas: np.ndarray, lambdas_all: np.ndarray, w_all: np.ndarray):
+    """
+    kappas: shape (N,)
+    lambdas_all: shape (N,1)
+    w_all: shape (N,1)
+    returns: shape (N,1,1)
+    """
+    N = kappas.shape[-1]
+    out = np.empty((N,1,1), dtype=np.float64)
+    for i in prange(N):
+        out[i,0,0] = expA_n1_numba(kappas[i], lambdas_all[i], w_all[i])
+    return out
+
+
+
+@njit(parallel=True, cache=True)
+def batch_expA(kappas: np.ndarray, lambdas_all: np.ndarray, w_all: np.ndarray):
+    """
+    kappas: shape (N,)
+    lambdas_all: shape (N,d)
+    w_all: shape (N,d)
+    returns: shape (N,d,d)
+    """
+    d = lambdas_all.shape[-1]
+    if d==1:
+        return batch_expA_n1(kappas, lambdas_all, w_all)
+    elif d==2:
+        return batch_expA_n2(kappas, lambdas_all, w_all)
+    elif d==3:
+        return batch_expA_n3(kappas, lambdas_all, w_all)
+    else:
+        raise ValueError("Only d=1,2,3 are supported")
+
+
+#########################################################################
+@njit(cache=True)
+def invA_rank1_numba_general(kappa, lambdas, w, tol=1e-14):
+    """Analytic inverse for A = -kappa*1*w^T - diag(lambdas), any n>=1.
+
+    Inputs:
+    kappa: float
+    lambdas: (n,) float64, diagonal entries of L (must be nonzero)
+    w: (n.) float64
+    tol: singularity tolerance for denom
+
+    Returns:
+    Ainv: (n,n) float64. If singular/ill-conditioned, returns all-Nan matrix.
+    """
+    n = lambdas.shape[0]
+    Ainv = np.empty((n, n), dtype=np.float64)
+
+    # d_i = 1/lambda_i, z_i = w_i/lambda_i, s = sum z_i
+    d = np.empty(n, dtype=np.float64)
+    z = np.empty(n, dtype=np.float64)
+
+    s = 0.0
+    for i in range(n):
+        lam = lambdas[i]
+        if lam == 0.0:
+            # singular because L^{-1} doesn't exist
+            for r in range(n):
+                for c in range(n):
+                    Ainv[r, c] = np.nan
+            return Ainv
+        di = 1.0 / lam
+        d[i] = di
+        zi = w[i] * di
+        z[i] = zi
+        s += zi
+
+    denom = 1.0 + kappa * s
+    if abs(denom) < tol:
+        for r in range(n):
+            for c in range(n):
+                Ainv[r, c] = np.nan
+        return Ainv
+
+    alpha = kappa / denom
+    for i in range(n):
+        di = d[i]
+        for j in range(n):
+            val = alpha * di * z[j]
+            if i == j:
+                val -= di
+            Ainv[i, j] = val
+    return Ainv
+
+
+@njit(parallel=True, cache=True)
+def batch_invA(kappas: np.ndarray, lambdas_all: np.ndarray, w_all: np.ndarray):
+    """
+    kappas: shape (N,)
+    lambdas_all: shape (N,3)
+    w_all: shape (N,3)
+    returns: shape (N,3,3)
+    """
+    N, d = w_all.shape
+    out = np.empty((N,d,d), dtype=np.float64)
+    for i in prange(N):
+        out[i] = invA_rank1_numba_general(kappas[i], lambdas_all[i], w_all[i])
+    return out

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

@@ -6,13 +6,14 @@ from scipy.linalg import expm
 from numba import njit
 from numba import njit, objmode
 
-# from stochvolmodels.examples.run_pricing_options_on_qvar import nb_path
+from stochvolmodels.pricers.rough_logsv.expm import batch_expA, batch_invA
 
 
 # from stochvolmodels.utils.config import VariableType
 # from RoughKernel import european_rule
 # from stochvolmodels.pricers.logsv_pricer import LogSvParams
 
+
 @njit(cache=False, fastmath=True)
 def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
                     z0: np.ndarray, weight: np.ndarray, h: float):
@@ -22,7 +23,7 @@ def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: flo
     ----------
     nodes : (fixed argument) exponents x_i, array of size (n,)
     v0 : (fixed argument) array of size (n, nb_path)
-    theta : long-run level, scaled by lambda, scalar
+    theta : long-run level, scalar
     kappa1 : linear mean-reversion speed, scalar
     kappa2 : quadratic mean-reversion speed, scalar
     z0 : initial values, array of size (n, nb_path)
@@ -34,16 +35,32 @@ def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: flo
     Array of size (n, nb_path)
     """
     assert nodes.shape == v0.shape == z0.shape == weight.shape
-    n = weight.shape[0]
+    n = z0.shape[0]
     z0w = np.sum(weight * z0, axis=0)
+    g0 = (kappa1 + kappa2*z0w)*(theta-z0w)
+    k1 = -nodes * (z0 - v0)
+    for j in range(n):
+        k1[j] += g0
+    k1 *= 0.5 * h
+
+    zmid = z0 + k1
+    zmidw = np.sum(weight * zmid, axis=0)
+    gmid = (kappa1 + kappa2 * zmidw) * (theta - zmidw)
+    k2 = -nodes * (zmid - v0)
+    for j in range(n):
+        k2[j] += gmid
+    k2 *= h
+    Dzh = z0 + k2
 
     # s1 = -nodes[:, None] * (z0 - v0) * h + (kappa1 + kappa2 * z0w) * (theta - z0w) * h
     # s2 = -nodes[:, None] * (z0 + 0.5 * s1 - v0) * h + (kappa1 + kappa2 * (z0w + 0.5 * s1)) * (theta - (z0w + 0.5 * s1)) * h
     # Dzh = z0 + s2
 
-    z1 =  -nodes * (z0 - v0) * h + (kappa1 + kappa2 * z0w) * (theta - z0w) * h
-    z2 = -nodes * (z0 + 0.5 * z1 - v0) * h + (kappa1 + kappa2 * (z0w + 0.5 * z1)) * (theta - (z0w + 0.5 * z1)) * h
-    Dzh = z0 + z2
+
+
+    # z1 =  -nodes * (z0 - v0) * h + (kappa1 + kappa2 * z0w) * (theta - z0w) * h
+    # z2 = -nodes * (z0 + 0.5 * z1 - v0) * h + (kappa1 + kappa2 * (z0w + 0.5 * z1)) * (theta - (z0w + 0.5 * z1)) * h
+    # Dzh = z0 + z2
 
     # lamda_vec = np.repeat(lamda, n)
     # theta_vec = np.repeat(theta, n)[:, None]
@@ -57,6 +74,124 @@ def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: flo
 
     return Dzh
 
+
+@njit(cache=False, fastmath=True)
+def drift_ode_solve2(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
+                    z0: np.ndarray, weight: np.ndarray, h: float):
+    """
+
+    Parameters
+    ----------
+    nodes : (fixed argument) exponents x_i, array of size (n,)
+    v0 : (fixed argument) array of size (n, nb_path)
+    theta : long-run level, scalar
+    kappa1 : linear mean-reversion speed, scalar
+    kappa2 : quadratic mean-reversion speed, scalar
+    z0 : initial values, array of size (n, nb_path)
+    weight : wieghts, array of size (n, )
+    h : step size
+
+    Returns
+    -------
+    Array of size (n, nb_path)
+    """
+    assert nodes.shape == v0.shape == z0.shape == weight.shape
+    n, nb_path = weight.shape
+
+    # --- k1 ---
+    z0w = np.sum(weight * z0, axis=0)
+    c1 = (kappa1 + kappa2 * z0w) * (theta - z0w)
+    s1 = -nodes * (z0 - v0) + c1
+
+    # --- k2 ---
+    z_tmp = z0 + 0.5 * h * s1
+    z1w = np.sum(weight * z_tmp, axis=0)
+    c2 = (kappa1 + kappa2 * z1w) * (theta - z1w)
+    s2 = -nodes * (z_tmp - v0) + c2
+
+    # --- k3 ---
+    z_tmp = z0 + 0.5 * h * s2
+    z2w = np.sum(weight * z_tmp, axis=0)
+    c3 = (kappa1 + kappa2 * z2w) * (theta - z2w)
+    s3 = -nodes * (z_tmp - v0) + c3
+
+    # --- k4 ---
+    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 / 6.0) * (s1 + 2.0 * s2 + 2.0 * 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):
+    """
+
+    Parameters
+    ----------
+    nodes : (fixed argument) exponents x_i, array of size (n,)
+    v0 : (fixed argument) array of size (n, nb_path)
+    theta : long-run level, scalar
+    kappa1 : linear mean-reversion speed, scalar
+    kappa2 : quadratic mean-reversion speed, scalar
+    z0 : initial values, array of size (n, nb_path)
+    weight : wieghts, array of size (n, )
+    h : step size
+
+    Returns
+    -------
+    Array of size (n, nb_path)
+    """
+    assert nodes.shape == v0.shape == z0.shape == weight.shape
+    n, nb_path = weight.shape
+    z0w = np.sum(weight * z0, axis=0)
+    kappa = kappa1 + kappa2 * z0w
+
+    b_ = np.zeros((nb_path, n))
+    for k in range(n):
+        b_[:, k] = kappa * theta + nodes[k] * v0[k]
+
+    eAh = batch_expA(kappa, nodes.T * h, weight.T * h)
+    I = np.identity(n)
+    invA = batch_invA(kappa, nodes.T, weight.T)
+    tmp2 = np.zeros((nb_path, n, n))
+    for i in range(n):
+        for j in range(n):
+            for k in range(n):
+                tmp2[:,i,j] += invA[:,i,k] * (eAh[:, k, j] - I[k,j])
+
+    Dzh_v1 = np.zeros((nb_path, n))
+    for i in range(n):
+        for j in range(n):
+            Dzh_v1[:, i] += eAh[:, i, j] * z0[j, :] + tmp2[:, i, j] * b_[:, j]
+    # for p in range(nb_path):
+    #     Dzh_v1[p] = eAh[p] @ z0[..., p] + tmp2[p] @ b_[p]
+
+    # def ff2():
+    #     lamda = kappa1 + kappa2 * z0w
+    #     coeff0_vec = np.repeat(kappa1 * theta, n)
+    #     Dzh_v2 = np.zeros_like(z0)
+    #     for p in range(nb_path):
+    #         diag_x = np.diag(nodes[:, p])
+    #         lamda_vec = np.repeat(lamda[p], n)
+    #         A = -np.outer(lamda_vec, weight[:, p]) - diag_x  # matrix of size (n,n)
+    #         b = coeff0_vec + diag_x @ v0[:, p]
+    #         eAh_v2 = expm(A * h)
+    #         Dzh_v2[:, p] = eAh_v2 @ z0[:, p] + (np.linalg.inv(A) @ (eAh_v2 - I)) @ b
+    #
+    #     return Dzh_v2
+    #
+    # Dzh_v2 = ff2()
+    # diff = np.linalg.norm(Dzh_v2-Dzh_v1.T)
+    # assert diff < 1e-12
+
+    return Dzh_v1.T
+
+
 @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):
@@ -101,9 +236,9 @@ def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1:
     -------
 
     """
-    D_inn = drift_ode_solve(nodes, v0, theta, kappa1, kappa2, v_init, weight, 0.5 * h)
+    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)
-    sol = drift_ode_solve(nodes, v0, theta, kappa1, kappa2, S_inn, weight, 0.5 * h)
+    sol = drift_ode_solve2(nodes, v0, theta, kappa1, kappa2, S_inn, weight, 0.5 * h)
 
     return sol
 
@@ -124,6 +259,9 @@ def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
     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)
+    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
 
     wlam = weight * nodes
     vw = np.sum(weight * v, axis=0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.4
+Version: 1.1.6
 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>

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

@@ -47,6 +47,7 @@ stochvolmodels/data/fetch_option_chain.py
 stochvolmodels/data/option_chain.py
 stochvolmodels/data/test_option_chain.py
 stochvolmodels/examples/quick_run_lognormal_sv_pricer.py
+stochvolmodels/examples/run_hawkes_pricer.py
 stochvolmodels/examples/run_heston.py
 stochvolmodels/examples/run_heston_sv_pricer.py
 stochvolmodels/examples/run_lognormal_sv_pricer.py
@@ -76,6 +77,7 @@ stochvolmodels/pricers/logsv/affine_expansion.py
 stochvolmodels/pricers/logsv/logsv_params.py
 stochvolmodels/pricers/logsv/vol_moments_ode.py
 stochvolmodels/pricers/rough_logsv/RoughKernel.py
+stochvolmodels/pricers/rough_logsv/expm.py
 stochvolmodels/pricers/rough_logsv/split_simulation.py
 stochvolmodels/pricers/rough_logsv/test_kernel_approx.py
 stochvolmodels/tests/__init__.py