stochvolmodels 1.0.14__tar.gz → 1.0.15__tar.gz

{stochvolmodels-1.0.14 → stochvolmodels-1.0.15}/PKG-INFO

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

{stochvolmodels-1.0.14 → stochvolmodels-1.0.15}/pyproject.toml

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

{stochvolmodels-1.0.14 → stochvolmodels-1.0.15}/stochvolmodels/__init__.py

@@ -61,10 +61,14 @@ from stochvolmodels.pricers.analytic.bachelier import (
 )
 
 from stochvolmodels.pricers.analytic.tdist import (
-    t_cum,
-    compute_tdist_price,
-    compute_compute_negative_prob,
-    infer_tdist_implied_vol,
+    pdf_tdist,
+    cdf_tdist,
+    cum_mean_tdist,
+    imply_drift_tdist,
+    compute_default_prob_tdist,
+    compute_forward_tdist,
+    compute_vanilla_price_tdist,
+    infer_implied_vol_tdist,
     infer_tdist_implied_vols_from_model_slice_prices
 )
 
@@ -111,6 +115,11 @@ from stochvolmodels.pricers.gmm_pricer import (
     GmmPricer
 )
 
+from stochvolmodels.pricers.tdist_pricer import (
+    TdistParams,
+    TdistPricer
+)
+
 
 from stochvolmodels.data.option_chain import OptionChain, OptionSlice
 

{stochvolmodels-1.0.14 → stochvolmodels-1.0.15}/stochvolmodels/data/test_option_chain.py

@@ -1,5 +1,6 @@
 """
 test data with implied volatilities for VIX, SQQQ, Bitcoin, Gold, SPY
+data are taken around Nov2021
 data is used for logsv_model_wtih_quadratic_drift figures
 """
 

stochvolmodels-1.0.15/stochvolmodels/pricers/analytic/tdist.py

@@ -0,0 +1,270 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.stats import t
+from scipy.special import betainc, gamma
+from scipy.optimize import fsolve
+from typing import Union
+from enum import Enum
+
+
+def compute_upsilon(vol: float, ttm: float, nu: float) -> float:
+    if nu <= 2.0:
+        raise ValueError(f"{nu} must be > 2.0")
+    return vol*np.sqrt(ttm*(nu-2.0)/nu)
+
+
+def pdf_tdist(x: Union[np.ndarray, float], mu: float, vol: float, nu: float, ttm: float) -> Union[float, np.ndarray]:
+    upsilon = compute_upsilon(vol=vol, ttm=ttm, nu=nu)
+    z = (x - mu * ttm) / upsilon
+    c = (1.0/np.sqrt(np.pi*nu))*(gamma(0.5*(nu+1.0)) / gamma(0.5*nu))/upsilon
+    f = np.power(1.0+np.square(z) / nu, -0.5*(nu+1.0))
+    return c*f
+
+
+def cdf_tdist(x: Union[np.ndarray, float], mu: float, vol: float, nu: float, ttm: float) -> Union[float, np.ndarray]:
+    """
+    cumulative distribution of cumullative location-scale t-distribution
+    cdf = int^{x}_{-\infty} f(u)du
+    """
+    upsilon = compute_upsilon(vol=vol, ttm=ttm, nu=nu)
+    z = (x-mu*ttm) / upsilon
+    cdf = 0.5*(1.0 + np.sign(z)*(1.0-betainc(nu/2.0, 0.5, nu/(np.square(z)+nu))))
+    return cdf
+
+
+def cum_mean_tdist(x: Union[np.ndarray, float], mu: float = 0, vol: float = 0.2, nu: float = 3.0, ttm: float = 0.25) -> Union[float, np.ndarray]:
+    """
+    cumulative expected value
+    h = int^{x}_{-\infty} u f(u)du
+    """
+    upsilon = compute_upsilon(vol=vol, ttm=ttm, nu=nu)
+    z = (x-mu*ttm) / upsilon
+    norm = (gamma(0.5*(1.0+nu)) / gamma(0.5*nu))*np.sqrt(nu/np.pi) / (1.0-nu)
+    h = mu * cdf_tdist(x, mu=mu, vol=vol, nu=nu, ttm=ttm) + upsilon * norm * np.power(1.0 + np.square(z) / nu, -0.5 * (nu - 1.0))
+    return h
+
+
+def imply_drift_tdist(rf_rate: float = 0.0, vol: float = 0.2, nu: float = 3.0, ttm: float = 0.25) -> float:
+    """
+    imply drift of t-distribution under risk-neutral measure
+    """
+    rf_return = (np.exp(rf_rate*ttm) - 1.0)
+
+    def func(mu: float) -> float:
+        x_star = -(1.0+ttm*mu)
+        return mu * ttm - cdf_tdist(x_star, mu=0.0, vol=vol, nu=nu, ttm=ttm) - cum_mean_tdist(x_star, mu=0.0, vol=vol, nu=nu, ttm=ttm) - rf_return
+
+    mu = fsolve(func, x0=rf_rate, xtol=1e-10)
+    return mu[0]
+
+
+def compute_default_prob_tdist(ttm: float,
+                               vol: float,
+                               nu: float = 4.5,
+                               rf_rate: float = 0.0
+                               ) -> Union[float, np.ndarray]:
+    """
+    imply drift of t-distribution under risk-neutral measure
+    """
+    risk_neutral_mu = imply_drift_tdist(rf_rate=rf_rate, vol=vol, nu=nu, ttm=ttm)
+    x_star = -(1.0+risk_neutral_mu*ttm)
+    default_prob = cdf_tdist(x=x_star, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+    return default_prob
+
+
+def compute_forward_tdist(spot: Union[float, np.ndarray],
+                          ttm: float,
+                          vol: float,
+                          nu: float = 4.5,
+                          rf_rate: float = 0.0
+                          ) -> Union[float, np.ndarray]:
+    """
+    imply drift of t-distribution under risk-neutral measure
+    """
+    risk_neutral_mu = imply_drift_tdist(rf_rate=rf_rate, vol=vol, nu=nu, ttm=ttm)
+    x_star = -(1.0+risk_neutral_mu*ttm)
+    c_1 = cdf_tdist(x=x_star, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+    h_1 = cum_mean_tdist(x=x_star, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+    forward = spot * ((1.0 + risk_neutral_mu*ttm)*(1.0-c_1)-h_1)
+    return forward
+
+
+def compute_vanilla_price_tdist(spot: Union[float, np.ndarray],
+                                strikes: Union[float, np.ndarray],
+                                ttm: float,
+                                vol: float,
+                                nu: float = 4.5,
+                                optiontypes: Union[str, np.ndarray] = 'C',
+                                rf_rate: float = 0.0,
+                                is_compute_risk_neutral_mu: bool = True
+                                ) -> Union[float, np.ndarray]:
+    """
+    option pricer for t-distribution
+    """
+    discfactor = np.exp(-rf_rate*ttm)
+    if is_compute_risk_neutral_mu:
+        risk_neutral_mu = imply_drift_tdist(rf_rate=rf_rate, vol=vol, nu=nu, ttm=ttm)
+    else:
+        risk_neutral_mu = rf_rate
+    spot_star = spot*(1.0 + risk_neutral_mu*ttm)
+    x_lower_bound = -1.0-risk_neutral_mu*ttm
+
+    def compute(strike_: Union[float, np.ndarray], optiontype_: str) -> float:
+        y = strike_ / spot - (1.0 + risk_neutral_mu*ttm)
+        c_y = cdf_tdist(x=y, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+        h_y = cum_mean_tdist(x=y, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+        if optiontype_ == 'C' or optiontype_ == 'IC':
+            price_ = (-spot * h_y + (spot_star-strike_)*(1.0-c_y))
+        elif optiontype_ == 'P' or optiontype_ == 'IP':
+            c_1 = cdf_tdist(x=x_lower_bound, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+            h_1 = cum_mean_tdist(x=x_lower_bound, mu=0.0, vol=vol, nu=nu, ttm=ttm)
+            price_ = discfactor * ((strike_ - spot_star) * (c_y - c_1) - spot * (h_y - h_1)+strike_*c_1)
+        else:
+            raise NotImplementedError(f"optiontype")
+        return price_
+
+    if isinstance(optiontypes, str):
+        price = compute(strikes, optiontypes)
+    else:
+        price = np.zeros_like(strikes)
+        for idx, (strike_, optiontype_) in enumerate(zip(strikes, optiontypes)):
+            price[idx] = compute(strike_, optiontype_)
+    return price
+
+
+def infer_implied_vol_tdist(spot: float,
+                            ttm: float,
+                            strike: float,
+                            given_price: float,
+                            rf_rate: float = 0.0,
+                            optiontype: str = 'C',
+                            nu: float = 4.5,
+                            tol: float = 1e-12,
+                            is_bounds_to_nan: bool = False
+                            ) -> float:
+    """
+    compute normal implied vol
+    """
+    x1, x2 = 0.05, 10.0  # starting values
+    f = compute_vanilla_price_tdist(spot=spot, strikes=strike, ttm=ttm, vol=x1, nu=nu, rf_rate=rf_rate, optiontypes=optiontype) - given_price
+    fmid = compute_vanilla_price_tdist(spot=spot, strikes=strike, ttm=ttm, vol=x2, nu=nu, rf_rate=rf_rate, optiontypes=optiontype) - given_price
+    if f*fmid < 0.0:
+        if f < 0.0:
+            rtb = x1
+            dx = x2-x1
+        else:
+            rtb = x2
+            dx = x1-x2
+        xmid = rtb
+        for j in range(0, 100):
+            dx = dx*0.5
+            xmid = rtb+dx
+            fmid = compute_vanilla_price_tdist(spot=spot, strikes=strike, ttm=ttm, vol=xmid, nu=nu, rf_rate=rf_rate, optiontypes=optiontype) - given_price
+            if fmid <= 0.0:
+                rtb = xmid
+            if np.abs(fmid) < tol:
+                break
+        v1 = xmid
+    else:
+        if f < 0:
+            v1 = x1
+        else:
+            v1 = x2
+    if is_bounds_to_nan:  # in case vol was inferred it will return nan
+        if np.abs(v1-x1) < tol or np.abs(v1-x2) < tol:
+            v1 = np.nan
+    return v1
+
+
+def infer_tdist_implied_vols_from_model_slice_prices(ttm: float,
+                                                     spot: float,
+                                                     strikes: np.ndarray,
+                                                     optiontypes: np.ndarray,
+                                                     model_prices: np.ndarray,
+                                                     rf_rate: float,
+                                                     nu: float
+                                                     ) -> np.ndarray:
+    model_vol_ttm = np.zeros_like(strikes)
+    for idx, (strike, model_price, optiontype) in enumerate(zip(strikes, model_prices, optiontypes)):
+        model_vol_ttm[idx] = infer_implied_vol_tdist(spot=spot, ttm=ttm, rf_rate=rf_rate,
+                                                     given_price=model_price,
+                                                     strike=strike,
+                                                     optiontype=optiontype,
+                                                     nu=nu)
+    return model_vol_ttm
+
+
+class UnitTests(Enum):
+    PLOT_PDF = 1
+    PLOT_CDF = 2
+    PLOT_CUM_X = 3
+    PLOT_H = 4
+
+
+def run_unit_test(unit_test: UnitTests):
+
+    import qis as qis
+
+    x = np.linspace(-5.0, 5.0, 20000)
+    dx = x[1] - x[0]
+    ttm = 1.0
+    mu_vols = {'mu=0.0, vol=0.2': (0.0, 0.2),
+               'mu=0.2, vol=0.2': (0.2, 0.2),
+               'mu=0.2, vol=0.4': (0.2, 0.4)}
+
+    if unit_test == UnitTests.PLOT_PDF:
+        pdfs = {}
+        for key, mu_vol in mu_vols.items():
+            pdf = dx * pdf_tdist(x=x, mu=mu_vol[0], vol=mu_vol[1], nu=3.0, ttm=ttm)
+            pdfs[key] = pd.Series(pdf, index=x)
+            print(f"{key}: sum={np.sum(pdf)}, mean={np.sum(x*pdf)}, std={np.sqrt(np.sum(np.square(x)*pdf)-np.square(np.sum(x*pdf)))}")
+        pdfs = pd.DataFrame.from_dict(pdfs, orient='columns')
+        qis.plot_line(df=pdfs)
+
+    elif unit_test == UnitTests.PLOT_CDF:
+        pdfs = {}
+        cpdfs = {}
+        for key, mu_vol in mu_vols.items():
+            pdf = dx * pdf_tdist(x=x, mu=mu_vol[0], vol=mu_vol[1], nu=3.0, ttm=ttm)
+            cpdf = cdf_tdist(x=x, mu=mu_vol[0], vol=mu_vol[1], nu=3.0, ttm=ttm)
+            pdfs[f"{key}_pdf_sum"] = pd.Series(np.cumsum(pdf), index=x)
+            cpdfs[f"{key}_cdf"] = pd.Series(cpdf, index=x)
+        pdfs = pd.DataFrame.from_dict(pdfs, orient='columns')
+        cpdfs = pd.DataFrame.from_dict(cpdfs, orient='columns')
+        df = pd.concat([pdfs, cpdfs], axis=1)
+        colors = qis.get_n_colors(n=len(mu_vols.keys()))
+        qis.plot_line(df=df, colors=2*colors)
+
+    elif unit_test == UnitTests.PLOT_CUM_X:
+        pdfs = {}
+        cpdfs = {}
+        for key, mu_vol in mu_vols.items():
+            pdf = dx * pdf_tdist(x=x, mu=mu_vol[0], vol=mu_vol[1], nu=3.0, ttm=ttm)
+            cpdf = cum_mean_tdist(x=x, mu=mu_vol[0], vol=mu_vol[1], nu=3.0, ttm=ttm)
+            pdfs[f"{key}_h_pdf_sum"] = pd.Series(np.cumsum(x*pdf), index=x)
+            cpdfs[f"{key}_t_h"] = pd.Series(cpdf, index=x)
+        pdfs = pd.DataFrame.from_dict(pdfs, orient='columns')
+        cpdfs = pd.DataFrame.from_dict(cpdfs, orient='columns')
+        df = pd.concat([pdfs, cpdfs], axis=1)
+        colors = qis.get_n_colors(n=len(mu_vols.keys()))
+        qis.plot_line(df=df, colors=2*colors)
+
+    elif unit_test == UnitTests.PLOT_H:
+        x = np.linspace(-10.0, 10.0, 2000)
+        h = pd.Series(cum_mean_tdist(x=x, mu=0.5, vol=1.0, nu=3.0, ttm=1.0), index=x, name='h')
+        qis.plot_line(df=h, xlabel='x')
+
+    plt.show()
+
+
+if __name__ == '__main__':
+
+    unit_test = UnitTests.PLOT_CUM_X
+
+    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.14 → stochvolmodels-1.0.15}/stochvolmodels/pricers/gmm_pricer.py

@@ -1,5 +1,5 @@
 """
-implementation of gaussian mixture pricer
+implementation of gaussian mixture pricer and calibration
 """
 import numpy as np
 import matplotlib.pyplot as plt
@@ -14,10 +14,7 @@ from stochvolmodels.utils.funcs import to_flat_np_array, timer, npdf1
 import stochvolmodels.pricers.analytic.bsm as bsm
 from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
 from stochvolmodels.utils.config import VariableType
-
-# data
 from stochvolmodels.data.option_chain import OptionChain
-from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
 
 
 @dataclass
@@ -95,7 +92,6 @@ class GmmPricer(ModelPricer):
         if len(ttms) > 1:
             raise NotImplementedError(f"cannot calibrate to multiple slices")
         ttm = ttms[0]
-        discfactor = option_chain.discfactors[0]
 
         # p0 = (gmm_weights, gmm_mus, gmm_vols)
         if params0 is not None:
@@ -138,11 +134,12 @@ class GmmPricer(ModelPricer):
             return np.sum(params.gmm_weights) - 1.0
 
         def martingale(pars: np.ndarray) -> float:
+            # we set to 1.0, mutplication with foward will be set by pricing
             params = parse_model_params(pars=pars)
-            return np.sum(params.gmm_weights*np.exp((params.gmm_mus+0.5*params.gmm_vols*params.gmm_vols)*ttm)) - discfactor
+            return np.sum(params.gmm_weights*np.exp((params.gmm_mus+0.5*params.gmm_vols*params.gmm_vols)*ttm)) - 1.0
 
         constraints = ({'type': 'eq', 'fun': weights_sum}, {'type': 'eq', 'fun': martingale})
-        options = {'disp': True, 'ftol': 1e-10, 'maxiter': 300}
+        options = {'disp': True, 'ftol': 1e-10, 'maxiter': 500}
 
         res = minimize(objective, p0, args=None, method='SLSQP', constraints=constraints, bounds=bounds, options=options)
         fit_params = parse_model_params(pars=res.x)
@@ -175,6 +172,7 @@ class GmmPricer(ModelPricer):
             fit_params[ids_] = params0
         return fit_params
 
+
 @njit
 def compute_gmm_vanilla_price(gmm_weights: np.ndarray,
                               gmm_mus: np.ndarray,
@@ -269,6 +267,7 @@ def run_unit_test(unit_test: UnitTests):
 
     import seaborn as sns
     import qis as qis
+    from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
 
     if unit_test == UnitTests.CALIBRATOR:
         option_chain = get_btc_test_chain_data()

{stochvolmodels-1.0.14 → stochvolmodels-1.0.15}/stochvolmodels/pricers/model_pricer.py

@@ -324,6 +324,7 @@ class ModelPricer(ABC):
                                     headers: Optional[List[str]] = None,
                                     xvar_format: str = None,
                                     figsize: Tuple[float, float] = plot.FIGSIZE,
+                                    title: str = None,
                                     axs: List[plt.Subplot] = None,
                                     **kwargs
                                     ) -> plt.Figure:
@@ -369,11 +370,11 @@ class ModelPricer(ABC):
             model_vols = pd.Series(model_ivols[idx], index=strikes, name=f"Model Fit: mse={mse2:0.2%}")
             if option_chain.ids is not None:
                 if headers is not None:
-                    title = f"{headers[idx]} slice - {option_chain.ids[idx]}"
+                    title = title or f"{headers[idx]} slice - {option_chain.ids[idx]}"
                 else:
-                    title = f"Slice - {option_chain.ids[idx]}"
+                    title = title or f"Slice - {option_chain.ids[idx]}"
             else:
-                title = f"{ttm=:0.2f}"
+                title = title or f"{ttm=:0.2f}"
 
             if is_log_strike_xaxis:
                 atm_points = {'ATM': (0.0, atm_vols[idx])}

stochvolmodels-1.0.15/stochvolmodels/pricers/tdist_pricer.py

@@ -0,0 +1,203 @@
+"""
+implementation of gaussian mixture pricer and calibration
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+from dataclasses import dataclass
+from scipy.optimize import minimize
+from numba.typed import List
+from typing import Tuple
+from enum import Enum
+
+# sv 
+import stochvolmodels.pricers.analytic.tdist as td
+from stochvolmodels.utils.funcs import to_flat_np_array, timer
+from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
+from stochvolmodels.utils.config import VariableType
+
+# data
+from stochvolmodels.data.option_chain import OptionChain
+
+
+@dataclass
+class TdistParams(ModelParams):
+    drift: float
+    vol: float
+    nu: float
+    ttm: float  # ttm is important as all params are fixed to this ttm, it is not part of calibration
+
+
+class TdistPricer(ModelPricer):
+
+    def price_chain(self, option_chain: OptionChain, params: TdistParams, **kwargs) -> np.ndarray:
+        """
+        implementation of generic method price_chain using heston wrapper for tdist prices
+        """
+        model_prices_ttms = tdist_vanilla_chain_pricer(drift=params.drift,
+                                                       vol=params.vol,
+                                                       nu=params.nu,
+                                                       ttms=option_chain.ttms,
+                                                       forwards=option_chain.forwards,
+                                                       strikes_ttms=option_chain.strikes_ttms,
+                                                       optiontypes_ttms=option_chain.optiontypes_ttms,
+                                                       discfactors=option_chain.discfactors)
+
+        return model_prices_ttms
+
+    def model_mc_price_chain(self, option_chain: OptionChain, params: TdistParams,
+                             nb_path: int = 100000,
+                             variable_type: VariableType = VariableType.LOG_RETURN,
+                             **kwargs
+                             ) -> (List[np.ndarray], List[np.ndarray]):
+        raise NotImplementedError
+
+    @timer
+    def calibrate_model_params_to_chain_slice(self,
+                                              option_chain: OptionChain,
+                                              params0: TdistParams = None,
+                                              is_vega_weighted: bool = True,
+                                              is_unit_ttm_vega: bool = False,
+                                              **kwargs
+                                              ) -> TdistParams:
+        """
+        implementation of model calibration interface
+        fit: TdistParams
+        nb: always use option_chain with one slice because we need martingale condition per slice
+        """
+        ttms = option_chain.ttms
+        if len(ttms) > 1:
+            raise NotImplementedError(f"cannot calibrate to multiple slices")
+        ttm = ttms[0]
+        rf_rate = option_chain.discount_rates[0]
+
+        # p0 = (gmm_weights, gmm_mus, gmm_vols)
+        if params0 is not None:
+            p0 = np.array([params0.vol, params0.nu])
+        else:
+            p0 = np.array([0.2, 3.0])
+
+        vol_bounds = [(0.05, 10.0)]
+        nu_bounds = [(2.01, 20.0)]
+        bounds = np.concatenate((vol_bounds, nu_bounds))
+
+        x, y = option_chain.get_chain_data_as_xy()
+        market_vols = to_flat_np_array(y)  # market mid quotes
+        if is_vega_weighted:
+            vegas_ttms = option_chain.get_chain_vegas(is_unit_ttm_vega=is_unit_ttm_vega)
+            vegas_ttms = [vegas_ttm/sum(vegas_ttm) for vegas_ttm in vegas_ttms]
+            weights = to_flat_np_array(vegas_ttms)
+        else:
+            weights = np.ones_like(market_vols)
+
+        def parse_model_params(pars: np.ndarray) -> TdistParams:
+            vol = pars[0]
+            nu = pars[1]
+            drift = td.imply_drift_tdist(rf_rate=rf_rate, vol=vol, nu=nu, ttm=ttm)
+            return TdistParams(vol=vol, nu=nu, drift=drift, ttm=ttm)
+
+        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)
+            resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
+            return resid
+
+        options = {'disp': True, 'ftol': 1e-10, 'maxiter': 500}
+        res = minimize(objective, p0, args=None, method='SLSQP', bounds=bounds, options=options)
+        fit_params = parse_model_params(pars=res.x)
+
+        return fit_params
+
+    @timer
+    def calibrate_model_params_to_chain(self,
+                                        option_chain: OptionChain,
+                                        is_vega_weighted: bool = True,
+                                        is_unit_ttm_vega: bool = False,
+                                        **kwargs
+                                        ) -> List[str, TdistParams]:
+        """
+        model params are fitted per slice
+        need to splic chain to slices
+        """
+        fit_params = {}
+        params0 = None
+        for ids_ in option_chain.ids:
+            option_chain0 = OptionChain.get_slices_as_chain(option_chain, ids=[ids_])
+            params0 = self.calibrate_model_params_to_chain_slice(option_chain=option_chain0,
+                                                                 params0=params0,
+                                                                 is_vega_weighted=is_vega_weighted,
+                                                                 is_unit_ttm_vega=is_unit_ttm_vega,
+                                                                 **kwargs)
+            fit_params[ids_] = params0
+        return fit_params
+
+
+def tdist_vanilla_chain_pricer(vol: float,
+                               nu: float,
+                               drift: float,
+                               ttms: np.ndarray,
+                               forwards: np.ndarray,
+                               strikes_ttms: Tuple[np.ndarray, ...],
+                               optiontypes_ttms: Tuple[np.ndarray, ...],
+                               discfactors: np.ndarray,
+                               ) -> np.ndarray:
+    """
+    vectorised bsm deltas for array of aligned strikes, vols, and optiontypes
+    """
+    # outputs as numpy lists
+    model_prices_ttms = List()
+    for ttm, forward, discfactor, strikes_ttm, optiontypes_ttm in zip(ttms, forwards, discfactors, strikes_ttms,
+                                                                      optiontypes_ttms):
+        option_prices_ttm = td.compute_vanilla_price_tdist(spot=forward*discfactor,
+                                                           strikes=strikes_ttm,
+                                                           ttm=ttm,
+                                                           vol=vol,
+                                                           nu=nu,
+                                                           optiontypes=optiontypes_ttm,
+                                                           rf_rate=drift,
+                                                           is_compute_risk_neutral_mu=False  # drift is already adjusted
+                                                           )
+        model_prices_ttms.append(option_prices_ttm)
+
+    return model_prices_ttms
+
+
+class UnitTests(Enum):
+    CALIBRATOR = 1
+
+
+def run_unit_test(unit_test: UnitTests):
+
+    import seaborn as sns
+    import qis as qis
+    import stochvolmodels.data.test_option_chain as chains
+
+    if unit_test == UnitTests.CALIBRATOR:
+        # option_chain = chains.get_btc_test_chain_data()
+        option_chain = chains.get_spy_test_chain_data()
+        # option_chain = chains.get_gld_test_chain_data()
+
+        tdist_pricer = TdistPricer()
+        fit_params = tdist_pricer.calibrate_model_params_to_chain(option_chain=option_chain)
+
+        with sns.axes_style('darkgrid'):
+            fig, axs = plt.subplots(2, 2, figsize=(14, 12), tight_layout=True)
+            axs = qis.to_flat_list(axs)
+
+        for idx, (key, params) in enumerate(fit_params.items()):
+            print(f"{key}: {params}")
+            option_chain0 = OptionChain.get_slices_as_chain(option_chain, ids=[key])
+            tdist_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain0, params=params, axs=[axs[idx]])
+
+    plt.show()
+
+
+if __name__ == '__main__':
+
+    unit_test = UnitTests.CALIBRATOR
+
+    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.14 → stochvolmodels-1.0.15}/stochvolmodels/tests/qv_pricer.py

@@ -6,7 +6,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 from enum import Enum
 
-from stochvolmodels.pricers.analytic import mgf_pricer as mgfp
+import stochvolmodels.utils.mgf_pricer as mgfp
 from stochvolmodels.pricers.logsv import affine_expansion as afe
 from stochvolmodels.utils.config import VariableType
 from stochvolmodels.pricers.logsv_pricer import LogSVPricer, LogSvParams

stochvolmodels-1.0.14/stochvolmodels/pricers/analytic/tdist.py

@@ -1,126 +0,0 @@
-import numpy as np
-from scipy.stats import t
-from scipy.special import gamma
-from typing import Union
-
-
-def t_cum(y: float, nu: float) -> float:
-    """
-    cumulative pdf ot t-distribution
-    """
-    c = (1.0/np.sqrt(np.pi*nu))* (nu/(nu-1.0)) * gamma(0.5*(nu+1.0)) / gamma(0.5*nu)
-    f = np.power(1.0+np.square(y) / nu, -0.5*(nu-1.0))
-    return c * f
-
-
-def compute_tdist_price(forward: Union[float, np.ndarray],
-                        strikes: Union[float, np.ndarray],
-                        ttm: float,
-                        vol: float,
-                        nu: float = 4.5,
-                        optiontypes: Union[str, np.ndarray] = 'C',
-                        discfactor: float = 1.0
-                        ) -> Union[float, np.ndarray]:
-    """
-    bsm pricer for forward
-    """
-    # scaler = vol*np.sqrt(ttm)*np.sqrt(0.5*nu)*((nu-1.0)/nu)*gamma(0.5*nu)/gamma(0.5*(nu+1.0))
-    ups = vol * np.sqrt(ttm) * np.sqrt((nu - 2.0) / nu)
-
-    def compute(strike_: Union[float, np.ndarray], optiontype_: str) -> float:
-        y = strike_ / forward - 1.0
-        if optiontype_ == 'C' or optiontype_ == 'IC':
-            price_ = discfactor * (forward * t_cum(y/ups, nu=nu) * ups + (forward - strike_) * (1.0 - t.cdf(y/ups, nu)))
-        elif optiontype_ == 'P' or optiontype_ == 'IP':
-            price_ = discfactor * (forward * t_cum(y/ups, nu=nu) * ups - (forward - strike_) * t.cdf(y/ups, nu))
-        else:
-            raise NotImplementedError(f"optiontype")
-        return price_
-
-    if isinstance(optiontypes, str):
-        price = compute(strikes, optiontypes)
-    else:
-        price = np.zeros_like(strikes)
-        for idx, (strike_, optiontype_) in enumerate(zip(strikes, optiontypes)):
-            price[idx] = compute(strike_, optiontype_)
-    return price
-
-
-def compute_compute_negative_prob(ttms: np.ndarray,
-                                  vol: float,
-                                  drift: float = 0.0,
-                                  nu: float = 3.5
-                                  ) -> Union[float, np.ndarray]:
-    """
-    bsm pricer for forward
-    """
-    probs = np.zeros_like(ttms)
-    q = vol*np.sqrt(0.5*nu)*((nu-1.0)/nu)*gamma(0.5*nu)/gamma(0.5*(nu+1.0))
-    for idx, ttm in enumerate(ttms):
-        scaler = q*np.sqrt(ttm)
-        ups = 1.0 / scaler
-        probs[idx] = t.cdf(-(1.0+drift*ttm)*ups, nu)
-    return probs
-
-
-def infer_tdist_implied_vol(forward: float,
-                            ttm: float,
-                            strike: float,
-                            given_price: float,
-                            discfactor: float = 1.0,
-                            optiontype: str = 'C',
-                            nu: float = 4.5,
-                            tol: float = 1e-12,
-                            is_bounds_to_nan: bool = False
-                            ) -> float:
-    """
-    compute normal implied vol
-    """
-    x1, x2 = 0.05, 10.0  # starting values
-    f = compute_tdist_price(forward=forward, strikes=strike, ttm=ttm, vol=x1, nu=nu, discfactor=discfactor, optiontypes=optiontype) - given_price
-    fmid = compute_tdist_price(forward=forward, strikes=strike, ttm=ttm, vol=x2, nu=nu, discfactor=discfactor, optiontypes=optiontype) - given_price
-    if f*fmid < 0.0:
-        if f < 0.0:
-            rtb = x1
-            dx = x2-x1
-        else:
-            rtb = x2
-            dx = x1-x2
-        xmid = rtb
-        for j in range(0, 100):
-            dx = dx*0.5
-            xmid = rtb+dx
-            fmid = compute_tdist_price(forward=forward, strikes=strike, ttm=ttm, vol=xmid, nu=nu, discfactor=discfactor, optiontypes=optiontype) - given_price
-            if fmid <= 0.0:
-                rtb = xmid
-            if np.abs(fmid) < tol:
-                break
-        v1 = xmid
-    else:
-        if f < 0:
-            v1 = x1
-        else:
-            v1 = x2
-    if is_bounds_to_nan:  # in case vol was inferred it will return nan
-        if np.abs(v1-x1) < tol or np.abs(v1-x2) < tol:
-            v1 = np.nan
-    return v1
-
-
-def infer_tdist_implied_vols_from_model_slice_prices(ttm: float,
-                                                     forward: float,
-                                                     strikes: np.ndarray,
-                                                     optiontypes: np.ndarray,
-                                                     model_prices: np.ndarray,
-                                                     discfactor: float,
-                                                     nu: float
-                                                     ) -> np.ndarray:
-    model_vol_ttm = np.zeros_like(strikes)
-    for idx, (strike, model_price, optiontype) in enumerate(zip(strikes, model_prices, optiontypes)):
-        model_vol_ttm[idx] = infer_tdist_implied_vol(forward=forward, ttm=ttm, discfactor=discfactor,
-                                                     given_price=model_price,
-                                                     strike=strike,
-                                                     optiontype=optiontype,
-                                                     nu=nu)
-    return model_vol_ttm
-