sdevpy 1.0.7__tar.gz → 1.0.8__tar.gz

{sdevpy-1.0.7 → sdevpy-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.7
+Version: 1.0.8
 Summary: Python package for Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python
@@ -17,6 +17,7 @@ Requires-Dist: holidays
 Requires-Dist: pandas_market_calendars
 Requires-Dist: openpyxl
 Requires-Dist: colorlog
+Requires-Dist: scikit-learn
 
 # SDev.Python
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.7"
+version = "1.0.8"
 license-files = []
 authors = [{ name="Sebastien Gurrieri", email="sebgur@gmail.com" }]
 description = "Python package for Finance"
@@ -15,15 +15,20 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = ["pandas", "numpy", "scipy", "matplotlib", "holidays",
-                "pandas_market_calendars", "openpyxl", "colorlog"
+                "pandas_market_calendars", "openpyxl", "colorlog",
+                "scikit-learn"
 ]
 #dependencies = ["pyperclip", "tensorflow", "scikit-learn",
 # "tensorflow_probability", "silence_tensorflow"]
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["sdevpy*", "notebooks*"]  # Only include these
-#exclude = ["notebooks*", "spreadsheets*"]      # Exclude these
+include = ["sdevpy*"] # Only include these
+exclude = ["sdevpy/volatility/impliedvol/models/tssvi2*"]
+#exclude = ["notebooks*", "spreadsheets*"] # Exclude these
+
+[tool.setuptools.package-data]
+"sdevpy" = ["datasets/**/*", "notebooks/**/*.ipynb"]
 
 [tool.ruff]
 line-length = 120

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/analytics/americantree.py

@@ -7,15 +7,15 @@ from sdevpy.tree import trees
 from sdevpy.tree.trees import Payoff
 
 
-def option_price(ttm, strike, is_call, is_american, spot, vol, rf_rate, div_rate, disc_rate,
-                 method='trinomial', n_steps = 30):
+def option_price(ttm: float, strike: float, is_call: bool, is_american: bool, spot: float, vol: float,
+                 rf_rate: float, div_rate: float, disc_rate: float, method: str='trinomial', n_steps: int=30):
     """ Price of an American option using binomial or trinomial trees under Black-Scholes model """
     payoff = Payoff(ttm, strike, is_call, is_american)
     return price(payoff, spot, vol, rf_rate, div_rate, disc_rate, method, n_steps)
 
 
-def price(payoff, spot, vol, rf_rate, div_rate, disc_rate,
-          method='trinomial', n_steps = 30):
+def price(payoff, spot: float, vol: float, rf_rate: float, div_rate: float, disc_rate: float,
+          method: str='trinomial', n_steps: int=30):
     """ Price of a payoff using binomial or trinomial trees under Black-Scholes model """
     if method == 'binomial':
         tree = trees.BinomialTree(n_steps)
@@ -86,7 +86,6 @@ if __name__ == "__main__":
         bin_p = [100.0 * (x / cf - 1.0) for x in bin_p]
         tri_p = [100.0 * (x / cf - 1.0) for x in tri_p]
 
-
     # Plot the results
     plt.figure(figsize=(10, 6))
     plt.plot(bin_t, bin_p, label='Binomial Tree Price')

sdevpy-1.0.8/sdevpy/analytics/bachelier.py

@@ -0,0 +1,140 @@
+""" Utilities for Bachelier model """
+import numpy as np
+import numpy.typing as npt
+from scipy.stats import norm
+from scipy.optimize import minimize_scalar
+
+
+def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
+          vol: npt.ArrayLike) -> npt.ArrayLike:
+    """ Option price under the Bachelier model """
+    stdev = vol * expiry**0.5
+    d = (fwd - strike) / stdev
+    wd = np.where(is_call, d, -d)
+    # wd = d if is_call else -d
+    return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
+
+
+def price_straddles(expiry: npt.ArrayLike, strike: npt.ArrayLike, fwd: npt.ArrayLike,
+                    vol: npt.ArrayLike) -> npt.ArrayLike:
+    """ Straddle price under the Bachelier model.
+        Note: we could improve the speed by writing the code in-line instead of
+              calling the price() function twice """
+    expiries_ = np.asarray(expiry).reshape(-1, 1)
+    prices = []
+    for i, exp_row in enumerate(expiries_):
+        k_prices = []
+        for j, k in enumerate(strike[i]):
+            iv = vol[i, j]
+            call_price = price(exp_row, k, True, fwd, iv)
+            put_price = price(exp_row, k, False, fwd, iv)
+            k_prices.append(call_price[0] + put_price[0])
+        prices.append(k_prices)
+
+    return np.asarray(prices)
+
+
+def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017.
+        This is the original, non-vectorized. """
+    m = fwd - strike
+    abs_m = np.abs(m)
+    # Special case at ATM
+    if abs_m < 1e-8:
+        return fwd_price * np.sqrt(2.0 * np.pi) / np.sqrt(expiry)
+
+    # General case
+    tilde_phi_star_c = -0.001882039271
+    theta = 1.0 if is_call else -1.0
+
+    tilde_phi_star = -np.abs(fwd_price - np.maximum(theta * m, 0.0)) / abs_m
+    em5 = 1e-5
+
+    if tilde_phi_star < tilde_phi_star_c:
+        g = 1.0 / (tilde_phi_star - 0.5)
+        g2 = g**2
+        em3 = 1e-3
+        num = 0.032114372355 - g2 * (0.016969777977 - g2 * (2.6207332461 * em3
+                                                             - 9.6066952861 * em5 * g2))
+        den = 1.0 - g2 * (0.6635646938 - g2 * (0.14528712196 - 0.010472855461 * g2))
+        eta_bar = num / den
+        xb = g * (eta_bar * g2 + 1.0 / np.sqrt(2.0 * np.pi))
+    else:
+        h = np.sqrt(-np.log(-tilde_phi_star))
+        num = 9.4883409779 - h * (9.6320903635 - h * (0.58556997323 + 2.1464093351 * h))
+        den = 1.0 - h * (0.65174820867 + h * (1.5120247828 + 6.6437847132 * em5 * h))
+        xb = num / den
+
+    q = (norm.cdf(xb) + norm.pdf(xb) / xb - tilde_phi_star) / norm.pdf(xb)
+    xb2 = xb**2
+    num = 3.0 * q * xb2 * (2.0 - q * xb * (2.0 + xb2))
+    den = 6.0 + q * xb * (-12.0 + xb * (6.0 * q + xb * (-6.0 + q * xb * (3.0 + xb2))))
+    xs = xb + num / den
+    sigma = abs_m / (np.abs(xs) * np.sqrt(expiry))
+    return sigma
+
+
+def implied_vol(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike,
+                fwd: npt.ArrayLike, fwd_price: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017.
+        Vectorized version (vectorization not in Jaeckel). """
+    strike = np.asarray(strike, dtype=float)
+    fwd_price = np.asarray(fwd_price, dtype=float)
+    is_call = np.asarray(is_call, dtype=bool)
+
+    #### ATM branch ####
+    m = fwd - strike
+    abs_m = np.abs(m)
+    atm_mask = (abs_m < 1e-8)
+    atm_result = fwd_price * np.sqrt(2.0 * np.pi / expiry)
+
+    #### General case ####
+    tilde_phi_star_c = -0.001882039271
+    theta = np.where(is_call, 1.0, -1.0)
+    tilde_phi_star = -np.abs(fwd_price - np.maximum(theta * m, 0.0)) / np.where(atm_mask, 1.0, abs_m)
+    em5 = 1e-5
+    mask_low = (tilde_phi_star < tilde_phi_star_c)
+
+    # Branch = lower
+    g = 1.0 / (tilde_phi_star - 0.5)
+    g2 = g**2
+    em3 = 1e-3
+    num_low = 0.032114372355 - g2 * (0.016969777977 - g2 * (2.6207332461 * em3 - 9.6066952861 * em5 * g2))
+    den_low = 1.0 - g2 * (0.6635646938 - g2 * (0.14528712196 - 0.010472855461 * g2))
+    eta_bar = num_low / den_low
+    xb_low = g * (eta_bar * g2 + 1.0 / np.sqrt(2.0 * np.pi))
+
+    # Branch = higher
+    # Note: substitute a safe value where mask_low is True to avoid sqrt(log(large))
+    safe_tps = np.where(mask_low, -0.001, tilde_phi_star)
+    h = np.sqrt(-np.log(-safe_tps))
+    num_high = 9.4883409779 - h * (9.6320903635 - h * (0.58556997323 + 2.1464093351 * h))
+    den_high = 1.0 - h * (0.65174820867 + h * (1.5120247828 + 6.6437847132 * em5 * h))
+    xb_high = num_high / den_high
+
+    # Join lower/higher
+    xb = np.where(mask_low, xb_low, xb_high)
+    q = (norm.cdf(xb) + norm.pdf(xb) / xb - tilde_phi_star) / norm.pdf(xb)
+    xb2 = xb**2
+    num = 3.0 * q * xb2 * (2.0 - q * xb * (2.0 + xb2))
+    den = 6.0 + q * xb * (-12.0 + xb * (6.0 * q + xb * (-6.0 + q * xb * (3.0 + xb2))))
+    xs = xb + num / den
+    sigma = abs_m / (np.abs(xs) * np.sqrt(expiry))
+
+    # Join ATM/OTM
+    return np.where(atm_mask, atm_result, sigma)
+
+
+def implied_vol_solve(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Direct method by numerical inversion using Brent """
+    options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    xmin = 1e-6
+    xmax = 1.0
+
+    def error(vol):
+        premium = price(expiry, strike, is_call, fwd, vol)
+        return (premium - fwd_price) ** 2
+
+    res = minimize_scalar(fun=error, bracket=(xmin, xmax), options=options, method='brent')
+
+    return res.x

sdevpy-1.0.8/sdevpy/analytics/black.py

@@ -0,0 +1,105 @@
+""" Utilities for Black-Scholes model """
+import numpy as np
+import numpy.typing as npt
+from scipy.stats import norm
+from scipy.optimize import minimize_scalar
+from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
+from sdevpy.utilities.tools import isiterable
+
+
+def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
+          vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ Option price under the Black-Scholes model """
+    # w = 1.0 if is_call else -1.0
+    w = np.where(is_call, 1.0, -1.0)
+    s = vol * np.sqrt(expiry)
+    d1 = np.log(fwd / strike) / s + 0.5 * s
+    d2 = d1 - s
+    return w * (fwd * norm.cdf(w * d1) - strike * norm.cdf(w * d2))
+
+
+def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Direct method by numerical inversion using Brent.
+        Non-vectorized due to solver. """
+    options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    xmin = 1e-6
+    xmax = 1.0
+
+    def error(vol):
+        premium = price(expiry, strike, is_call, fwd, vol)
+        return (premium - fwd_price) ** 2
+
+    res = minimize_scalar(fun=error, bracket=(xmin, xmax), options=options, method='brent')
+    return res.x
+
+
+def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
+                 fwd_price: npt.ArrayLike) -> npt.ArrayLike:
+    """ Black implied volatility for vector of strikes/prices """
+    if isiterable(strike) and isiterable(fwd_price):
+        ivs = [implied_vol(expiry, k, is_call, fwd, p) for k, p in zip(strike, fwd_price, strict=True)]
+        return np.asarray(ivs)
+    elif not isiterable(strike) and not isiterable(fwd_price):
+        return implied_vol(expiry, strike, is_call, fwd, fwd_price)
+    else:
+        raise ValueError("Incompatible shapes between strikes and prices")
+
+
+def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
+                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.ArrayLike:
+    """ Using vectorized Newton-Raphson, with faster convergence than Brent.
+        However, this method can struggle for very small vegas, so we may want to switch
+        to another method (maybe Brent above) below a certain vega threshold.
+        Or to switch to Halley's method.
+        To be investigated if speed becomes a bottleneck or Brent's method has issues. """
+    strike = np.asarray(strike, dtype=float)
+    fwd_price = np.asarray(fwd_price, dtype=float)
+    vol = np.full_like(fwd_price, 0.25) # Initial guess: flat 25%
+    sqrt_t = np.sqrt(expiry)
+    for _ in range(max_iter):
+        s = vol * sqrt_t
+        d1 = np.log(fwd / strike) / s + 0.5 * s
+        vega = fwd * norm.pdf(d1) * sqrt_t
+        diff = price(expiry, strike, is_call, fwd, vol) - fwd_price
+        vol -= diff / vega
+        vol = np.maximum(vol, 1e-8) # Keep vol positive
+        if np.all(np.abs(diff) < tol):
+            break
+
+    # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
+    #     return vol[0]
+    # else:
+    #     return vol
+    return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
+
+
+def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
+    """ Black-Scholes implied volatility using P. Jaeckel's 'Let's be rational' method,
+        from package py_vollib. Install with pip install py_vollib or at
+        https://pypi.org/project/py_vollib/. Unfortunately we found it has instabilities
+        near ATM. """
+    flag = 'c' if is_call else 'p'
+    p = fwd_price
+    iv = jaeckel.implied_volatility_of_undiscounted_option_price(p, fwd, strike, expiry, flag)
+    return iv
+
+
+if __name__ == "__main__":
+    EXPIRY = 1.0
+    VOL = 0.25
+    IS_CALL = True
+    NUM_POINTS = 100
+    # FWD = 100
+    # K = 100
+    # p = price(EXPIRY, K, IS_CALL, FWD, VOL)
+    # iv = implied_vol(EXPIRY, K, IS_CALL, FWD, p)
+    # print(iv)
+    f_space = np.linspace(100, 120, NUM_POINTS)
+    k_space = np.linspace(20, 2180, NUM_POINTS)
+    prices = price(EXPIRY, k_space, IS_CALL, f_space, VOL)
+    # print(prices)
+    implied_vols = []
+    for i, k in enumerate(k_space):
+        implied_vols.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
+
+    # print(implied_vols)

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/machinelearning/datasets.py

@@ -3,7 +3,7 @@ import os
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
-from sdevpy.tools import filemanager
+from sdevpy.utilities import filemanager
 
 
 def prepare_sets(inputs: npt.ArrayLike, outputs: npt.ArrayLike, train_percent: float) -> npt.ArrayLike:

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/machinelearning/keras/learningmodel.py

@@ -5,8 +5,8 @@ from sklearn.preprocessing import StandardScaler
 import tensorflow as tf
 import joblib
 import absl.logging
-from sdevpy.tools import jsonmanager
-from sdevpy.tools import filemanager
+from sdevpy.utilities import jsonmanager
+from sdevpy.utilities import filemanager
 
 class LearningModel:
     """ Wrapper class for machine learning models, including scalers, and simplifying

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/machinelearning/keras/learningschedules.py

@@ -1,7 +1,8 @@
 """ Custom learning schedules """
 import numpy as np
 import tensorflow as tf
-from sdevpy.tools.constants import TWO_PI
+from sdevpy.utilities.constants import TWO_PI
+
 
 # Custom learning rate scheduler, exponentially decreases between given values
 class FlooredExponentialDecay(tf.keras.optimizers.schedules.LearningRateSchedule):

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/correlations.py

@@ -2,7 +2,7 @@ from pathlib import Path
 import numpy as np
 import pandas as pd
 import datetime as dt
-from sdevpy.tools import dates as dts
+from sdevpy.utilities import dates as dts
 
 
 def get_correlations(names: list[str], date: dt.datetime, **kwargs):

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/eqforward.py

@@ -2,7 +2,7 @@ import os, json
 import datetime as dt
 import numpy as np
 from pathlib import Path
-from sdevpy.tools import dates, timegrids
+from sdevpy.utilities import dates, timegrids
 from sdevpy.maths import interpolation as itp
 from sdevpy.market import yieldcurve as ycrv
 from sdevpy.market.spot import get_spots

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/eqvolsurface.py

@@ -2,7 +2,9 @@ import os, json, logging
 import datetime as dt
 import numpy as np
 from pathlib import Path
-from sdevpy.tools import dates
+from sdevpy.utilities import dates
+from sdevpy.utilities import timegrids
+from sdevpy.analytics import black
 log = logging.getLogger(__name__)
 
 
@@ -21,8 +23,6 @@ class EqVolSurfaceData:
         self.forwards = np.asarray([s['forward'] for s in sections])
         self.input_strikes = [np.asarray(s['strikes']) for s in sections]
         self.vols = [np.asarray(s['vols']) for s in sections]
-        # self.input_strikes = np.asarray([s['strikes'] for s in sections])
-        # self.vols = np.asarray([s['vols'] for s in sections])
 
         # Size checks
         n_times = len(self.expiries)
@@ -43,12 +43,23 @@ class EqVolSurfaceData:
         else:
             raise ValueError(f"Strike input type not supported yet: {self.strike_input_type}")
 
+        # Calculate prices
+        self.call_prices = []
+        for exp_idx, expiry in enumerate(self.expiries):
+            t = timegrids.model_time(self.valdate, expiry)
+            fwd = self.forwards[exp_idx]
+            strikes = self.abs_strikes[exp_idx]
+            vols = self.vols[exp_idx]
+            self.call_prices.append(black.price(t, strikes, True, fwd, vols))
+
     def get_strikes(self, type: str='absolute'):
         req_type = type.lower()
         if req_type == 'absolute':
             return self.abs_strikes
         elif req_type == 'relative':
             return self.abs_strikes / self.forwards.reshape(-1, 1)
+        else:
+            raise ValueError(f"Unknown strike type {req_type}: expected absolute or relative")
 
     def dump(self, file, indent=2):
         data = self.dump_data()

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/fixings.py

@@ -2,8 +2,8 @@ import os
 import datetime as dt
 import pandas as pd
 from pathlib import Path
-from sdevpy.tools import dates as dts
-from sdevpy.tools.utils import isiterable
+from sdevpy.utilities import dates as dts
+from sdevpy.utilities.tools import isiterable
 from sdevpy.maths import interpolation as itp
 
 
@@ -131,8 +131,8 @@ def test_data_folder():
 
 if __name__ == "__main__":
     # import numpy as np
-    # from sdevpy.tools.scalendar import make_schedule
-    # from sdevpy.tools.timegrids import model_time
+    # from sdevpy.utilities.scalendar import make_schedule
+    # from sdevpy.utilities.timegrids import model_time
     # from sdevpy.maths.rand.rng import get_rng
     name = "ABC"
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/spot.py

@@ -2,7 +2,7 @@ import os, json
 import datetime as dt
 import numpy as np
 from pathlib import Path
-from sdevpy.tools import dates
+from sdevpy.utilities import dates
 
 
 def get_spots(names: list[str], valdate: dt.datetime, **kwargs):

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/market/yieldcurve.py

@@ -4,7 +4,7 @@ import datetime as dt
 import numpy as np
 from abc import ABC, abstractmethod
 from enum import Enum
-from sdevpy.tools import timegrids, dates
+from sdevpy.utilities import timegrids, dates
 from sdevpy.maths import interpolation as itp
 
 
@@ -201,7 +201,7 @@ def test_data_folder():
 
 if __name__ == "__main__":
     import matplotlib.pyplot as plt
-    from sdevpy.tools import dates
+    from sdevpy.utilities import dates
 
     valdate = dt.datetime(2026, 2, 15)
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/maths/rand/pathconstruction.py

@@ -131,7 +131,7 @@ if __name__ == "__main__":
     # Sobol with scrambling in incremental construction thatn Sobol without scrambling
     # in the Brownian bridge construction.
     # from sdevpy.maths.rand import rng
-    # from sdevpy.tools import timer
+    # from sdevpy.utilities import timer
 
     # Make time grid
     n_steps = 5

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/montecarlo/mcpricer.py

@@ -2,7 +2,7 @@
     multi-d vector. This way we can get those paths from an independent engine. """
 import numpy as np
 import datetime as dt
-from sdevpy.tools import timegrids, timer
+from sdevpy.utilities import timegrids, timer
 from sdevpy.volatility.localvol import localvol_factory as lvf
 from sdevpy.models.assetmodels import MultiAssetGBM
 from sdevpy.montecarlo.pathgenerator import PathGenerator

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/montecarlo/mcrun.py

@@ -7,8 +7,8 @@ from sdevpy.montecarlo.payoffs.exotics import WorstOfBarrier, make_basket_option
 from sdevpy.montecarlo.mcpricer import price_book
 from sdevpy.models.localvol_factory import get_local_vols
 from sdevpy.analytics import black
-from sdevpy.tools import timegrids
-from sdevpy.tools import book as bk
+from sdevpy.utilities import timegrids
+from sdevpy.utilities import book as bk
 from sdevpy.market.yieldcurve import get_yieldcurve
 from sdevpy.market.eqforward import get_forward_curves
 from sdevpy.montecarlo.payoffs import cashflows as cfl

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/montecarlo/payoffs/basic.py

@@ -1,8 +1,8 @@
 import numpy as np
 import datetime as dt
 from abc import ABC, abstractmethod
-from sdevpy.tools.scalendar import make_schedule
-from sdevpy.tools.utils import rand_str
+from sdevpy.utilities.scalendar import make_schedule
+from sdevpy.utilities.tools import rand_str
 from sdevpy.market import fixings as fxgs
 
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/montecarlo/payoffs/exotics.py

@@ -60,7 +60,7 @@ def make_asian_option(name: str, strike: float, optiontype: str, start: dt.datet
     return payoff
 
 
-def make_basket_option(names: list[str], weights: list[float], strike: float, optiontype: str, expiry: dt.dateime):
+def make_basket_option(names: list[str], weights: list[float], strike: float, optiontype: str, expiry: dt.datetime):
     """ Create Basket option payoff """
     spots = [Terminal(name, expiry) for name in names]
     basket = Basket(spots, weights)

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/pde/forwardpde.py

@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
 from sdevpy.analytics import black
 from sdevpy.maths import metrics
 from sdevpy.pde import pdeschemes
-from sdevpy.tools import timegrids
+from sdevpy.utilities import timegrids
 
 
 def density_step(old_p, old_x, old_dx, t_grid, local_vol, config):

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/aad/aad_mc.py

@@ -6,7 +6,8 @@ import matplotlib.pyplot as plt
 from sdevpy.montecarlo import smoothers
 from sdevpy import settings
 from sdevpy.analytics import black
-from sdevpy.tools.timer import Stopwatch
+from sdevpy.utilities.timer import Stopwatch
+
 
 # ################ Runtime configuration ##########################################################
 # Parameters

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/aad/aad_mc_nd.py

@@ -6,7 +6,7 @@ from scipy.stats import norm
 import matplotlib.pyplot as plt
 from sdevpy.analytics import black
 from sdevpy.montecarlo import smoothers
-from sdevpy.tools.timer import Stopwatch
+from sdevpy.utilities.timer import Stopwatch
 
 # In this script we calculate PV, Delta and Gamma for a hypothetical product
 # (an option on the multiplicated spots) using Monte-Carlo with bumps, closed-form

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/datafiles.py

@@ -1,7 +1,7 @@
 """ Operations on data files e.g. merging, etc. """
 import os
 import pandas as pd
-from sdevpy.tools import filemanager
+from sdevpy.utilities import filemanager
 from sdevpy import settings
 
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/set_limits.py

@@ -1,11 +1,9 @@
-# Import packages
 import datetime as dt
-# import pandas as pd
-# from dateutil.relativedelta import relativedelta
-from sdevpy.tools import dates
+from sdevpy.utilities import dates
 from openbb import obb
 obb.user.preferences.output_type = "dataframe"
 
+
 names = ['SPY', 'VTV', 'VUG', 'VBR', 'VBK', 'VGK', 'VPL']
 colors = ['blue', 'red', 'green', 'brown', 'orange', 'yellow']
 today = dt.date.today()

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/stovol/stovolgen.py

@@ -3,10 +3,10 @@
     a network that learns the so-called 'direct' calculation, i.e. prices from parameter. """
 import os
 from datetime import datetime
-from sdevpy.volsurfacegen import stovolfactory
+from sdevpy.volatility.mlsurfacegen import stovolfactory
 from sdevpy import settings
-from sdevpy.tools import filemanager
-from sdevpy.tools.timer import Stopwatch
+from sdevpy.utilities import filemanager
+from sdevpy.utilities.timer import Stopwatch
 
 
 # ################ Runtime configuration ##########################################################

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/stovol/stovolplot.py

@@ -4,7 +4,6 @@ import matplotlib.pyplot as plt
 import matplotlib.ticker as mtick
 from sdevpy.analytics import bachelier
 from sdevpy.analytics import black
-# from sdevpy.tools import clipboard
 
 
 def plot_transform_surface(expiries, strikes, are_calls, fwd, ref_prices, mod_prices, title_,
@@ -70,7 +69,7 @@ def transform_surface(expiries, strikes, are_calls, fwd, prices, transform='Shif
             are_calls_ = are_calls[i]
             # trans_prices_ = []
             for j, strike in enumerate(strikes_):
-                trans_prices[i, j] = bachelier.implied_vol(expiry, strike, are_calls_[j], fwd,
+                trans_prices[i, j] = bachelier.implied_vol_jaeckel(expiry, strike, are_calls_[j], fwd,
                                                            prices[i, j])
             #     trans_prices_.append(bachelier.implied_vol(expiry, strike, are_calls_[j], fwd,
             #                                                prices[i, j]))

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/stovol/stovoltrain.py

@@ -14,10 +14,10 @@ from sdevpy.machinelearning.learningmodel import LearningModel, load_learning_mo
 from sdevpy.machinelearning.learningschedules import FlooredExponentialDecay
 from sdevpy.machinelearning.callbacks import RefCallback
 from sdevpy.machinelearning import datasets
-from sdevpy.tools import filemanager
-from sdevpy.tools.timer import Stopwatch
+from sdevpy.utilities import filemanager
+from sdevpy.utilities.timer import Stopwatch
 from sdevpy.maths.metrics import bps_rmse, tf_bps_rmse
-from sdevpy.volsurfacegen.stovolfactory import set_generator
+from sdevpy.volatility.mlsurfacegen.stovolfactory import set_generator
 from sdevpy.projects.stovol import stovolplot as xplt
 
 

{sdevpy-1.0.7 → sdevpy-1.0.8}/sdevpy/projects/stovolinverse/stovolinvgen.py

@@ -3,10 +3,11 @@
     a network that learns the so-called 'inverse' calculation, i.e. parameters from prices. """
 import os
 from datetime import datetime
-from sdevpy.volsurfacegen import stovolfactory
+from sdevpy.volatility.mlsurfacegen import stovolfactory
 from sdevpy import settings
-from sdevpy.tools import filemanager
-from sdevpy.tools.timer import Stopwatch
+from sdevpy.utilities import filemanager
+from sdevpy.utilities.timer import Stopwatch
+
 
 # ################ Runtime configuration ##########################################################
 MODEL_TYPE = "SABR"