stochvolmodels 1.0.21__tar.gz → 1.0.22__tar.gz

{stochvolmodels-1.0.21 → stochvolmodels-1.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stochvolmodels
-Version: 1.0.21
+Version: 1.0.22
 Summary: Implementation of stochastic volatility models for option pricing
 Home-page: https://github.com/ArturSepp/StochVolModels
 License: LICENSE.txt

{stochvolmodels-1.0.21 → stochvolmodels-1.0.22}/pyproject.toml

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

stochvolmodels-1.0.21/stochvolmodels/my_papers/forward_var/calibrate_forward_var.py

@@ -1,115 +0,0 @@
-# packages
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from enum import Enum
-
-import qis
-
-# project
-import stochvolmodels as sv
-from stochvolmodels.pricers.logsv_pricer import LogSVPricer, LogsvModelCalibrationType
-from stochvolmodels.pricers.logsv.vol_moments_ode import fit_model_vol_backbone_to_varswaps
-from stochvolmodels import LogSvParams
-from stochvolmodels.utils.funcs import set_seed
-
-
-class UnitTests(Enum):
-    VARSWAP_FIT = 1
-    CALIBRATE_4PARAM_MODEL = 2
-    CALIBRATE_VARSWAP_PARAM_MODEL = 3
-    COMPARE_MODEL_VOLS_TO_MC = 4
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    set_seed(24)
-
-    logsv_pricer = LogSVPricer()
-    option_chain = sv.get_btc_test_chain_data()
-
-    local_path = "C://Users//artur//OneDrive//My Papers//MyPresentations//Crypto Vols Tartu. Zurich. Aug 2022//figures//"
-
-    if unit_test == UnitTests.VARSWAP_FIT:
-        btc_log_params = LogSvParams(sigma0=0.7118361434192538, theta=0.7118361434192538,
-                                     kappa1=2.214702576955766, kappa2=2.18028273418397, beta=0.0,
-                                     volvol=0.921487415907961)
-        btc_log_params = LogSvParams(sigma0=0.88, theta=0.88,
-                                     kappa1=2.214702576955766, kappa2=2.18028273418397, beta=0.0,
-                                     volvol=0.921487415907961)
-
-        vars_swaps = option_chain.get_slice_varswap_strikes()
-        vars_swaps1 = pd.Series(np.square(option_chain.get_chain_atm_vols()), index=option_chain.ttms)
-        vars_swaps = np.maximum(vars_swaps, vars_swaps1)
-
-        vol_backbone = fit_model_vol_backbone_to_varswaps(log_sv_params=btc_log_params,
-                                                          varswap_strikes=vars_swaps,
-                                                          verbose=True)
-        btc_log_params.set_vol_backbone(vol_backbone=vol_backbone)
-
-        logsv_pricer = LogSVPricer()
-        logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain,
-                                                 params=btc_log_params)
-
-    elif unit_test == UnitTests.CALIBRATE_4PARAM_MODEL:
-        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
-        fitted_params = LogSvParams(sigma0=0.8626, theta=1.0417, kappa1=2.21, kappa2=2.18, beta=0.13, volvol=1.6286)
-        btc_calibrated_params = fitted_params
-        """
-        btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(option_chain=option_chain,
-                                                                             params0=params0,
-                                                                             model_calibration_type=LogsvModelCalibrationType.PARAMS4,
-                                                                             constraints_type=sv.ConstraintsType.INVERSE_MARTINGALE)
-        """
-        print(btc_calibrated_params)
-        fig = logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain,
-                                                       params=btc_calibrated_params)
-        qis.save_fig(fig=fig, file_name='four_param_model_fit', local_path=local_path)
-
-    elif unit_test == UnitTests.CALIBRATE_VARSWAP_PARAM_MODEL:
-        params0 = LogSvParams(sigma0=0.85, theta=0.85, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=1.5)
-        fitted_params = LogSvParams(sigma0=0.85, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.24, volvol=1.14)
-        btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(
-            option_chain=option_chain,
-            params0=params0,
-            params_min=LogSvParams(sigma0=0.1, theta=0.1, kappa1=0.25, kappa2=0.25, beta=0.0, volvol=1.5),
-            model_calibration_type=LogsvModelCalibrationType.PARAMS_WITH_VARSWAP_FIT,
-            constraints_type=sv.ConstraintsType.INVERSE_MARTINGALE)
-        print(btc_calibrated_params)
-
-        fig = logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain,
-                                                       params=btc_calibrated_params)
-        qis.save_fig(fig=fig, file_name='backbone_model_fit', local_path=local_path)
-
-    elif unit_test == UnitTests.COMPARE_MODEL_VOLS_TO_MC:
-        uniform_chain_data = sv.OptionChain.to_uniform_strikes(obj=option_chain, num_strikes=31)
-        is_varswap = True
-        if is_varswap:
-            fitted_params = LogSvParams(sigma0=0.85, theta=.85, kappa1=2.21, kappa2=2.18, beta=0.24, volvol=1.14)
-            varswap_strikes = option_chain.get_slice_varswap_strikes(floor_with_atm_vols=True)
-            fitted_params.set_vol_backbone(vol_backbone=fit_model_vol_backbone_to_varswaps(log_sv_params=fitted_params,
-                                                                                           varswap_strikes=varswap_strikes))
-        else:
-            fitted_params = LogSvParams(sigma0=0.8626, theta=1.0417, kappa1=2.21, kappa2=2.18, beta=0.13, volvol=1.6286)
-
-        logsv_pricer.plot_model_ivols_vs_mc(option_chain=uniform_chain_data,
-                                            params=fitted_params,
-                                            nb_path=100000)
-
-        logsv_pricer.plot_comp_mma_inverse_options_with_mc(option_chain=uniform_chain_data,
-                                                           params=fitted_params,
-                                                           nb_path=100000)
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.CALIBRATE_VARSWAP_PARAM_MODEL
-
-    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.21/stochvolmodels/my_papers/il_hedging/README.md

@@ -1,8 +0,0 @@
-This module contains analysis for paper
-[Unified Approach for Hedging Impermanent Loss of Liquidity Provision](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4887298) 
-by Artur Sepp, Alexander Lipton, and Vladimir Lucic
-
-All figures in the paper are produced by unittests in
-https://github.com/ArturSepp/StochVolModels/blob/main/my_papers/il_hedging/run_logsv_for_il_payoff.py
-
-See the description of data and analysis in the paper.

stochvolmodels-1.0.21/stochvolmodels/my_papers/il_hedging/logsv_figures.py

@@ -1,61 +0,0 @@
-"""
-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
-from enum import Enum
-
-from stochvolmodels import LogSVPricer, LogSvParams, OptionChain
-
-
-def plot_skews():
-    logsv_pricer = LogSVPricer()
-    option_chain = OptionChain.get_uniform_chain(ttms=np.array([14.0/365.0]),
-                                                 ids=np.array(['2w']),
-                                                 strikes=np.linspace(0.6, 1.4, 21))
-
-    # define parameters for bootstrap
-    sigma0 = 0.5
-    params_dict = {'beta=-1': LogSvParams(sigma0=sigma0, theta=sigma0, kappa1=5.0, kappa2=5.0, beta=-1, volvol=1.0),
-                   'beta=0': LogSvParams(sigma0=sigma0, theta=sigma0, kappa1=5.0, kappa2=5.0, beta=0.0, volvol=1.4),
-                   'beta=1': LogSvParams(sigma0=sigma0, theta=sigma0, kappa1=5.0, kappa2=5.0, beta=1.0, volvol=1.0)}
-
-    params_dict = {
-        'volvol=1.0': LogSvParams(sigma0=sigma0, theta=sigma0, kappa1=2.21, kappa2=2.18, beta=0.0, volvol=1.0),
-        'volvol=2.0': LogSvParams(sigma0=sigma0 - 0.005, theta=sigma0 - 0.005, kappa1=2.21, kappa2=2.18, beta=0.0,
-                                  volvol=2.0),
-        'volvol=3.0': LogSvParams(sigma0=sigma0 - 0.01, theta=sigma0 - 0.01, kappa1=2.21, kappa2=2.18, beta=0.0,
-                                  volvol=3.0)}
-
-    # get slice for illustration
-    option_slice = option_chain.get_slice(id='2w')
-    logsv_pricer.plot_model_slices_in_params(option_slice=option_slice,
-                                             params_dict=params_dict)
-
-
-class UnitTests(Enum):
-    PLOT_SKEWS = 1
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    if unit_test == UnitTests.PLOT_SKEWS:
-        with sns.axes_style("darkgrid"):
-            fig, axs = plt.subplots(3, 1, figsize=(10, 7))
-        plot_skews()
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.PLOT_SKEWS
-
-    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.21/stochvolmodels/my_papers/il_hedging/run_logsv_for_il_payoff.py

@@ -1,150 +0,0 @@
-"""
-computation of il payoff under log sv
-"""
-import numpy as np
-import matplotlib.pyplot as plt
-from numba import njit
-from enum import Enum
-
-# stochvolmodels pricers
-from stochvolmodels import (get_transform_var_grid,
-                            vanilla_slice_pricer_with_mgf_grid,
-                            digital_slice_pricer_with_mgf_grid,
-                            compute_integration_weights,
-                            ExpansionOrder,
-                            get_expansion_n,
-                            compute_logsv_a_mgf_grid,
-                            LogSvParams)
-
-
-def logsv_il_pricer(params: LogSvParams,
-                    ttm: float,
-                    p1: float,  # can price on range of forwards
-                    p0: float,
-                    pa: float,
-                    pb: float,
-                    is_stiff_solver: bool = False,
-                    expansion_order: ExpansionOrder = ExpansionOrder.SECOND,
-                    vol_scaler: float = None,
-                    notional: float = 1000000
-                    ) -> float:
-    """
-    price il using bsm mgf
-    """
-    # starting values
-    if vol_scaler is None:  # for calibrations we fix one vol_scaler so the grid is not affected by v0
-        vol_scaler = params.sigma0 * np.sqrt(np.minimum(np.min(ttm), 0.5 / 12.0))
-
-    # for vanilla call and put
-    phi_grid, psi_grid, theta_grid = get_transform_var_grid(vol_scaler=vol_scaler,
-                                                                 real_phi=-0.4)
-    a_t0 = np.zeros((phi_grid.shape[0], get_expansion_n(expansion_order)), dtype=np.complex128)
-
-    a_t0, log_mgf_grid = compute_logsv_a_mgf_grid(ttm=ttm,
-                                                  phi_grid=phi_grid,
-                                                  psi_grid=psi_grid,
-                                                  theta_grid=theta_grid,
-                                                  a_t0=a_t0,
-                                                  expansion_order=expansion_order,
-                                                  is_stiff_solver=is_stiff_solver,
-                                                  **params.to_dict())
-
-    vanilla_option_prices = vanilla_slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                               phi_grid=phi_grid,
-                                                               forward=p1,
-                                                               strikes=np.array([pa, pb]),
-                                                               optiontypes=np.array(['P', 'C']),
-                                                               discfactor=1.0)
-    bsm_put, bsm_call = vanilla_option_prices[0], vanilla_option_prices[1]
-
-    digital_options = digital_slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                         phi_grid=phi_grid,
-                                                         forward=p1,
-                                                         strikes=np.array([pa, pb]),
-                                                         optiontypes=np.array(['P', 'C']),
-                                                         discfactor=1.0)
-    digital_put, digital_call = digital_options[0], digital_options[1]
-
-    square_root = square_root_payoff_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                          phi_grid=phi_grid,
-                                                          forward=p1,
-                                                          pa=pa,
-                                                          pb=pb,
-                                                          discfactor=1.0)
-
-    sp0 = np.sqrt(p0)
-    spa = np.sqrt(pa)
-    spb = np.sqrt(pb)
-
-    linear = sp0*(p1/p0+1.0)
-
-    payoff = -2.0*square_root + linear + \
-             (1.0 / spa) * bsm_put - (1.0 / spb) * bsm_call \
-             -2.0 * spa * digital_put -2.0 * spb * digital_call
-
-    notional0 = 1.0 / (2.0*sp0-p0/spb-spa)
-    payoff = - (notional0*notional)*payoff
-    return payoff
-
-
-logsv_il_pricer_vector = np.vectorize(logsv_il_pricer, doc='Vectorized `logsv_il_pricer`')
-
-
-@njit(cache=False, fastmath=True)
-def square_root_payoff_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
-                                            phi_grid: np.ndarray,
-                                            forward: float,
-                                            pa: float,
-                                            pb: float,
-                                            discfactor: float = 1.0,
-                                            is_simpson: bool = True
-                                            ) -> np.ndarray:
-    """
-    generic function for pricing digital options on the spot given the mgf grid
-    mgf in x is function defined on log-price transform phi grids
-    transform variable is phi_grid = real_phi + i*p
-    grid can be non-uniform
-    we can use either positive or negative phi_real but not
-    """
-    dp = compute_integration_weights(var_grid=phi_grid, is_simpson=is_simpson)
-
-    x = np.log(forward)
-    xa = np.log(pa)
-    xb = np.log(pb)
-    p_payoff = (np.exp( (phi_grid+0.5)*xb - phi_grid*x) - np.exp((phi_grid+0.5)*xa - phi_grid*x))
-    p_payoff = (dp / np.pi) * p_payoff / (phi_grid+0.5)
-    option_price = discfactor * np.nansum(np.real(p_payoff*np.exp(log_mgf_grid)))
-    return option_price
-
-
-class UnitTests(Enum):
-    COMPUTE_MODEL_PRICES = 1
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    # define model params
-    params = LogSvParams(sigma0=0.4861785891939535, theta=0.6176006871606874, kappa1=1.955809653686808, kappa2=1.978367101612294, beta=-0.26916969112829325, volvol=3.265815229306317)
-
-    if unit_test == UnitTests.COMPUTE_MODEL_PRICES:
-        payoff = logsv_il_pricer(params=params,
-                                 ttm=10.0/365.0,
-                                 p1=2200.0,
-                                 p0=2200.0,
-                                 pa=2000.0,
-                                 pb=2400.0)
-        print(payoff)
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.COMPUTE_MODEL_PRICES
-
-    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.21/stochvolmodels/my_papers/inverse_options/README.md

@@ -1,10 +0,0 @@
-This module contains analysis for paper
-[Valuation and Hedging of Cryptocurrency Inverse Options](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4606748) by Artur Sepp and Vladimir Lucic
-
-Comparision of net deltas in the paper are generated using
-```python 
-compare_net_delta.py
-```
-https://github.com/ArturSepp/StochVolModels/tree/main/my_papers/inverse_options
-
-See the description of data and analysis in the paper.

stochvolmodels-1.0.21/stochvolmodels/my_papers/inverse_options/compare_net_delta.py

@@ -1,168 +0,0 @@
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-import qis as qis
-from enum import Enum
-
-
-from stochvolmodels import (compute_bsm_vanilla_grid_deltas,
-                            compute_bsm_forward_grid_prices,
-                            compute_bsm_vanilla_price,
-                            compute_bsm_vanilla_delta)
-
-
-def compare_net_deltas(ttm: float,
-                       forward: float,
-                       vol: float,
-                       strike_level: float = 1.0,
-                       optiontype: str = 'C',
-                       ax: plt.Subplot = None,
-                       **kwargs
-                       ):
-
-    spot_drid = np.linspace(0.7*forward, 1.3*forward, 1000)
-    strike = strike_level * forward
-
-    option_prices = compute_bsm_forward_grid_prices(ttm=ttm, forwards=spot_drid, strike=strike, vol=vol, optiontype=optiontype)
-    option_deltas = compute_bsm_vanilla_grid_deltas(ttm=ttm, forwards=spot_drid, strike=strike, vol=vol, optiontype=optiontype)
-    option_net_delta = option_deltas - option_prices / spot_drid
-    option_deltas = pd.Series(option_deltas, index=spot_drid, name='Black Delta')
-    option_net_delta = pd.Series(option_net_delta, index=spot_drid, name='Net Delta')
-    deltas = pd.concat([option_deltas, option_net_delta], axis=1)
-
-    qis.plot_line(df=deltas,
-                  xvar_format='{:,.0f}',
-                  ylabel='BTC price',
-                  ax=ax,
-                  **kwargs)
-
-
-def compare_pnl(ttm: float,
-                forward: float,
-                vol: float,
-                strike_level: float = 1.0,
-                optiontype: str = 'C',
-                is_btc_pnl: bool = True,
-                ax: plt.Subplot = None,
-                **kwargs
-                ):
-
-    spot_drid = np.linspace(0.7*forward, 1.3*forward, 10000)
-    returns_grid = spot_drid / forward - 1.0
-    strike = strike_level*forward
-
-    option_price0 = compute_bsm_vanilla_price(ttm=ttm, forward=forward, strike=strike, vol=vol, optiontype=optiontype)
-    option_delta0 = compute_bsm_vanilla_delta(ttm=ttm, forward=forward, strike=strike, vol=vol, optiontype=optiontype)
-    option_net_delta0 = option_delta0 - option_price0 / forward
-
-    # price return
-    inverse_price_return = (spot_drid-forward) / spot_drid
-    dt = 1.0 / 365.0
-    option_prices = compute_bsm_forward_grid_prices(ttm=ttm-dt, forwards=spot_drid, strike=strike, vol=vol, optiontype=optiontype)
-    option_pnl_btc = (option_price0/forward - option_prices/spot_drid)
-
-    # black p&l
-    pnl_btc = option_pnl_btc + option_delta0 * inverse_price_return
-    if not is_btc_pnl:
-        pnl_btc = pnl_btc * spot_drid
-    pnl_btc_positive = spot_drid[pnl_btc >= 0.0]
-    lower_be = pnl_btc_positive[0] / forward - 1.0
-    upper_be = pnl_btc_positive[-1] / forward - 1.0
-    pnl_btc = pd.Series(pnl_btc, index=returns_grid, name=f"Black Delta: breakevens=({lower_be:0.2%}, {upper_be:0.2%})")
-
-    # net p&l
-    pnl_btc_net_delta = option_pnl_btc + option_net_delta0 * inverse_price_return
-    if not is_btc_pnl:
-        pnl_btc_net_delta = pnl_btc_net_delta * spot_drid
-    pnl_btc_net_delta_positive = spot_drid[pnl_btc_net_delta >= 0.0]
-    lower_be = pnl_btc_net_delta_positive[0] / forward - 1.0
-    upper_be = pnl_btc_net_delta_positive[-1] / forward - 1.0
-    pnl_btc_net_delta = pd.Series(pnl_btc_net_delta, index=returns_grid, name=f"Net Delta   : breakevens=({lower_be:0.2%}, {upper_be:0.2%})")
-
-    pnls = pd.concat([pnl_btc, pnl_btc_net_delta], axis=1)
-
-    if is_btc_pnl:
-        ylabel = 'BTC P&L'
-        yvar_format = '{:,.2f}'
-    else:
-        ylabel = 'USD P&L'
-        yvar_format = '{:,.0f}'
-
-    qis.plot_line(df=pnls,
-                  xvar_format='{:,.1%}',
-                  yvar_format=yvar_format,
-                  ylabel=ylabel,
-                  xlabel='BTC % change',
-                  ax=ax,
-                  **kwargs)
-
-
-class UnitTests(Enum):
-    DELTA_COMP = 1
-    PNL_COMP = 2
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    LOCAL_PATH = "C://Users//artur//OneDrive//My Papers//Working Papers//Crypto Options. Zurich. Oct 2022//FinalFigures//"
-
-    kwargs = dict(fontsize=14, framealpha=0.9)
-
-    ttm = 7.0 / 365.0
-
-    if unit_test == UnitTests.DELTA_COMP:
-
-        with sns.axes_style("darkgrid"):
-            fig, axs = plt.subplots(1, 2, figsize=(14, 7), tight_layout=True)
-            compare_net_deltas(ttm=ttm, forward=50000, vol=0.6, optiontype='C',
-                               strike_level=1.0,
-                               title='(A) Call Delta for K=100%*S_0',
-                               ax=axs[0],
-                               **kwargs)
-            compare_net_deltas(ttm=ttm, forward=50000, vol=0.6, optiontype='P',
-                               strike_level=1.0,
-                               title='(B) Put Delta for K=100%*S_0',
-                               ax=axs[1],
-                               **kwargs)
-
-        is_save = True
-        if is_save:
-            qis.save_fig(fig, file_name='delta_comp', local_path=LOCAL_PATH)
-            qis.save_fig(fig, file_name='delta_comp',  file_type=qis.FileTypes.EPS, dpi=1200, local_path=LOCAL_PATH)
-
-    elif unit_test == UnitTests.PNL_COMP:
-
-        with sns.axes_style("darkgrid"):
-            fig, axs = plt.subplots(1, 2, figsize=(14, 7), tight_layout=True)
-            compare_pnl(ttm=ttm, forward=50000, vol=0.6, optiontype='C',
-                        title='(A) ATM Call K=100%*F_0',
-                        y_limits=(-0.3, 0.05),
-                        ax=axs[0],
-                        **kwargs)
-            compare_pnl(ttm=ttm, forward=50000, vol=0.6, optiontype='C',
-                        title='(B) ITM Call K=90%*F_0',
-                        strike_level=0.9,
-                        is_btc_pnl=True,
-                        y_limits=(-0.3, 0.05),
-                        ax=axs[1],
-                        **kwargs)
-
-        is_save = True
-        if is_save:
-            qis.save_fig(fig, file_name='pnl_comp', local_path=LOCAL_PATH)
-            qis.save_fig(fig, file_name='pnl_comp',  file_type=qis.FileTypes.EPS, dpi=1200, local_path=LOCAL_PATH)
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.DELTA_COMP
-
-    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.21/stochvolmodels/my_papers/logsv_model_wtih_quadratic_drift/README.md

@@ -1,13 +0,0 @@
-This module contains analysis for paper
-[Log-normal Stochastic Volatility Model with Quadratic Drift](https://www.worldscientific.com/doi/10.1142/S0219024924500031)
-by Artur Sepp and Parviz Rakhmonov
-
-See the description of data and analysis in the paper.
-
-Figures in the paper are generated using unittests in
-```python 
-article_figures.py
-```
-https://github.com/ArturSepp/StochVolModels/blob/main/my_papers/logsv_model_wtih_quadratic_drift/article_figures.py
-
-See the description of data and analysis in the paper.