stochvolmodels 1.0.12__tar.gz → 1.0.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stochvolmodels
-Version: 1.0.12
+Version: 1.0.15
 Summary: Implementation of stochastic volatility models for option pricing
 Home-page: https://github.com/ArturSepp/StochVolModels
 License: LICENSE.txt
@@ -50,32 +50,6 @@ For the analytic implementation of stochastic volatility models, the package pro
 1) Interface for analytical pricing of vanilla options using Fourier transform with closed-form solution for moment generating function
 2) Interface for Monte-Carlo simulations of model dynamics
 
-## Supporting Illustrations for Public Papers 
-
-As illustrations of different analytics, this packadge includes module ```my_papers``` 
-with codes for computations and visualisations featured in several papers
-for 
-
-1) "Log-normal Stochastic Volatility Model with Quadratic Drift" by Sepp A and Rakhmonov P, SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2522425
-```python 
-stochvolmodels/my_papers/logsv_model_wtih_quadratic_drift
-```
-
-
-2) "What is a robust stochastic volatility model" by Sepp A and Rakhmonov P,
-SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4647027
-```python 
-stochvolmodels/my_papers/volatility_models
-```
-
-
-3) "Valuation and Hedging of Cryptocurrency Inverse Options" by Sepp A and Lucic V, 
-SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4606748 
-```python 
-stochvolmodels/my_papers/inverse_options
-```
-
-
 
 ## Installation
 ```python 
@@ -92,6 +66,8 @@ pip install stochvolmodels
    3. [Comparison of model prices vs MC](#subparagraph3)
    4. [Analysis and figures for the paper](#subparagraph4)
 3. [Running Heston SV pricer](#heston)
+4. [Supporting Illustrations for Public Papers](#papers)
+
 
 Running model calibration to sample Bitcoin options data
 
@@ -256,3 +232,32 @@ pricer.plot_model_slices_in_params(option_slice=option_slice, params_dict=params
 
 plt.show()
 ```
+
+
+## Supporting Illustrations for Public Papers <a name="papers"></a>
+
+As illustrations of different analytics, this packadge includes module ```my_papers``` 
+with codes for computations and visualisations featured in several papers
+for 
+
+1) "Log-normal Stochastic Volatility Model with Quadratic Drift" by Sepp A and Rakhmonov P, SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2522425
+```python 
+stochvolmodels/my_papers/logsv_model_wtih_quadratic_drift
+```
+
+
+2) "What is a robust stochastic volatility model" by Sepp A and Rakhmonov P,
+SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4647027
+```python 
+stochvolmodels/my_papers/volatility_models
+```
+
+
+3) "Valuation and Hedging of Cryptocurrency Inverse Options" by Sepp A and Lucic V, 
+SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4606748 
+```python 
+stochvolmodels/my_papers/inverse_options
+```
+
+
+

{stochvolmodels-1.0.12 → stochvolmodels-1.0.15}/README.md

@@ -11,32 +11,6 @@ For the analytic implementation of stochastic volatility models, the package pro
 1) Interface for analytical pricing of vanilla options using Fourier transform with closed-form solution for moment generating function
 2) Interface for Monte-Carlo simulations of model dynamics
 
-## Supporting Illustrations for Public Papers 
-
-As illustrations of different analytics, this packadge includes module ```my_papers``` 
-with codes for computations and visualisations featured in several papers
-for 
-
-1) "Log-normal Stochastic Volatility Model with Quadratic Drift" by Sepp A and Rakhmonov P, SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2522425
-```python 
-stochvolmodels/my_papers/logsv_model_wtih_quadratic_drift
-```
-
-
-2) "What is a robust stochastic volatility model" by Sepp A and Rakhmonov P,
-SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4647027
-```python 
-stochvolmodels/my_papers/volatility_models
-```
-
-
-3) "Valuation and Hedging of Cryptocurrency Inverse Options" by Sepp A and Lucic V, 
-SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4606748 
-```python 
-stochvolmodels/my_papers/inverse_options
-```
-
-
 
 ## Installation
 ```python 
@@ -53,6 +27,8 @@ pip install stochvolmodels
    3. [Comparison of model prices vs MC](#subparagraph3)
    4. [Analysis and figures for the paper](#subparagraph4)
 3. [Running Heston SV pricer](#heston)
+4. [Supporting Illustrations for Public Papers](#papers)
+
 
 Running model calibration to sample Bitcoin options data
 
@@ -216,4 +192,32 @@ pricer = HestonPricer()
 pricer.plot_model_slices_in_params(option_slice=option_slice, params_dict=params_dict)
 
 plt.show()
-```
+```
+
+
+## Supporting Illustrations for Public Papers <a name="papers"></a>
+
+As illustrations of different analytics, this packadge includes module ```my_papers``` 
+with codes for computations and visualisations featured in several papers
+for 
+
+1) "Log-normal Stochastic Volatility Model with Quadratic Drift" by Sepp A and Rakhmonov P, SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2522425
+```python 
+stochvolmodels/my_papers/logsv_model_wtih_quadratic_drift
+```
+
+
+2) "What is a robust stochastic volatility model" by Sepp A and Rakhmonov P,
+SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4647027
+```python 
+stochvolmodels/my_papers/volatility_models
+```
+
+
+3) "Valuation and Hedging of Cryptocurrency Inverse Options" by Sepp A and Lucic V, 
+SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4606748 
+```python 
+stochvolmodels/my_papers/inverse_options
+```
+
+

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.12"
+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.12 → 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,13 +115,20 @@ from stochvolmodels.pricers.gmm_pricer import (
     GmmPricer
 )
 
+from stochvolmodels.pricers.tdist_pricer import (
+    TdistParams,
+    TdistPricer
+)
+
 
 from stochvolmodels.data.option_chain import OptionChain, OptionSlice
 
+"""
 from stochvolmodels.data.fetch_option_chain import (generate_vol_chain_np,
                                                     load_option_chain,
                                                     sample_option_chain_at_times,
                                                     load_price_data)
+"""
 
 from stochvolmodels.data.test_option_chain import (
     get_btc_test_chain_data,
@@ -148,3 +159,6 @@ from stochvolmodels.utils.plots import (
     set_y_limits,
     vol_slice_fit
 )
+
+
+from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar

{stochvolmodels-1.0.12 → 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
 """
 
@@ -852,10 +853,10 @@ def get_qv_options_test_chain_data(num_strikes: int = 21) -> OptionChain:
     forwards = array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
     discfactors = array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
     strikes_ttm = np.linspace(0.75, 1.5, num_strikes)
-    strikes_ttms = (strikes_ttm, strikes_ttm, strikes_ttm, strikes_ttm)
+    strikes_ttms = (strikes_ttm, strikes_ttm, strikes_ttm, strikes_ttm, strikes_ttm, strikes_ttm)
 
     optiontypes_ttm = np.full(strikes_ttm.shape, 'C')
-    optiontypes_ttms = (optiontypes_ttm, optiontypes_ttm, optiontypes_ttm, optiontypes_ttm)
+    optiontypes_ttms = (optiontypes_ttm, optiontypes_ttm, optiontypes_ttm, optiontypes_ttm, optiontypes_ttm, optiontypes_ttm)
 
     data = OptionChain(ids=ids,
                        ttms=ttms,

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.12 → 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,
@@ -191,6 +189,7 @@ def compute_gmm_vanilla_price(gmm_weights: np.ndarray,
     price = 0.0
     for gmm_weight, gmm_mu, gmm_vol in zip(gmm_weights, gmm_mus, gmm_vols):
         forward_i = forward*np.exp((gmm_mu+0.5*gmm_vol*gmm_vol)*ttm)
+        # forward is vol-adjusted
         price_i = bsm.compute_bsm_vanilla_price(forward=forward_i,
                                                 strike=strike,
                                                 ttm=ttm,
@@ -268,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.12 → stochvolmodels-1.0.15}/stochvolmodels/pricers/heston_pricer.py

@@ -13,10 +13,10 @@ from enum import Enum
 
 # stochvolmodels
 from stochvolmodels.utils.funcs import to_flat_np_array, set_time_grid, timer
-from stochvolmodels.utils.mgf_pricer import get_transform_var_grid, vanilla_slice_pricer_with_mgf_grid
 from stochvolmodels.utils.config import VariableType
 from stochvolmodels.utils.mc_payoffs import compute_mc_vars_payoff
 from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
+import stochvolmodels.utils.mgf_pricer as mgfp
 
 # data
 from stochvolmodels.data.option_chain import OptionChain
@@ -192,11 +192,14 @@ def heston_chain_pricer(v0: float,
                         strikes_ttms: Tuple[np.ndarray, ...],
                         optiontypes_ttms: Tuple[np.ndarray, ...],
                         discfactors: np.ndarray,
+                        variable_type: VariableType = VariableType.LOG_RETURN,
                         vol_scaler: float = None  # run calibration on same vol_scaler
                         ) -> List[np.ndarray]:
 
     # starting values
-    phi_grid, psi_grid, theta_grid = get_transform_var_grid(vol_scaler=vol_scaler or np.sqrt(v0*ttms[-1]))
+    if vol_scaler is None:
+        vol_scaler = np.minimum(0.3, np.sqrt(v0*ttms[0]))
+    phi_grid, psi_grid, theta_grid = mgfp.get_transform_var_grid(vol_scaler=vol_scaler)
     a_t0, b_t0 = np.zeros(phi_grid.shape[0], dtype=np.complex128), np.zeros(phi_grid.shape[0], dtype=np.complex128)
     ttm0 = 0.0
 
@@ -213,13 +216,26 @@ def heston_chain_pricer(v0: float,
                                                            psi_grid=psi_grid,
                                                            a_t0=a_t0,
                                                            b_t0=b_t0)
-
-        option_prices = vanilla_slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                           phi_grid=phi_grid,
-                                                           forward=forward,
-                                                           discfactor=discfactor,
-                                                           strikes=strikes_ttm,
-                                                           optiontypes=optiontypes_ttm)
+        
+        if variable_type == VariableType.LOG_RETURN:
+            option_prices = mgfp.vanilla_slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
+                                                                    phi_grid=phi_grid,
+                                                                    forward=forward,
+                                                                    strikes=strikes_ttm,
+                                                                    optiontypes=optiontypes_ttm,
+                                                                    discfactor=discfactor)
+
+        elif variable_type == VariableType.Q_VAR:
+            option_prices = mgfp.slice_qvar_pricer_with_a_grid(log_mgf_grid=log_mgf_grid,
+                                                               psi_grid=psi_grid,
+                                                               ttm=ttm,
+                                                               forward=forward,
+                                                               strikes=strikes_ttm,
+                                                               optiontypes=optiontypes_ttm,
+                                                               discfactor=discfactor)
+        else:
+            raise NotImplementedError(f"variable_type={variable_type}")
+            
         model_prices_ttms.append(option_prices)
         ttm0 = ttm
 
@@ -330,10 +346,12 @@ class UnitTests(Enum):
     SLICE_PRICER = 2
     CALIBRATOR = 3
     MC_COMPARISION = 4
-
+    MC_COMPARISION_QVAR = 5
 
 def run_unit_test(unit_test: UnitTests):
 
+    import stochvolmodels.data.test_option_chain as chains
+
     if unit_test == UnitTests.CHAIN_PRICER:
         params = HestonParams(v0=0.85**2,
                               theta=1.4**2,
@@ -392,12 +410,33 @@ def run_unit_test(unit_test: UnitTests):
         heston_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                              params=BTC_HESTON_PARAMS)
 
+    elif unit_test == UnitTests.MC_COMPARISION_QVAR:
+        from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar
+        from stochvolmodels.pricers.logsv_pricer import LogSvParams
+        heston_pricer = HestonPricer()
+        ttms = {'1m': 1.0/12.0, '6m': 0.5}
+        option_chain = chains.get_qv_options_test_chain_data()
+        option_chain = OptionChain.get_slices_as_chain(option_chain, ids=list(ttms.keys()))
+        LOGSV_BTC_PARAMS = LogSvParams(sigma0=0.8376, theta=1.0413, kappa1=3.1844, kappa2=3.058, beta=0.1514,
+                                       volvol=1.8458)
+
+        forwards = np.array([compute_analytic_qvar(params=LOGSV_BTC_PARAMS, ttm=ttm, n_terms=4) for ttm in ttms.values()])
+        print(f"QV forwards = {forwards}")
+
+        option_chain.forwards = forwards  # replace forwards to imply BSM vols
+        option_chain.strikes_ttms = List(forward * strikes_ttm for forward, strikes_ttm in zip(option_chain.forwards, option_chain.strikes_ttms))
+
+        fig = heston_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
+                                                   params=BTC_HESTON_PARAMS,
+                                                   variable_type=VariableType.Q_VAR,
+                                                   nb_path=200000)
+
     plt.show()
 
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.MC_COMPARISION
+    unit_test = UnitTests.CALIBRATOR
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.12 → stochvolmodels-1.0.15}/stochvolmodels/pricers/logsv_pricer.py

@@ -770,13 +770,16 @@ class UnitTests(Enum):
     SLICE_PRICER = 2
     CALIBRATOR = 3
     MC_COMPARISION = 4
-    VOL_PATHS = 5
-    TERMINAL_VALUES = 6
-    MMA_INVERSE_MEASURE_VS_MC = 7
+    MC_COMPARISION_QVAR = 5
+    VOL_PATHS = 6
+    TERMINAL_VALUES = 7
+    MMA_INVERSE_MEASURE_VS_MC = 8
 
 
 def run_unit_test(unit_test: UnitTests):
 
+    import stochvolmodels.data.test_option_chain as chains
+
     if unit_test == UnitTests.CHAIN_PRICER:
         option_chain = get_btc_test_chain_data()
         logsv_pricer = LogSVPricer()
@@ -822,6 +825,22 @@ def run_unit_test(unit_test: UnitTests):
         logsv_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                             params=LOGSV_BTC_PARAMS)
 
+    elif unit_test == UnitTests.MC_COMPARISION_QVAR:
+        from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar
+        logsv_pricer = LogSVPricer()
+        ttms = {'1m': 1.0/12.0, '6m': 0.5}
+        option_chain = chains.get_qv_options_test_chain_data()
+        option_chain = OptionChain.get_slices_as_chain(option_chain, ids=list(ttms.keys()))
+        forwards = np.array([compute_analytic_qvar(params=LOGSV_BTC_PARAMS, ttm=ttm, n_terms=4) for ttm in ttms.values()])
+        print(f"QV forwards = {forwards}")
+
+        option_chain.forwards = forwards  # replace forwards to imply BSM vols
+        option_chain.strikes_ttms = List(forward * strikes_ttm for forward, strikes_ttm in zip(option_chain.forwards, option_chain.strikes_ttms))
+
+        fig = logsv_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
+                                                  params=LOGSV_BTC_PARAMS,
+                                                  variable_type=VariableType.Q_VAR)
+    
     elif unit_test == UnitTests.VOL_PATHS:
         logsv_pricer = LogSVPricer()
         nb_path = 10
@@ -859,7 +878,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.VOL_PATHS
+    unit_test = UnitTests.MC_COMPARISION_QVAR
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.12 → 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.12 → 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.12/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
-