stochvolmodels 1.0.26__tar.gz → 1.0.28__tar.gz

{stochvolmodels-1.0.26 → stochvolmodels-1.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: stochvolmodels
-Version: 1.0.26
+Version: 1.0.28
 Summary: Implementation of stochastic volatility models for option pricing
 License: LICENSE.txt
 Keywords: volatility,options,Black-Scholes,Heston,Monte-Carlo

{stochvolmodels-1.0.26 → stochvolmodels-1.0.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.26"
+version = "1.0.28"
 description = "Implementation of stochastic volatility models for option pricing"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]

{stochvolmodels-1.0.26 → stochvolmodels-1.0.28}/stochvolmodels/__init__.py

@@ -106,7 +106,10 @@ 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
 
@@ -156,3 +159,5 @@ from stochvolmodels.utils.plots import (
 
 
 from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar
+
+from stochvolmodels.data.option_chain import generate_vol_chain_np

stochvolmodels-1.0.28/stochvolmodels/data/fetch_option_chain.py

@@ -0,0 +1,174 @@
+"""
+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
+from qis import TimePeriod
+from typing import Dict, Tuple, Optional, Literal
+from numba.typed import List
+from enum import Enum
+import qis as qis
+# 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.26 → stochvolmodels-1.0.28}/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):
@@ -95,6 +97,36 @@ def run_unit_test(unit_test: UnitTests):
         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:
         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)
@@ -105,12 +137,27 @@ 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.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
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.26 → stochvolmodels-1.0.28}/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.26 → stochvolmodels-1.0.28}/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.26 → stochvolmodels-1.0.28}/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))
 

{stochvolmodels-1.0.26 → stochvolmodels-1.0.28}/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.26 → stochvolmodels-1.0.28}/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
 
@@ -102,7 +104,7 @@ def find_nearest(a: np.ndarray,
                  is_equal_or_largest: bool = False
                  ) -> float:
     """
-    find closes element
+    find closest element
     https://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array
     """
     if is_sorted: