stochvolmodels 1.0.25__tar.gz → 1.0.27__tar.gz

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: stochvolmodels
-Version: 1.0.25
+Version: 1.0.27
 Summary: Implementation of stochastic volatility models for option pricing
 License: LICENSE.txt
 Keywords: volatility,options,Black-Scholes,Heston,Monte-Carlo
@@ -32,7 +32,6 @@ Requires-Dist: numpy (>=1.22.4)
 Requires-Dist: pandas (>=0.19)
 Requires-Dist: scipy (>=1.3)
 Requires-Dist: seaborn (>=0.11.2)
-Requires-Dist: statsmodels (>=0.13.0)
 Project-URL: Documentation, https://github.com/ArturSepp/StochVolModels
 Project-URL: Issues, https://github.com/ArturSepp/StochVolModels/issues
 Project-URL: Personal website, https://artursepp.com
@@ -75,6 +74,19 @@ Close using
 git clone https://github.com/ArturSepp/StochVolModels.git
 ```
 
+Core dependencies:
+    python = ">=3.8",
+    numba = ">=0.56.4",
+    numpy = ">=1.22.4",
+    scipy = ">=1.10",
+    pandas = ">=2.2.0",
+    matplotlib = ">=3.2.2",
+    seaborn = ">=0.12.2"
+
+Optional dependencies:
+    qis ">=2.1.38" (for running code in my_papers and volatility_book)
+
+
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/README.md

@@ -34,6 +34,19 @@ Close using
 git clone https://github.com/ArturSepp/StochVolModels.git
 ```
 
+Core dependencies:
+    python = ">=3.8",
+    numba = ">=0.56.4",
+    numpy = ">=1.22.4",
+    scipy = ">=1.10",
+    pandas = ">=2.2.0",
+    matplotlib = ">=3.2.2",
+    seaborn = ">=0.12.2"
+
+Optional dependencies:
+    qis ">=2.1.38" (for running code in my_papers and volatility_book)
+
+
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.25"
+version = "1.0.27"
 description = "Implementation of stochastic volatility models for option pricing"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]
@@ -37,7 +37,6 @@ python = ">=3.8"
 numba = ">=0.55"
 numpy = ">=1.22.4"
 scipy = ">=1.3"
-statsmodels = ">=0.13.0"
 pandas = ">=0.19"
 matplotlib = ">=3.5.2"
 seaborn = ">=0.11.2"
@@ -45,5 +44,3 @@ seaborn = ">=0.11.2"
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
-
-

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/__init__.py

@@ -22,7 +22,8 @@ from stochvolmodels.utils.funcs import (
     to_flat_np_array,
     update_kwargs,
     ncdf,
-    npdf
+    npdf,
+    find_nearest
 )
 
 from stochvolmodels.pricers.analytic.bsm import (
@@ -105,14 +106,16 @@ from stochvolmodels.pricers.logsv_pricer import (
     LOGSV_BTC_PARAMS,
     LogSVPricer,
     LogsvModelCalibrationType,
-    ConstraintsType
+    ConstraintsType,
+    CalibrationEngine,
+    get_randoms_for_chain_valuation,
+    logsv_mc_chain_pricer_fixed_randoms
 )
 from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
 
 from stochvolmodels.pricers.gmm_pricer import (
     GmmParams,
-    GmmPricer,
-    plot_gmm_pdfs
+    GmmPricer
 )
 
 from stochvolmodels.pricers.tdist_pricer import (

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/data/option_chain.py

@@ -8,16 +8,15 @@ data is provided as:
 from __future__ import annotations
 
 import numpy as np
+import pandas as pd
 from dataclasses import dataclass
 from typing import Tuple, Optional
-
-import pandas as pd
 from numba.typed import List
 
 import stochvolmodels.pricers.analytic.bsm as bsm
-from  stochvolmodels.utils.var_swap_pricer import compute_var_swap_strike
-from stochvolmodels.pricers.factor_hjm.rate_core import get_default_swap_term_structure, swap_rate
 import stochvolmodels.pricers.analytic.bachelier as bachel
+from stochvolmodels.utils.var_swap_pricer import compute_var_swap_strike
+from stochvolmodels.pricers.factor_hjm.rate_core import get_default_swap_term_structure, swap_rate
 
 
 @dataclass

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/examples/run_heston_sv_pricer.py

@@ -1,8 +1,6 @@
 
 import numpy as np
 import matplotlib.pyplot as plt
-from enum import Enum
-
 import stochvolmodels as sv
 from stochvolmodels import HestonPricer, HestonParams, OptionChain, BTC_HESTON_PARAMS
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/examples/run_lognormal_sv_pricer.py

@@ -17,6 +17,8 @@ class UnitTests(Enum):
     COMPARE_MODEL_VOLS_TO_MC = 4
     PLOT_FIT_TO_BITCOIN_OPTION_CHAIN = 5
     CALIBRATE_MODEL_TO_BTC_OPTIONS = 6
+    MC_WITH_FIXED_RANDOMS = 7
+    CALIBRATE_MODEL_TO_BTC_OPTIONS_WITH_MC = 8
 
 
 def run_unit_test(unit_test: UnitTests):
@@ -105,12 +107,57 @@ def run_unit_test(unit_test: UnitTests):
         print(btc_calibrated_params)
         logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
                                                  params=btc_calibrated_params)
+
+    elif unit_test == UnitTests.MC_WITH_FIXED_RANDOMS:
+        btc_option_chain = sv.get_btc_test_chain_data()
+        W0s, W1s, dts = sv.get_randoms_for_chain_valuation(ttms=btc_option_chain.ttms,
+                                                           nb_path=10000,
+                                                           nb_steps_per_year=360,
+                                                           seed=10)
+        print(dts)
+        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
+        vol_backbone_etas = params.get_vol_backbone_etas(ttms=btc_option_chain.ttms)
+        args = dict(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,
+                    W0s=W0s,
+                    W1s=W1s,
+                    dts=dts,
+                    v0=params0.sigma0,
+                    theta=params0.theta,
+                    kappa1=params0.kappa1,
+                    kappa2=params0.kappa2,
+                    beta=params0.beta,
+                    volvol=params0.volvol,
+                    vol_backbone_etas=vol_backbone_etas)
+        option_prices_ttm, option_std_ttm = sv.logsv_mc_chain_pricer_fixed_randoms(**args)
+        print(option_prices_ttm)
+
+        option_prices_ttm, option_std_ttm = sv.logsv_mc_chain_pricer_fixed_randoms(**args)
+        print(option_prices_ttm)
+
+    elif unit_test == UnitTests.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=2.18, beta=0.15, volvol=2.0)
+        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.MC,
+                                                                             nb_path=100000,
+                                                                             seed=7)
+        print(btc_calibrated_params)
+        logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
+                                                 params=btc_calibrated_params)
+
     plt.show()
 
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.COMPUTE_MODEL_PRICES
+    unit_test = UnitTests.CALIBRATE_MODEL_TO_BTC_OPTIONS_WITH_MC
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/examples/run_pricing_options_on_qvar.py

@@ -3,7 +3,6 @@ run valuation for options on quadratic variance
 """
 import numpy as np
 import matplotlib.pyplot as plt
-import qis as qis
 import stochvolmodels.data.test_option_chain as chains
 from numba.typed import List
 from stochvolmodels import (LogSVPricer, LogSvParams, compute_analytic_qvar, OptionChain,
@@ -37,7 +36,7 @@ fig1 = logsv_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                            params=LOGSV_BTC_PARAMS,
                                            variable_type=VariableType.Q_VAR,
                                            nb_path=nb_path)
-qis.set_suptitle(fig1, title='Implied variance skew by Log-Normal SV model')
+fig1.suptitle('Implied variance skew by Log-Normal SV model')
 
 # run Heston prices
 heston_pricer = HestonPricer()
@@ -45,7 +44,7 @@ fig2 = heston_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                             params=BTC_HESTON_PARAMS,
                                             variable_type=VariableType.Q_VAR,
                                             nb_path=nb_path)
-qis.set_suptitle(fig2, title='Implied variance skew by Heston SV model')
+fig2.suptitle('Implied variance skew by Heston SV model')
 
 
 plt.show()

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/factor_hjm/rate_logsv_pricer.py

@@ -877,7 +877,7 @@ def simulate_logsv_MF(ttms: np.ndarray,
     if seed is None:
         seed = 16
     np.random.seed(seed)  # fix seed
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps=int(np.ceil(year_days*ttm)))
+    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=360)
     if W is None:
         W0 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path, basis.get_nb_factors()))  # TODO: undo
         W1 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))  # TODO: undo
@@ -1017,7 +1017,7 @@ def simulate_logsv_futures_MF2(params: MultiFactRateLogSvParams,
     if seed is None:
         seed = 16
     np.random.seed(seed)  # fix seed
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, year_days=720)
+    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=720)
     if W is None:
         W0 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path, basis.get_nb_factors()))  # TODO: undo
         W1 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))  # TODO: undo

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/gmm_pricer.py

@@ -4,16 +4,12 @@ implementation of gaussian mixture pricer and calibration
 import numpy as np
 import matplotlib.pyplot as plt
 from dataclasses import dataclass
-
-import pandas as pd
-import qis as qis
-import seaborn as sns
 from scipy.optimize import minimize
 from numba import njit
 from numba.typed import List
 from typing import Tuple
 from enum import Enum
-
+# project
 import stochvolmodels.pricers.analytic.bsm as bsm
 from stochvolmodels.utils.funcs import to_flat_np_array, timer, npdf
 from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
@@ -263,56 +259,6 @@ def gmm_vanilla_chain_pricer(gmm_weights: np.ndarray,
     return model_prices_ttms
 
 
-def plot_gmm_pdfs(params: GmmParams,
-                  option_chain0: OptionChain,
-                  nstdev: float = 10.0,
-                  titles: List[str] = None,
-                  axs: List[plt.Subplot] = None
-                  ) -> plt.Figure:
-    """
-    plot gmm pdf and model fit
-    """
-    stdev = nstdev * params.get_get_avg_vol() * np.sqrt(params.ttm)
-    x = np.linspace(-stdev, stdev, 3000)
-    state_pdfs, agg_pdf = params.compute_state_pdfs(x=x)
-
-    columns = []
-    for idx in range(len(params.gmm_weights)):
-        columns.append(
-            f"state-{idx + 1}: mean={params.gmm_mus[idx]:0.2f}, vol={params.gmm_vols[idx]:0.2f}, weight={params.gmm_weights[idx]:0.2f}")
-
-    state_pdfs = pd.DataFrame(state_pdfs, index=x, columns=columns)
-    agg_pdf = pd.Series(agg_pdf, index=x, name='Aggregate PDF')
-    df = pd.concat([agg_pdf, state_pdfs], axis=1)
-
-    kwargs = dict(fontsize=14, framealpha=0.80)
-
-    if axs is None:
-        with sns.axes_style("darkgrid"):
-            fig, axs = plt.subplots(1, 2, figsize=(16, 4.5))
-    else:
-        fig = None
-
-    qis.plot_line(df=df,
-                  linestyles=['--'] + ['-'] * len(params.gmm_weights),
-                  y_limits=(0.0, None),
-                  xvar_format='{:,.2f}',
-                  xlabel='log-price',
-                  first_color_fixed=True,
-                  ax=axs[0],
-                  **kwargs)
-    axs[0].get_lines()[0].set_linewidth(4.0)
-    axs[0].get_legend().get_lines()[0].set_linewidth(4.0)
-    qis.set_title(ax=axs[0], title='(A) State PDF and Aggregate Risk-Neutral PDF', **kwargs)
-
-    gmm_pricer = GmmPricer()
-    gmm_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain0, params=params,
-                                           is_log_strike_xaxis=True,
-                                           axs=[axs[1]],
-                                           **kwargs)
-    return fig
-
-
 class UnitTests(Enum):
     CALIBRATOR = 1
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/hawkes_jd_pricer.py

@@ -696,7 +696,7 @@ def simulate_hawkesjd_terminal(ttm: float,
         assert lambda_m0.shape[0] == nb_path
 
     # vars
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps=int(5*360))  # need small dt step for large intensities
+    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=5*360)  # need small dt step for large intensities
     W0 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))
     U_P = -np.log(np.random.uniform(low=1e-16, high=1.0, size=(nb_steps, nb_path)))/dt
     U_M = -np.log(np.random.uniform(low=1e-16, high=1.0, size=(nb_steps, nb_path)))/dt

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/heston_pricer.py

@@ -298,7 +298,7 @@ def simulate_heston_x_vol_terminal(ttm: float,
                                    rho: float,
                                    volvol: float,
                                    nb_path: int = 100000,
-                                   nb_steps: int = 360
+                                   nb_steps_per_year: int = 360
                                    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
 
     if x0.shape[0] == 1:  # initial value
@@ -316,7 +316,7 @@ def simulate_heston_x_vol_terminal(ttm: float,
     else:
         assert qvar0.shape[0] == nb_path
 
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps=nb_steps)
+    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=nb_steps_per_year)
     w0 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))
     w1 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))
 
@@ -348,6 +348,7 @@ class UnitTests(Enum):
     MC_COMPARISION = 4
     MC_COMPARISION_QVAR = 5
 
+
 def run_unit_test(unit_test: UnitTests):
 
     import stochvolmodels.data.test_option_chain as chains

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/logsv/logsv_params.py

@@ -1,12 +1,13 @@
-from dataclasses import dataclass, asdict
-from typing import Optional, Dict, Any
-
+"""
+implementation of log sv params
+"""
 import numpy as np
 import pandas as pd
 from numpy import linalg as la
-from qis import find_nearest
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any
 
-from stochvolmodels import VariableType
+from stochvolmodels import VariableType, find_nearest
 from stochvolmodels.pricers.model_pricer import ModelParams
 
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/pricers/logsv_pricer.py

@@ -15,7 +15,7 @@ from enum import Enum
 from stochvolmodels.utils.config import VariableType
 import stochvolmodels.utils.mgf_pricer as mgfp
 from stochvolmodels.utils.mc_payoffs import compute_mc_vars_payoff
-from stochvolmodels.utils.funcs import to_flat_np_array, set_time_grid, timer, compute_histogram_data
+from stochvolmodels.utils.funcs import to_flat_np_array, set_time_grid, timer, compute_histogram_data, set_seed
 
 # stochvolmodels pricers
 from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
@@ -44,6 +44,11 @@ class ConstraintsType(Enum):
     INVERSE_MARTINGALE_MOMENT4 = 5  # kappa_2 >= 2.0*beta
 
 
+class CalibrationEngine(Enum):
+    ANALYTIC = 1
+    MC = 2
+
+
 LOGSV_BTC_PARAMS = LogSvParams(sigma0=0.8376, theta=1.0413, kappa1=3.1844, kappa2=3.058, beta=0.1514, volvol=1.8458)
 
 
@@ -95,7 +100,7 @@ class LogSVPricer(ModelPricer):
                                      is_spot_measure=is_spot_measure,
                                      variable_type=variable_type,
                                      nb_path=nb_path,
-                                     nb_steps=nb_steps or int(360*np.max(option_chain.ttms))+1)
+                                     nb_steps_per_year=nb_steps or int(360 * np.max(option_chain.ttms)) + 1)
 
     def set_vol_scaler(self, option_chain: OptionChain) -> float:
         """
@@ -115,6 +120,10 @@ class LogSVPricer(ModelPricer):
                                         is_unit_ttm_vega: bool = False,
                                         model_calibration_type: LogsvModelCalibrationType = LogsvModelCalibrationType.PARAMS5,
                                         constraints_type: ConstraintsType = ConstraintsType.UNCONSTRAINT,
+                                        calibration_engine: CalibrationEngine = CalibrationEngine.ANALYTIC,
+                                        nb_path: int = 100000,
+                                        nb_steps: int = 360,
+                                        seed: int = 10,
                                         **kwargs
                                         ) -> LogSvParams:
         """
@@ -169,9 +178,38 @@ class LogSVPricer(ModelPricer):
                 raise NotImplementedError(f"{model_calibration_type}")
             return fit_params
 
+        if calibration_engine == CalibrationEngine.MC:
+            W0s, W1s, dts = get_randoms_for_chain_valuation(ttms=option_chain.ttms, nb_path=nb_path, nb_steps_per_year=nb_steps, seed=seed)
+
         def objective(pars: np.ndarray, args: np.ndarray) -> float:
             params = parse_model_params(pars=pars)
-            model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, vol_scaler=vol_scaler)
+
+            if calibration_engine == CalibrationEngine.ANALYTIC:
+                model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, vol_scaler=vol_scaler)
+
+            elif calibration_engine == CalibrationEngine.MC:
+                option_prices_ttm, option_std_ttm = 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,
+                                                                                        W0s=W0s,
+                                                                                        W1s=W1s,
+                                                                                        dts=dts,
+                                                                                        v0=params.sigma0,
+                                                                                        theta=params.theta,
+                                                                                        kappa1=params.kappa1,
+                                                                                        kappa2=params.kappa2,
+                                                                                        beta=params.beta,
+                                                                                        volvol=params.volvol,
+                                                                                        vol_backbone_etas=params.get_vol_backbone_etas(ttms=option_chain.ttms))
+                model_vols = option_chain.compute_model_ivols_from_chain_data(model_prices=option_prices_ttm)
+                print(f"option_prices_ttm\n{option_prices_ttm}")
+                print(f"model_vols\n{model_vols}")
+
+            else:
+                raise NotImplementedError(f"{calibration_engine}")
+
             resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
             return resid
 
@@ -278,7 +316,7 @@ class LogSVPricer(ModelPricer):
                                              volvol=params.volvol,
                                              nb_path=nb_path,
                                              is_spot_measure=is_spot_measure,
-                                             nb_steps=nb_steps,
+                                             nb_steps_per_year=nb_steps,
                                              brownians=brownians,
                                              **kwargs)
         return sigma_t, grid_t
@@ -512,7 +550,7 @@ def logsv_mc_chain_pricer(ttms: np.ndarray,
                           vol_backbone_etas: np.ndarray,
                           is_spot_measure: bool = True,
                           nb_path: int = 100000,
-                          nb_steps: int = 360,
+                          nb_steps_per_year: int = 360,
                           variable_type: VariableType = VariableType.LOG_RETURN
                           ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
     # starting values
@@ -538,7 +576,7 @@ def logsv_mc_chain_pricer(ttms: np.ndarray,
                                                           volvol=volvol,
                                                           vol_backbone_eta=vol_backbone_eta,
                                                           nb_path=nb_path,
-                                                          nb_steps=nb_steps,
+                                                          nb_steps_per_year=nb_steps_per_year,
                                                           is_spot_measure=is_spot_measure)
         ttm0 = ttm
         option_prices, option_std = compute_mc_vars_payoff(x0=x0, sigma0=sigma0, qvar0=qvar0,
@@ -564,7 +602,7 @@ def simulate_vol_paths(ttm: float,
                        volvol: float,
                        is_spot_measure: bool = True,
                        nb_path: int = 100000,
-                       nb_steps: int = 360,
+                       nb_steps_per_year: int = 360,
                        brownians: np.ndarray = None,
                        **kwargs
                        ) -> Tuple[np.ndarray, np.ndarray]:
@@ -573,7 +611,7 @@ def simulate_vol_paths(ttm: float,
     """
     sigma0 = v0 * np.ones(nb_path)
 
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps=nb_steps)
+    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps_per_year=nb_steps_per_year)
 
     if brownians is None:
         brownians = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))
@@ -586,7 +624,7 @@ def simulate_vol_paths(ttm: float,
     vartheta2 = beta*beta + volvol*volvol
     vartheta = np.sqrt(vartheta2)
     vol_var = np.log(sigma0)
-    sigma_t = np.zeros((nb_steps+1, nb_path))  # sigma grid will increase to include the sigma_0 at t0 = 0
+    sigma_t = np.zeros((nb_steps_per_year + 1, nb_path))  # sigma grid will increase to include the sigma_0 at t0 = 0
     sigma_t[0, :] = sigma0  # keep first value
     for t_, w1_ in enumerate(brownians):
         vol_var = vol_var + ((kappa1 * theta / sigma0 - kappa1) + kappa2*(theta-sigma0) + adj*sigma0 - 0.5*vartheta2) * dt + vartheta*w1_
@@ -609,7 +647,10 @@ def simulate_logsv_x_vol_terminal(ttm: float,
                                   vol_backbone_eta: float = 1.0,
                                   is_spot_measure: bool = True,
                                   nb_path: int = 100000,
-                                  nb_steps: int = 360
+                                  nb_steps_per_year: int = 360,
+                                  W0: Optional[np.ndarray] = None,
+                                  W1: Optional[np.ndarray] = None,
+                                  dt: Optional[float] = None
                                   ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     mc simulator for terminal values of log-return, vol sigma0, and qvar for log sv model
@@ -628,10 +669,16 @@ def simulate_logsv_x_vol_terminal(ttm: float,
         sigma0 = sigma0 * np.ones(nb_path)
     else:
         assert sigma0.shape[0] == nb_path
-
-    nb_steps, dt, grid_t = set_time_grid(ttm=ttm, nb_steps=nb_steps)
-    W0 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, nb_path))
-    W1 = np.sqrt(dt) * np.random.normal(0, 1, size=(nb_steps, 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}")
+        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))
+    else:
+        sdt = np.sqrt(dt)
+        W0_ = sdt * W0
+        W1_ = sdt * W1
 
     if is_spot_measure:
         alpha, adj = -1.0, 0.0
@@ -641,7 +688,7 @@ def simulate_logsv_x_vol_terminal(ttm: float,
     vartheta2 = beta*beta + volvol*volvol
     vol_backbone_eta2 = vol_backbone_eta * vol_backbone_eta
     vol_var = np.log(sigma0)
-    for t_, (w0, w1) in enumerate(zip(W0, W1)):
+    for t_, (w0, w1) in enumerate(zip(W0_, W1_)):
         sigma0_2dt = vol_backbone_eta2 * sigma0 * sigma0 * dt
         x0 = x0 + alpha * 0.5 * sigma0_2dt + vol_backbone_eta * sigma0 * w0
         vol_var = vol_var + ((kappa1 * theta / sigma0 - kappa1) + kappa2*(theta-sigma0) + adj*sigma0 - 0.5*vartheta2) * dt + beta*w0+volvol*w1
@@ -651,6 +698,96 @@ def simulate_logsv_x_vol_terminal(ttm: float,
     return x0, sigma0, qvar0
 
 
+def get_randoms_for_chain_valuation(ttms: np.ndarray,
+                                    nb_path: int = 100000,
+                                    nb_steps_per_year: int = 360,
+                                    seed: int = 10
+                                    ) -> Tuple[List[np.ndarray], List[np.ndarray], List[np.ndarray]]:
+    """
+    we need to fix random normals for suesequent evaluation using mc slices
+    outputs as numpy lists
+    """
+    #
+    set_seed(seed)
+    W0s = List()
+    W1s = List()
+    dts = List()
+    ttm0 = 0.0
+    for ttm in ttms:
+        # qqq
+        nb_steps_, dt, grid_t = set_time_grid(ttm=ttm - ttm0, nb_steps_per_year=nb_steps_per_year)
+        W0s.append(np.random.normal(0, 1, size=(nb_steps_, nb_path)))
+        W1s.append(np.random.normal(0, 1, size=(nb_steps_, nb_path)))
+        dts.append(dt)
+        ttm0 = ttm
+    return W0s, W1s, dts
+
+
+@njit(cache=False, fastmath=True)
+def logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
+                                        forwards: np.ndarray,
+                                        discfactors: np.ndarray,
+                                        strikes_ttms: Tuple[np.ndarray,...],
+                                        optiontypes_ttms: Tuple[np.ndarray, ...],
+                                        W0s: Tuple[np.ndarray, ...],
+                                        W1s: Tuple[np.ndarray, ...],
+                                        dts: Tuple[np.ndarray, ...],
+                                        v0: float,
+                                        theta: float,
+                                        kappa1: float,
+                                        kappa2: float,
+                                        beta: float,
+                                        volvol: float,
+                                        vol_backbone_etas: np.ndarray,
+                                        is_spot_measure: bool = True,
+                                        variable_type: VariableType = VariableType.LOG_RETURN
+                                        ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+    """
+    chain valuation using fixed randoms
+    """
+    # starting values
+    nb_path = W0s[0].shape[1]
+    x0 = np.zeros(nb_path)
+    qvar0 = np.zeros(nb_path)
+    sigma0 = v0*np.ones(nb_path)
+    ttm0 = 0.0
+
+    # outputs as numpy lists
+    option_prices_ttm = List()
+    option_std_ttm = List()
+    for ttm, forward, discfactor, strikes_ttm, optiontypes_ttm, vol_backbone_eta, W0, W1, dt in zip(ttms, forwards, discfactors,
+                                                                                                strikes_ttms, optiontypes_ttms,
+                                                                                                vol_backbone_etas,
+                                                                                                W0s, W1s, dts):
+        x0, sigma0, qvar0 = simulate_logsv_x_vol_terminal(ttm=ttm - ttm0,
+                                                          x0=x0,
+                                                          sigma0=sigma0,
+                                                          qvar0=qvar0,
+                                                          theta=theta,
+                                                          kappa1=kappa1,
+                                                          kappa2=kappa2,
+                                                          beta=beta,
+                                                          volvol=volvol,
+                                                          vol_backbone_eta=vol_backbone_eta,
+                                                          nb_path=nb_path,
+                                                          dt=dt,
+                                                          is_spot_measure=is_spot_measure,
+                                                          W0=W0,
+                                                          W1=W1)
+        ttm0 = ttm
+        option_prices, option_std = compute_mc_vars_payoff(x0=x0, sigma0=sigma0, qvar0=qvar0,
+                                                           ttm=ttm,
+                                                           forward=forward,
+                                                           strikes_ttm=strikes_ttm,
+                                                           optiontypes_ttm=optiontypes_ttm,
+                                                           discfactor=discfactor,
+                                                           variable_type=variable_type)
+        option_prices_ttm.append(option_prices)
+        option_std_ttm.append(option_std)
+
+    return option_prices_ttm, option_std_ttm
+
+
 class UnitTests(Enum):
     CHAIN_PRICER = 1
     SLICE_PRICER = 2

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/tests/bsm_mgf_pricer.py

@@ -9,7 +9,7 @@ import seaborn as sns
 from typing import Tuple
 from enum import Enum
 
-from stochvolmodels.pricers.analytic import mgf_pricer as mgfp
+import stochvolmodels.utils.mgf_pricer as mgfp
 from stochvolmodels.pricers.analytic.bsm import infer_bsm_ivols_from_model_chain_prices
 from stochvolmodels.utils.config import VariableType
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/utils/funcs.py

@@ -15,11 +15,13 @@ def to_flat_np_array(input_list: List[np.ndarray]) -> np.ndarray:
 
 
 @njit(cache=False, fastmath=False)
-def set_time_grid(ttm: float, nb_steps: int = 360) -> Tuple[int, float, np.ndarray]:
+def set_time_grid(ttm: float, nb_steps_per_year: int = 360) -> Tuple[int, float, np.ndarray]:
     """
     set daily steps
     """
+    nb_steps = int(ttm * nb_steps_per_year) + 1
     grid_t = np.linspace(0.0, ttm, nb_steps + 1)
+    # dt = ttm / nb_steps
     dt = grid_t[1] - grid_t[0]
     return nb_steps, dt, grid_t
 
@@ -94,3 +96,29 @@ def ncdf(x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
 @njit(cache=False, fastmath=True)
 def npdf(x: Union[float, np.ndarray], mu: float = 0.0, vol: float = 1.0) -> Union[float, np.ndarray]:
     return np.exp(-0.5*np.square((x-mu)/vol))/(vol*np.sqrt(2.0*np.pi))
+
+
+def find_nearest(a: np.ndarray,
+                 value: float,
+                 is_sorted: bool = True,
+                 is_equal_or_largest: bool = False
+                 ) -> float:
+    """
+    find closest element
+    https://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array
+    """
+    if is_sorted:
+        idx = np.searchsorted(a, value, side="left")
+        if is_equal_or_largest:  # return the equal or largest element
+            return a[idx]
+        else:
+            if idx > 0 and (idx == len(a) or np.abs(value - a[idx - 1]) < np.abs(value - a[idx])):
+                return a[idx - 1]
+            else:
+                return a[idx]
+    else:
+        a = np.asarray(a)
+        idx = (np.abs(a - value)).argmin()
+    return a[idx]
+
+

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/utils/mc_payoffs.py

@@ -4,7 +4,6 @@ Montecarlo analytics for option pay-off computations
 
 import numpy as np
 from numba import njit
-
 from stochvolmodels.utils.config import VariableType
 
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.27}/stochvolmodels/utils/mgf_pricer.py

@@ -5,7 +5,6 @@ generic analytics for option pricing using Fourier transforms of payoffs
 import numpy as np
 from numba import njit
 from typing import Tuple
-
 from stochvolmodels.utils.config import VariableType
 
 

stochvolmodels-1.0.25/stochvolmodels/data/fetch_option_chain.py

@@ -1,176 +0,0 @@
-"""
-this module is using option-chain-analytics package
-to fetch OptionChain data with options data
-see https://pypi.org/project/option-chain-analytics
-"""
-
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import qis
-from qis import TimePeriod
-from typing import Dict, Tuple, Optional, Literal
-from numba.typed import List
-from enum import Enum
-
-# chain
-from option_chain_analytics import OptionsDataDFs, create_chain_from_from_options_dfs
-from option_chain_analytics.option_chain import SliceColumn, SlicesChain
-
-# analytics
-from stochvolmodels.data.option_chain import OptionChain
-
-
-def generate_vol_chain_np(chain: SlicesChain,
-                          value_time: pd.Timestamp,
-                          days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                          delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                          is_filtered: bool = True
-                          ) -> OptionChain:
-    """
-    given SlicesChain generate OptionChain for calibration inputs
-    """
-
-    ttms, future_prices, discfactors = List(), List(), List()
-    optiontypes_ttms, strikes_ttms = List(), List()
-    bid_ivs, ask_ivs = List(), List()
-    bid_prices, ask_prices = List(), List()
-    slice_ids = []
-    for label, day in days_map.items():
-        next_date = value_time + pd.DateOffset(days=day)  # if overlapping next date will be last avilable maturity
-        slice_date = chain.get_next_slice_after_date(mat_date=next_date)
-        slice_t = chain.expiry_slices[slice_date]
-        df = slice_t.get_joint_slice(delta_bounds=delta_bounds, is_filtered=is_filtered)
-        if not df.empty:
-            slice_ids.append(f"{label}: {slice_t.expiry_id}")
-            ttms.append(slice_t.get_ttm())
-            future_prices.append(slice_t.get_future_price())
-            discfactors.append(1.0)
-            strikes_ttms.append(df.index.to_numpy())
-            optiontypes_ttms.append(df[SliceColumn.OPTION_TYPE].to_numpy(dtype=str))
-            bid_ivs.append(df[SliceColumn.BID_IV].to_numpy())
-            ask_ivs.append(df[SliceColumn.ASK_IV].to_numpy())
-            bid_prices.append(df[SliceColumn.BID_PRICE].to_numpy())
-            ask_prices.append(df[SliceColumn.ASK_PRICE].to_numpy())
-
-    out = OptionChain(ttms=np.array(ttms),
-                      forwards=np.array(future_prices),
-                      discfactors=np.array(discfactors),
-                      ids=np.array(slice_ids),
-                      strikes_ttms=strikes_ttms,
-                      optiontypes_ttms=optiontypes_ttms,
-                      bid_ivs=bid_ivs,
-                      ask_ivs=ask_ivs,
-                      bid_prices=bid_prices,
-                      ask_prices=ask_prices)
-    return out
-
-
-def load_option_chain(options_data_dfs: OptionsDataDFs,
-                      value_time: pd.Timestamp = pd.Timestamp('2023-02-06 08:00:00+00:00'),
-                      days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                      delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                      is_filtered: bool = True
-                      ) -> Optional[OptionChain]:
-    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
-    if chain is not None:
-        option_chain = generate_vol_chain_np(chain=chain,
-                                             value_time=value_time,
-                                             days_map=days_map,
-                                             delta_bounds=delta_bounds,
-                                             is_filtered=is_filtered)
-    else:
-        option_chain = None
-
-    return option_chain
-
-
-def sample_option_chain_at_times(options_data_dfs: OptionsDataDFs,
-                                 time_period: TimePeriod,
-                                 freq: str = 'W-FRI',
-                                 days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                                 delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                                 hour_offset: int = 8
-                                 ) -> Dict[pd.Timestamp, OptionChain]:
-    value_times = qis.generate_dates_schedule(time_period=time_period,
-                                              freq=freq,
-                                              hour_offset=hour_offset)
-    option_chains = {}
-    for value_time in value_times:
-        option_chains[value_time] = load_option_chain(options_data_dfs=options_data_dfs,
-                                                      value_time=value_time,
-                                                      days_map=days_map,
-                                                      delta_bounds=delta_bounds,
-                                                      is_filtered=True)
-    return option_chains
-
-
-def load_price_data(options_data_dfs: OptionsDataDFs,
-                    time_period: TimePeriod = None,
-                    data: Literal['spot', 'perp', 'funding_rate'] = 'spot',
-                    freq: Optional[str] = 'D'  # to do
-                    ) -> pd.Series:
-    #options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker, freq='D', hour_offset=8))
-    spot_price = options_data_dfs.get_spot_data()[data]
-    if freq is not None:
-        spot_price = spot_price.resample(freq).last()
-    if time_period is not None:
-        spot_price = time_period.locate(spot_price)
-    return spot_price
-
-
-class UnitTests(Enum):
-    PRINT_CHAIN_DATA = 1
-    GENERATE_VOL_CHAIN_NP = 2
-    SAMPLE_CHAIN_AT_TIMES = 3
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    ticker = 'BTC'  # BTC, ETH
-    value_time = pd.Timestamp('2021-10-21 08:00:00+00:00')
-    value_time = pd.Timestamp('2023-10-06 08:00:00+00:00')
-
-    from option_chain_analytics.ts_loaders import ts_data_loader_wrapper
-    options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker))
-    options_data_dfs.get_start_end_date().print()
-    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
-
-    if unit_test == UnitTests.PRINT_CHAIN_DATA:
-        for expiry, eslice in chain.expiry_slices.items():
-            eslice.print()
-
-    elif unit_test == UnitTests.GENERATE_VOL_CHAIN_NP:
-        option_chain = generate_vol_chain_np(chain=chain,
-                                             value_time=value_time,
-                                             days_map={'1w': 7},
-                                             delta_bounds=(-0.1, 0.1),
-                                             is_filtered=True)
-        option_chain.print()
-        skews = option_chain.get_chain_skews(delta=0.35)
-        print(skews)
-
-    elif unit_test == UnitTests.SAMPLE_CHAIN_AT_TIMES:
-        time_period = qis.TimePeriod('01Jan2023', '31Jan2023', tz='UTC')
-        option_chains = sample_option_chain_at_times(options_data_dfs=options_data_dfs,
-                                                     time_period=time_period,
-                                                     freq='W-FRI',
-                                                     hour_offset=9
-                                                     )
-        for key, chain in option_chains.items():
-            print(f"{key}")
-            print(chain)
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.SAMPLE_CHAIN_AT_TIMES
-
-    is_run_all_tests = False
-    if is_run_all_tests:
-        for unit_test in UnitTests:
-            run_unit_test(unit_test=unit_test)
-    else:
-        run_unit_test(unit_test=unit_test)

stochvolmodels-1.0.25/stochvolmodels/examples/run_gmm_fit.py

@@ -1,41 +0,0 @@
-"""
-example of fitting GMM
-see StochVolModels/examples/run_gmm_fit.py
-"""
-import matplotlib.pyplot as plt
-import seaborn as sns
-import qis as qis
-from stochvolmodels import (get_btc_test_chain_data,
-                            get_spy_test_chain_data,
-                            OptionChain, GmmPricer,
-                            plot_gmm_pdfs)
-
-# get test option chain data
-# option_chain = get_btc_test_chain_data()
-option_chain = get_spy_test_chain_data()
-
-# run GMM fit
-gmm_pricer = GmmPricer()
-fit_params = gmm_pricer.calibrate_model_params_to_chain(option_chain=option_chain, n_mixtures=4)
-
-# illustrate fitted parameters and model fit to market bid-ask
-# plot two ids
-ids = ['2m', '6m']
-n = len(ids)
-with sns.axes_style('darkgrid'):
-    fig, axs = plt.subplots(n, 2, figsize=(14, 12), tight_layout=True)
-    # axs = qis.to_flat_list(axs)
-current_ax = 0
-
-for key, params in fit_params.items():
-    print(f"{key}: {params}")
-    if key in ids:
-        option_chain0 = OptionChain.get_slices_as_chain(option_chain, ids=[key])
-        # gmm_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain0, params=params, axs=[axs[idx]])
-        plot_gmm_pdfs(params=params, option_chain0=option_chain0, axs=axs[current_ax, :])
-        qis.set_title(ax=axs[current_ax, 0], title=f"{key}-slice: (A) State PDF and Aggregate Risk-Neutral PDF")
-        qis.set_title(ax=axs[current_ax, 1], title=f"{key}-slice: Model to Market Bid/Ask vols")
-        current_ax += 1
-
-qis.set_suptitle(fig, title='Fit of 4-state GMM to SPY implied vols @ 15_Jul_2022_10_23_09')
-plt.show()