stochvolmodels 1.1.2__tar.gz → 1.1.3__tar.gz

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/.gitignore

@@ -131,3 +131,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+/resources
+/volatility_book

{stochvolmodels-1.1.2/stochvolmodels.egg-info → stochvolmodels-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.2
+Version: 1.1.3
 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>
@@ -1144,3 +1144,17 @@ Special thanks to co-authors and collaborators:
 - Alexander Lipton
 
 For additional research and advanced analytics, see the companion modules and papers included in this package.
+
+## BibTeX Citations for StochVolModels (Stochastic Volatility Models) Package
+
+If you use StochVolModels in your research, please cite it as:
+
+```bibtex
+@software{stochvolmodels2024,
+  author={Sepp, Artur},
+  title={StochVolModels: Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models},
+  year={2024},
+  url={https://github.com/ArturSepp/StochVolModels},
+}
+```
+

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/README.md

@@ -391,4 +391,18 @@ Special thanks to co-authors and collaborators:
 - Vladimir Lucic
 - Alexander Lipton
 
-For additional research and advanced analytics, see the companion modules and papers included in this package.
+For additional research and advanced analytics, see the companion modules and papers included in this package.
+
+## BibTeX Citations for StochVolModels (Stochastic Volatility Models) Package
+
+If you use StochVolModels in your research, please cite it as:
+
+```bibtex
+@software{stochvolmodels2024,
+  author={Sepp, Artur},
+  title={StochVolModels: Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models},
+  year={2024},
+  url={https://github.com/ArturSepp/StochVolModels},
+}
+```
+

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stochvolmodels"
-version = "1.1.2"
+version = "1.1.3"
 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.2 → stochvolmodels-1.1.3}/stochvolmodels/examples/run_lognormal_sv_pricer.py

@@ -4,8 +4,12 @@ run few unit test to illustrate implementation of log-normal sv model analytics
 
 import numpy as np
 import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import matplotlib.ticker as mticker
 from enum import Enum
 import stochvolmodels as sv
+from stochvolmodels.utils import plots as plot
 from stochvolmodels import LogSVPricer, LogSvParams, OptionChain, LogsvModelCalibrationType
 
 
@@ -22,6 +26,7 @@ class LocalTests(Enum):
     BENCHM_ROUGH_PRICER = 10
 
 
+
 def run_local_test(local_test: LocalTests):
     """Run local tests for development and debugging purposes.
 
@@ -160,23 +165,23 @@ def run_local_test(local_test: LocalTests):
         print(option_prices_ttm)
 
     elif local_test == LocalTests.BENCHM_ROUGH_PRICER:
-        btc_option_chain = OptionChain.get_uniform_chain(ttms=np.array([0.083, 0.25]),
-                                                     ids=np.array(['1m', '3m']),
-                                                     strikes=np.linspace(0.5, 1.5, 21))
-        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
-        nb_path = 100000
-        H = 0.3
-        N = 3
+        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
+        N = 2
+        seed = 1
 
         def rough_vol():
             params1 = LogSvParams.copy(params0)
-            params1.H = 0.3
+            params1.H = H
             params1.approximate_kernel(T=btc_option_chain.ttms[-1], N=N)
 
             Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(ttms=btc_option_chain.ttms,
                                                                              nb_path=nb_path,
                                                                              nb_steps_per_year=360,
-                                                                             seed=10)
+                                                                             seed=seed)
 
 
             option_prices_ttm, option_std_ttm = sv.rough_logsv_mc_chain_pricer_fixed_randoms(ttms=btc_option_chain.ttms,
@@ -228,16 +233,28 @@ def run_local_test(local_test: LocalTests):
         ivols_logsv = regular_vol()
 
         nb_slices = btc_option_chain.ttms.size
-        fig, axs = plt.subplots(1, nb_slices, figsize=(4*nb_slices, 3), tight_layout=True)
+        assert nb_slices == 4
+
+        with sns.axes_style('darkgrid'):
+            fig, axs = plt.subplots(2, 2, figsize=(15, 9), tight_layout=True)
+        axs = plot.to_flat_list(axs)
 
         for i in range(nb_slices):
-            ax = axs[i] if nb_slices>1 else axs
-            ax.plot(btc_option_chain.strikes_ttms[i], ivols_logsv[i], label="LOG_SV", marker="*")
-            ax.plot(btc_option_chain.strikes_ttms[i], ivols_rough_logsv[i], label="ROUGH_LOG_SV", marker="o")
+            data = pd.DataFrame({"Rough Log-SV": ivols_rough_logsv[i],
+                                 "Log-SV": ivols_logsv[i]},
+                                index=np.log(
+                                    btc_option_chain.strikes_ttms[i] / btc_option_chain.forwards[i]))
+            ax = axs[i]
+            sns.lineplot(data, ax=ax, markers=["o"])
             ax.set_title("Expiry: " + btc_option_chain.ids[i])
+            ax.yaxis.set_major_formatter(mticker.FuncFormatter(lambda z, _: '{:.0%}'.format(z)))
+            ax.xaxis.set_major_formatter(mticker.FuncFormatter(lambda z, _: '{:.2f}'.format(z)))
             ax.legend()
-        fig.suptitle(f"Conventional LogSV model vs Rough LogSV, H={H:.2f} via {N}f Markovian approximation",
-                     color="darkblue")
+        fig.suptitle(f"Conventional LogSV model vs Rough LogSV, H={H:.2f} via {N}f Markovian approximation\n"
+                     f"{params0.to_str()}",
+                     color = "darkblue", fontsize = 14)
+
+        # fig.savefig("c:/temp/rough_vs_conven_vol.pdf")
 
     elif local_test == LocalTests.CALIBRATE_MODEL_TO_BTC_OPTIONS:
         btc_option_chain = sv.get_btc_test_chain_data()

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/stochvolmodels/pricers/logsv/logsv_params.py

@@ -35,7 +35,10 @@ class LogSvParams(ModelParams):
 
     def approximate_kernel(self, T: float, N: int):
         assert 1 <= N <= 5  # not keen to use large N
-        if N > 1 and self.H<0.49:
+        if self.H >= 0.4:
+            N = N if N<=2 else 2
+            self.nodes, self.weights = european_rule(self.H, N, T)
+        elif N > 1 and self.H<0.49:
             self.nodes, self.weights = european_rule(self.H, N, T)
         else:
             self.weights = np.array([1.0])

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/stochvolmodels/pricers/logsv_pricer.py

@@ -703,7 +703,7 @@ def simulate_logsv_x_vol_terminal(ttm: float,
         assert sigma0.shape[0] == nb_path
     if W0 is None and W1 is None:
         nb_steps1, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=nb_steps_per_year)
-        print(f"nb_steps1={nb_steps1}, dt={dt}")
+        # print(f"nb_steps1={nb_steps1}, dt={dt}")
         sdt = np.sqrt(dt)
         W0_ = sdt * np.random.normal(0, 1, size=(nb_steps1, nb_path))
         W1_ = sdt * np.random.normal(0, 1, size=(nb_steps1, nb_path))
@@ -760,7 +760,7 @@ def get_randoms_for_rough_vol_chain_valuation(ttms: np.ndarray,
                                     nb_steps_per_year: int = 360,
                                     seed: int = 10
                                     ) -> Tuple[np.ndarray, np.ndarray, List[np.ndarray]]:
-    set_seed(seed)
+    np.random.seed(seed)
     grid_ttms = List()
     nb_steps_ttms = np.zeros_like(ttms).astype(int)
     for i, ttm in enumerate(ttms):
@@ -856,13 +856,11 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
                                               variable_type: VariableType = VariableType.LOG_RETURN
                                               ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
     assert weights.shape == nodes.shape and weights.ndim == 1
-    assert kappa2 == 0.0
+    # assert kappa2 == 0.0
     N = nodes.size
     v0 = sigma0 / np.sum(weights) * np.ones((N,))
 
     # need to redenote coefficients
-    lamda = kappa1
-    theta = kappa1 * theta
     volvol = np.sqrt(beta ** 2 + orthog_vol ** 2)
     rho = beta / volvol
 
@@ -882,8 +880,10 @@ def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
         nb_steps = timegrid.size - 1
         Z0_ = Z0[:nb_steps]
         Z1_ = Z1[:nb_steps]
-        log_spot_str, vol_str, qv_str = log_spot_full_combined(nodes, weights, v0_vec, theta, lamda, log_s0, v_init,
-                                                               rho, volvol, timegrid, nb_path, Z0_, Z1_)
+        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)}")
         print(f"Mean spot Strand: {np.mean(np.exp(log_spot_str))}")
 

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/stochvolmodels/pricers/rough_logsv/split_simulation.py

@@ -14,7 +14,7 @@ from numba import njit, objmode
 # from stochvolmodels.pricers.logsv_pricer import LogSvParams
 
 @njit(cache=False, fastmath=True)
-def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda: float,
+def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, kappa1: float, kappa2: float,
                     z0: np.ndarray, weight: np.ndarray, h: float):
     """
 
@@ -23,7 +23,8 @@ def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda: floa
     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
-    lamda : mean-reversion speed, 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
@@ -32,30 +33,39 @@ def drift_ode_solve(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda: floa
     -------
     Array of size (n, nb_path)
     """
-    assert nodes.shape == v0.shape[:-1] == z0.shape[:-1] == weight.shape
-    n = weight.size
-    lamda_vec = np.repeat(lamda, n)
-    theta_vec = np.repeat(theta, n)[:, None]
-    diag_x = np.diag(nodes)
-    I = np.identity(n)
-    A = -np.outer(lamda_vec, weight) - diag_x  # matrix of size (n, n)
-    b = theta_vec + diag_x @ v0  # vector of size (n, nb_path)
-    with objmode(eAh='float64[:, ::1]'):
-        eAh = expm(A * h)
-    Dzh = eAh @ z0 + (np.linalg.inv(A) @ (eAh - I)) @ b  # vector of size (n, nb_path)
+    assert nodes.shape == v0.shape == z0.shape == weight.shape
+    n = weight.shape[0]
+    z0w = np.sum(weight * z0, axis=0)
+
+    # 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
+
+    # lamda_vec = np.repeat(lamda, n)
+    # theta_vec = np.repeat(theta, n)[:, None]
+    # diag_x = np.diag(nodes)
+    # I = np.identity(n)
+    # A = -np.outer(lamda_vec, weight) - diag_x  # matrix of size (n, n)
+    # b = theta_vec + diag_x @ v0  # vector of size (n, nb_path)
+    # # with objmode(eAh='float64[:, ::1]'):
+    # eAh = expm(A * h)
+    # Dzh = eAh @ z0 + (np.linalg.inv(A) @ (eAh - I)) @ b  # vector of size (n, nb_path)
 
     return Dzh
 
 @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[:-1] == weight.shape and y0.shape[-1] == nb_path
+    assert y0.shape == weight.shape  and y0.shape[-1] == nb_path
     assert z_rand.shape == (nb_path,)
-    n = weight.size
-    weight_sum = np.sum(weight)
+    weight_sum = np.sum(weight, axis=0)
     volvol_ = volvol * weight_sum
 
-    yw = np.dot(weight, y0)
+    yw = np.sum(weight * y0, axis=0)
 
     dW = z_rand * np.sqrt(h)
     Yh = yw * np.exp(-0.5 * volvol_ ** 2 * h + volvol_ * dW)
@@ -68,7 +78,7 @@ 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, lamda: float,
+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):
     """
@@ -78,7 +88,8 @@ def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda:
     nodes : exponents x_i, array of size (n,)
     v0 : (fixed argument) array of size (n, nb_path)
     theta : long-run level, scaled by lambda, scalar
-    lamda : mean-reversion speed, scalar
+    kappa1 : linear mean-reversion speed, scalar
+    kappa2 : quadratic mean-reversion speed, scalar
     volvol :  total volatility. in other words, vartheta. scalar
     v_init :  initial values, array of size (n, nb_path)
     weight :  (fixed argument) wieghts, array of size (n, )
@@ -90,9 +101,9 @@ def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda:
     -------
 
     """
-    D_inn = drift_ode_solve(nodes, v0, theta, lamda, v_init, weight, 0.5 * h)
+    D_inn = drift_ode_solve(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, lamda, S_inn, weight, 0.5 * h)
+    sol = drift_ode_solve(nodes, v0, theta, kappa1, kappa2, S_inn, weight, 0.5 * h)
 
     return sol
 
@@ -100,33 +111,41 @@ def drift_diffus_strand(nodes: np.ndarray, v0: np.ndarray, theta: float, lamda:
 @njit(cache=False, fastmath=True)
 def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
                          v0: np.ndarray, y0: np.ndarray,
-                         theta: float, lamda: float, log_s: np.ndarray, v: np.ndarray, y: 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 == 1
-    assert v.shape[:-1] == weight.shape and v.shape[-1] == nb_path
+    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[:-1] == weight.shape and v0.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,)
 
-    vol_h = drift_diffus_strand(nodes, v0, theta, lamda, volvol, v, weight, h, nb_path, z0)
+    vol_h = drift_diffus_strand(nodes, v0, theta, kappa1, kappa2, volvol, v, weight, h, nb_path, z0)
 
-    ww = weight[None, :]
-    wlam = (weight * nodes)[None, :]
-    vw = ww @ v
-    volw_h = ww @ vol_h
-    w_inv = 1.0 / np.sum(weight)
+    wlam = weight * nodes
+    vw = np.sum(weight * v, axis=0)
+    volw_h = np.sum(weight * vol_h, axis=0)
+    w_inv = 1.0 / np.sum(weight, axis=0)
 
     c1 = 0.5
     c2 = 0.5
     rho_comp = np.sqrt(1.0 - rho * rho)
 
-    term1 = 1.0 / volvol * ((volw_h - vw + c1 * h * wlam @ v + c2 * h * wlam @ vol_h - wlam @ v0 * h) * w_inv
-                            - theta * h + lamda * c1 * h * vw + lamda * c2 * h * volw_h)
-    term2 = c1 * h * np.square(vw) + c2 * h * np.square(volw_h)
+    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)
+    w_lam_v0 = np.sum(wlam * v0, axis=0)
+
+    term1 = 1.0 / 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 - 0.5 * term2 + rho * term1 + rho_comp * np.sqrt(term2) * z1
 
     y_h = y + 0.5 * h * (vw * vw + volw_h * volw_h)  # don't need it but keep for plotting
@@ -136,12 +155,12 @@ def log_spot_full_solve2(nodes: np.ndarray, weight: np.ndarray,
 @njit(cache=False, fastmath=True)
 def log_spot_full_combined(nodes: np.ndarray, weight: np.ndarray,
                            v0: np.ndarray,
-                           theta: float, lamda: float, log_s0: float, v_init: 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)
+    # 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)
 
     y0 = np.zeros((1, nb_path))
 
@@ -152,7 +171,7 @@ def log_spot_full_combined(nodes: np.ndarray, weight: np.ndarray,
     # 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(nodes, weight, v0, y0, theta, lamda,
+        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])
 

stochvolmodels-1.1.3/stochvolmodels/pricers/rough_logsv/test_kernel_approx.py

@@ -0,0 +1,16 @@
+import numpy as np
+from stochvolmodels import LogSvParams
+
+if __name__ == "__main__":
+    H = 0.4464700054758044
+    N = 2
+    T = 1.
+
+    params0 = LogSvParams(sigma0 = 1.32, theta=0.47, kappa1=4.0, kappa2=2.0, beta=0.45, volvol=0.83)
+    for N in [1, 2, 3]:
+        for H in np.linspace(0.3, 0.49, 150):
+            params0.H = H
+            print(f" *** N={N}, H={H} *** ")
+            params0.approximate_kernel(T=T, N=N)
+            print(params0.weights)
+            print(params0.nodes)

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3/stochvolmodels.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stochvolmodels
-Version: 1.1.2
+Version: 1.1.3
 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>
@@ -1144,3 +1144,17 @@ Special thanks to co-authors and collaborators:
 - Alexander Lipton
 
 For additional research and advanced analytics, see the companion modules and papers included in this package.
+
+## BibTeX Citations for StochVolModels (Stochastic Volatility Models) Package
+
+If you use StochVolModels in your research, please cite it as:
+
+```bibtex
+@software{stochvolmodels2024,
+  author={Sepp, Artur},
+  title={StochVolModels: Python implementation of pricing analytics and Monte Carlo simulations for stochastic volatility models},
+  year={2024},
+  url={https://github.com/ArturSepp/StochVolModels},
+}
+```
+

{stochvolmodels-1.1.2 → stochvolmodels-1.1.3}/stochvolmodels.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ stochvolmodels/pricers/logsv/logsv_params.py
 stochvolmodels/pricers/logsv/vol_moments_ode.py
 stochvolmodels/pricers/rough_logsv/RoughKernel.py
 stochvolmodels/pricers/rough_logsv/split_simulation.py
+stochvolmodels/pricers/rough_logsv/test_kernel_approx.py
 stochvolmodels/tests/__init__.py
 stochvolmodels/tests/bsm_mgf_pricer.py
 stochvolmodels/tests/qv_pricer.py