stochvolmodels 1.0.6__tar.gz → 1.0.8__tar.gz

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stochvolmodels
-Version: 1.0.6
+Version: 1.0.8
 Summary: Implementation of stochastic volatility models for option pricing
 Home-page: https://github.com/ArturSepp/StochVolModels
 License: LICENSE.txt
@@ -50,12 +50,28 @@ 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
 
+## Illustrations
+
+As illustrations of different analytics, this packadge includes the computations and visualisations
+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
+```
+
+
 ## Installation
 ```python 
 pip install stochvolmodels
 ```
 
-
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/README.md

@@ -11,12 +11,28 @@ 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
 
+## Illustrations
+
+As illustrations of different analytics, this packadge includes the computations and visualisations
+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
+```
+
+
 ## Installation
 ```python 
 pip install stochvolmodels
 ```
 
-
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/pyproject.toml

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

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/__init__.py

@@ -56,7 +56,7 @@ from stochvolmodels.pricers.logsv_pricer import (
     LOGSV_BTC_PARAMS,
     LogSVPricer,
     LogSvParams,
-    ModelCalibrationType,
+    LogsvModelCalibrationType,
     ConstraintsType
 )
 
@@ -92,6 +92,40 @@ from stochvolmodels.utils.plots import (
     vol_slice_fit
 )
 
+
+from stochvolmodels.pricers.core.mgf_pricer import (
+    compute_integration_weights,
+    digital_slice_pricer_with_mgf_grid,
+    get_phi_grid,
+    get_psi_grid,
+    get_theta_grid,
+    get_transform_var_grid,
+    pdf_with_mgf_grid,
+    slice_pricer_with_mgf_grid_with_gamma,
+    slice_qvar_pricer_with_a_grid,
+    vanilla_slice_pricer_with_mgf_grid,
+    slice_pricer_with_mgf_grid_with_gamma,
+)
+
+from stochvolmodels.pricers.logsv.affine_expansion import (
+    ExpansionOrder,
+    VariableType,
+    compute_logsv_a_mgf_grid,
+    func_a_ode_quadratic_terms,
+    func_rhs,
+    func_rhs_jac,
+    get_expansion_n,
+    get_init_conditions_a,
+    solve_a_ode_grid,
+    solve_analytic_ode_for_a,
+    solve_analytic_ode_for_a0,
+    solve_analytic_ode_grid_phi,
+    solve_ode_for_a,
+    compute_logsv_a_mgf_grid,
+    solve_a_ode_grid,
+    solve_ode_for_a,
+)
+
 from stochvolmodels.pricers.core.config import VariableType
 
 from stochvolmodels.pricers.core.mc_payoffs import compute_mc_vars_payoff

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/data/option_chain.py

@@ -272,4 +272,4 @@ class OptionChain:
                    strikes_ttms=List([strikes for _ in ttms]),
                    bid_ivs=List([flat_vol*np.ones_like(strikes) for _ in ttms]),
                    ask_ivs=List([flat_vol*np.ones_like(strikes) for _ in ttms]),
-                   optiontypes_ttms=List([np.where(strikes >= forward, 'C', 'P') for forward in forwards]))
+                   optiontypes_ttms=List([np.where(strikes >= forward, 'C', 'P') for forward in forwards]))

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/pricers/core/mgf_pricer.py

@@ -27,7 +27,10 @@ def get_phi_grid(is_spot_measure: bool = True,
         else:
             real_p = real_phi
     else:
-        real_p = 0.5
+        if real_phi is None:
+            real_p = 0.5
+        else:
+            real_p = real_phi
     phi_grid = real_p + 1j * p
     return phi_grid
 
@@ -109,18 +112,17 @@ def compute_integration_weights(var_grid: np.ndarray,
 
 
 @njit(cache=False, fastmath=True)
-def slice_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
-                               phi_grid: np.ndarray,
-                               ttm: float,
-                               forward: float,
-                               strikes: np.ndarray,
-                               optiontypes: np.ndarray,
-                               discfactor: float = 1.0,
-                               is_spot_measure: bool = True,
-                               is_simpson: bool = True
-                               ) -> np.ndarray:
+def vanilla_slice_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
+                                       phi_grid: np.ndarray,
+                                       forward: float,
+                                       strikes: np.ndarray,
+                                       optiontypes: np.ndarray,
+                                       discfactor: float = 1.0,
+                                       is_spot_measure: bool = True,
+                                       is_simpson: bool = True
+                                       ) -> np.ndarray:
     """
-    generic function for pricing options on the spot given the mgf grid
+    generic function for pricing vanilla 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
@@ -128,7 +130,7 @@ def slice_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
     p = np.imag(phi_grid)
     dp = compute_integration_weights(var_grid=phi_grid, is_simpson=is_simpson)
 
-    if np.all(np.abs(np.real(phi_grid))-0.5 < 1e-10):  # optimized for phi = +/-0.5 + i*p
+    if np.all(np.equal(np.abs(np.real(phi_grid)), 0.5)):  # optimized for phi = +/-0.5 + i*p
         p_payoff = (dp / np.pi) / (p * p + 0.25) + 1j * 0.0  # add zero complex part for numba
     else:
         if is_spot_measure:
@@ -159,6 +161,54 @@ def slice_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
     return option_prices
 
 
+@njit(cache=False, fastmath=True)
+def digital_slice_pricer_with_mgf_grid(log_mgf_grid: np.ndarray,
+                                       phi_grid: np.ndarray,
+                                       forward: float,
+                                       strikes: np.ndarray,
+                                       optiontypes: np.ndarray,
+                                       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
+    """
+    dp = compute_integration_weights(var_grid=phi_grid, is_simpson=is_simpson)
+
+    # we can use positive or negative phi_real
+    if np.all(np.real(phi_grid) < 0.0):  # use calls
+        is_all_calls = True
+        p_payoff = - (dp / np.pi) / (phi_grid)  # for calls
+    else:
+        is_all_calls = False
+        p_payoff = (dp / np.pi) / (phi_grid) # for puts
+
+    log_strikes = np.log(forward/strikes)
+    option_prices = np.zeros_like(log_strikes)
+    for idx, (x, strike, type_) in enumerate(zip(log_strikes, strikes, optiontypes)):
+        # compute sum using trapesoidal rule
+        digital_option_price = np.nansum(np.real(p_payoff*np.exp(-x * phi_grid + log_mgf_grid)))
+        if type_ == 'C':
+            if is_all_calls:
+                price = digital_option_price
+            else:
+                price = 1.0 - digital_option_price
+        elif type_ == 'P':
+            if is_all_calls:
+                price = 1.0 - digital_option_price
+            else:
+                price = digital_option_price
+        else:
+            raise ValueError(f"not implemented")
+
+        option_prices[idx] = discfactor * price
+
+    return option_prices
+
+
 #@njit(cache=False, fastmath=True)
 def slice_pricer_with_mgf_grid_with_gamma(log_mgf_grid: np.ndarray,
                                           phi_grid: np.ndarray,

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/pricers/hawkes_jd_pricer.py

@@ -365,14 +365,13 @@ def hawkesjd_chain_pricer(model_params: HawkesJDParams,
                                                        model_params=model_params)
 
         if variable_type == VariableType.LOG_RETURN:
-            option_prices = mgfp.slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                            phi_grid=phi_grid,
-                                                            ttm=ttm,
-                                                            forward=forward,
-                                                            strikes=strikes_ttm,
-                                                            optiontypes=optiontypes_ttm,
-                                                            discfactor=discfactor,
-                                                            is_spot_measure=is_spot_measure)
+            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,
+                                                                    is_spot_measure=is_spot_measure)
         else:
             raise NotImplementedError
 

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/pricers/heston_pricer.py

@@ -11,7 +11,7 @@ from numba.typed import List
 from typing import Tuple
 from enum import Enum
 
-from stochvolmodels.pricers.core.mgf_pricer import get_transform_var_grid, slice_pricer_with_mgf_grid
+from stochvolmodels.pricers.core.mgf_pricer import get_transform_var_grid, vanilla_slice_pricer_with_mgf_grid
 from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
 from stochvolmodels.data.option_chain import OptionChain
 from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
@@ -213,13 +213,12 @@ def heston_chain_pricer(v0: float,
                                                            a_t0=a_t0,
                                                            b_t0=b_t0)
 
-        option_prices = slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                   phi_grid=phi_grid,
-                                                   ttm=ttm,
-                                                   forward=forward,
-                                                   discfactor=discfactor,
-                                                   strikes=strikes_ttm,
-                                                   optiontypes=optiontypes_ttm)
+        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)
         model_prices_ttms.append(option_prices)
         ttm0 = ttm
 

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/pricers/logsv_pricer.py

@@ -29,9 +29,10 @@ from stochvolmodels.data.option_chain import OptionChain
 from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
 
 
-class ModelCalibrationType(Enum):
-    PARAMS5 = 1  # v0, theta, kappa1, beta, volvol
-    PARAMS6 = 2  # v0, theta, kappa1, kappa2, beta, volvol
+class LogsvModelCalibrationType(Enum):
+    PARAMS4 = 1  # v0, theta, beta, volvol; kappa1, kappa2 are set externally
+    PARAMS5 = 2  # v0, theta, kappa1, beta, volvol
+    PARAMS6 = 3  # v0, theta, kappa1, kappa2, beta, volvol
 
 
 class ConstraintsType(Enum):
@@ -59,8 +60,8 @@ class LogSvParams(ModelParams):
             self.kappa2 = self.kappa1 / self.theta
 
     def to_dict(self) -> Dict[str, Any]:
-        #         return dict(sigma0=self.sigma0, theta=self.theta, kappa1=self.kappa1, kappa2=self.kappa2, beta=self.beta, volvol=self.volvol)
         return asdict(self)
+
     @property
     def kappa(self) -> float:
         return self.kappa1+self.kappa2*self.theta
@@ -220,10 +221,10 @@ class LogSVPricer(ModelPricer):
     @timer
     def calibrate_model_params_to_chain(self,
                                         option_chain: OptionChain,
-                                        params0: LogSvParams = None,
+                                        params0: LogSvParams,
                                         is_vega_weighted: bool = True,
                                         is_unit_ttm_vega: bool = False,
-                                        model_calibration_type: ModelCalibrationType = ModelCalibrationType.PARAMS5,
+                                        model_calibration_type: LogsvModelCalibrationType = LogsvModelCalibrationType.PARAMS5,
                                         constraints_type: ConstraintsType = ConstraintsType.UNCONSTRAINT,
                                         **kwargs
                                         ) -> LogSvParams:
@@ -245,7 +246,39 @@ class LogSVPricer(ModelPricer):
         else:
             weights = np.ones_like(market_vols)
 
-        if model_calibration_type == ModelCalibrationType.PARAMS5:
+        # implement different calibrato types
+        if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
+            # fit: v0, theta, beta, volvol; kappa1, kappa2 is given with params0
+            if params0 is not None:
+                p0 = np.array([params0.sigma0, params0.theta, params0.beta, params0.volvol])
+            else:
+                p0 = np.array([0.8, 0.8, -0.2, 2.0])
+            bounds = ((0.01, 2.0), (0.01, 2.0), (-5.0, 3.0), (0.1, 10.0))
+
+            def objective(pars: np.ndarray, args: np.ndarray) -> float:
+                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
+                params = LogSvParams(sigma0=v0, theta=theta, kappa1=params0.kappa1,
+                                     kappa2=params0.kappa2, beta=beta, volvol=volvol)
+                model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params,
+                                                                vol_scaler=vol_scaler)
+                resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
+                return resid
+
+            def martingale_measure(pars: np.ndarray) -> float:
+                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
+                return params0.kappa2 - beta
+
+            def inverse_measure(pars: np.ndarray) -> float:
+                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
+                return params0.kappa2 - 2.0 * beta
+
+            def vol_4thmoment_finite(pars: np.ndarray) -> float:
+                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
+                vartheta2 = beta * beta + volvol * volvol
+                kappa = params0.kappa1 + params0.kappa2 * theta
+                return kappa - 1.5 * vartheta2
+
+        elif model_calibration_type == LogsvModelCalibrationType.PARAMS5:
             # fit: v0, theta, kappa1, beta, volvol; kappa2 is mapped as kappa1 / theta
             if params0 is not None:
                 p0 = np.array([params0.sigma0, params0.theta, params0.kappa1, params0.beta, params0.volvol])
@@ -275,11 +308,6 @@ class LogSVPricer(ModelPricer):
                 kappa = kappa1 + kappa2 * theta
                 return kappa - 1.5*vartheta2
 
-            def kurtosis_finite(pars: np.ndarray) -> float:
-                v0, theta, kappa1, beta, volvol = pars[0], pars[1], pars[2], pars[3], pars[4]
-                vartheta2 = beta*beta + volvol*volvol
-                return kappa1 - 1.5*vartheta2
-
         else:
             raise NotImplementedError(f"{model_calibration_type}")
 
@@ -320,7 +348,15 @@ class LogSVPricer(ModelPricer):
 
         popt = res.x
 
-        if model_calibration_type == ModelCalibrationType.PARAMS5:
+        if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
+            fit_params = LogSvParams(sigma0=popt[0],
+                                     theta=popt[1],
+                                     kappa1=params0.kappa1,
+                                     kappa2=params0.kappa2,
+                                     beta=popt[2],
+                                     volvol=popt[3])
+
+        elif model_calibration_type == LogsvModelCalibrationType.PARAMS5:
             fit_params = LogSvParams(sigma0=popt[0],
                                      theta=popt[1],
                                      kappa1=popt[2],
@@ -481,14 +517,13 @@ def logsv_chain_pricer(params: LogSvParams,
                                                           **params.to_dict())
 
         if variable_type == VariableType.LOG_RETURN:
-            option_prices = mgfp.slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                            phi_grid=phi_grid,
-                                                            ttm=ttm,
-                                                            forward=forward,
-                                                            strikes=strikes_ttm,
-                                                            optiontypes=optiontypes_ttm,
-                                                            discfactor=discfactor,
-                                                            is_spot_measure=is_spot_measure)
+            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,
+                                                                    is_spot_measure=is_spot_measure)
 
         elif variable_type == VariableType.Q_VAR:
             option_prices = mgfp.slice_qvar_pricer_with_a_grid(log_mgf_grid=log_mgf_grid,

{stochvolmodels-1.0.6 → stochvolmodels-1.0.8}/stochvolmodels/tests/bsm_mgf_pricer.py

@@ -51,13 +51,12 @@ def bsm_slice_pricer(ttm: float,
 
     if variable_type == VariableType.LOG_RETURN:
         log_mgf_grid, phi_grid = compute_normal_mgf_grid(ttm=ttm, vol=vol, is_spot_measure=is_spot_measure)
-        bsm_prices = mgfp.slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
-                                                     phi_grid=phi_grid,
-                                                     ttm=ttm,
-                                                     forward=forward,
-                                                     strikes=strikes,
-                                                     optiontypes=optiontypes,
-                                                     is_spot_measure=is_spot_measure)
+        bsm_prices = mgfp.vanilla_slice_pricer_with_mgf_grid(log_mgf_grid=log_mgf_grid,
+                                                             phi_grid=phi_grid,
+                                                             forward=forward,
+                                                             strikes=strikes,
+                                                             optiontypes=optiontypes,
+                                                             is_spot_measure=is_spot_measure)
         bsm_ivols = infer_bsm_ivols_from_model_chain_prices(ttms=np.array([ttm]),
                                                             forwards=np.array([forward]),
                                                             discfactors=np.array([1.0]),