sdevpy 0.0.1__tar.gz

sdevpy-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2023] [Sebastien Gurrieri]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sdevpy-0.0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: sdevpy
+Version: 0.0.1
+Summary: Python package for Machine Learning in Finance
+Author-email: Sebastien Gurrieri <sebgur@gmail.com>
+Project-URL: Git page, https://github.com/sebgur/SDev.Python
+Project-URL: SDev Finance, http://sdev-finance.com/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# SDev.Python
+
+Python repository for various projects in Machine Learning in relation to Finance.This is a simple example package. In the current release,
+we work on stochastic volatility surfaces and their calibration through Machine Learning methods.
+
+See other work on our main website [SDev-Finance](http://sdev-finance.com/).

sdevpy-0.0.1/README.md

@@ -0,0 +1,6 @@
+# SDev.Python
+
+Python repository for various projects in Machine Learning in relation to Finance.This is a simple example package. In the current release,
+we work on stochastic volatility surfaces and their calibration through Machine Learning methods.
+
+See other work on our main website [SDev-Finance](http://sdev-finance.com/).

sdevpy-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sdevpy"
+version = "0.0.1"
+authors = [
+  { name="Sebastien Gurrieri", email="sebgur@gmail.com" },
+]
+description = "Python package for Machine Learning in Finance"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+	"pandas",
+]
+
+[project.urls]
+"Git page" = "https://github.com/sebgur/SDev.Python"
+"SDev Finance" = "http://sdev-finance.com/"

sdevpy-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sdevpy-0.0.1/src/sdevpy/analytics/bachelier.py

@@ -0,0 +1,66 @@
+""" Utilities for Bachelier model """
+import numpy as np
+from scipy.stats import norm
+from scipy.optimize import minimize_scalar
+
+
+def price(expiry, strike, is_call, fwd, vol):
+    """ Option price under the Bachelier model """
+    stdev = vol * expiry**0.5
+    d = (fwd - strike) / stdev
+    wd = d if is_call else -d
+    return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
+
+
+def implied_vol(expiry, strike, is_call, fwd, fwd_price):
+    """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017 """
+    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_solve(expiry, strike, is_call, fwd, fwd_price):
+    """ 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-0.0.1/src/sdevpy/analytics/black.py

@@ -0,0 +1,81 @@
+""" Utilities for Black-Scholes model """
+import numpy as np
+import scipy.stats
+from scipy.optimize import minimize_scalar
+import py_vollib.black.implied_volatility as jaeckel
+
+N = scipy.stats.norm.cdf
+# Ninv = scipy.stats.norm.ppf
+
+
+def price(expiry, strike, is_call, fwd, vol):
+    """ Option price under the Black-Scholes model """
+    w = 1.0 if is_call else -1.0
+    s = vol * np.sqrt(expiry)
+    d1 = np.log(fwd / strike) / s + 0.5 * s
+    d2 = d1 - s
+    return w * (fwd * N(w * d1) - strike * N(w * d2))
+
+def implied_vol_jaeckel(expiry, strike, is_call, fwd, fwd_price):
+    """ 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
+
+def implied_vol(expiry, strike, is_call, fwd, fwd_price):
+    """ 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
+
+# def performance(spot_vol, repo_rate, div_rate, expiry, strike, fixings):
+#     shape = spot_vol.shape
+#     num_underlyings = int(shape[0] / 2)
+#     # print(num_underlyings)
+#     forward_perf = 1.0
+#     vol2 = 0.0
+#     for i in range(num_underlyings):
+#         forward = spot_vol[2 * i] * np.exp((repo_rate - div_rate) * expiry)
+#         perf = forward  # / fixings[i]
+#         # perf = forward / fixings[i]
+#         forward_perf = forward_perf * perf
+#         vol = spot_vol[2 * i + 1]
+#         vol2 = vol2 + np.power(vol, 2)
+#
+#     vol = np.sqrt(vol2)
+#     # print(vol)
+#
+#     # return forward_perf
+#     return black_formula(forward_perf, strike, vol, expiry, True)
+
+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-0.0.1/src/sdevpy/analytics/fbsabr.py

@@ -0,0 +1,183 @@
+""" Monte-Carlo simulation for Free-Boundary SABR model (vanillas) """
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy.stats as sp
+# from analytics.sabr import calculate_alpha
+from tools.timegrids import SimpleTimeGridBuilder
+from tools import timer
+
+
+def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_per_year=10,
+          scheme='Andersen'):
+    """ Calculate vanilla prices under Free-Boundary SABR model by Monte-Carlo simulation"""
+    floor = 0.00001
+
+    # Temporarily turn off the warnings for division by 0. This is because on certain paths,
+    # the spot becomes so close to 0 that Python effectively handles it as 0. This results in
+    # a warning when taking a negative power of it. However, this is not an issue as Python
+    # correctly finds +infinity and since we use a floor, this case is correctly handled.
+    np.seterr(divide='ignore')
+
+    # Build time grid
+    time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
+    time_grid_builder.add_grid(expiries)
+    time_grid = time_grid_builder.complete_grid()
+    num_factors = 2
+
+    # Find payoff times
+    is_payoff = np.in1d(time_grid, expiries)
+
+    # Retrieve parameters
+    lnvol = parameters['LnVol']
+    beta = parameters['Beta']
+    nu = parameters['Nu']
+    rho = parameters['Rho']
+    alpha = calculate_fbsabr_alpha(lnvol, fwd, beta)
+    nu2 = nu**2
+    sqrtmrho2 = np.sqrt(1.0 - rho**2)
+
+    # Draw all gaussians
+    # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
+
+    # Define dimensions
+    mean = np.zeros(num_factors)
+    corr = np.zeros((num_factors, num_factors))
+    for c in range(num_factors):
+        corr[c, c] = 1.0
+
+    # Draw for each step
+    seed = 42
+    rng = np.random.RandomState(seed)
+
+    # Initialize paths
+    spot = np.ones((2 * num_mc, 1)) * fwd
+    vol = np.ones((2 * num_mc, 1)) * 1.0
+
+    # Loop over time grid
+    ts = te = 0
+    payoff_count = 0
+    mc_prices = []
+    for i, t in enumerate(time_grid):
+        # print("time iteration " + str(i))
+        ts = te
+        te = t
+        dt = te - ts
+        sqrt_dt = np.sqrt(dt)
+
+        # Evolve
+        dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
+        dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
+        dz0 = dz[:, 0].reshape(-1, 1)
+        dz1 = dz[:, 1].reshape(-1, 1)
+
+        vols = vol
+        abs_f = np.maximum(np.abs(spot), floor)
+
+        # Evolve vol
+        vol *= np.exp(-0.5 * nu2 * dt + nu * dz1)
+
+        # Evolve spot
+        if scheme == 'Euler':
+            dw = rho * dz1 + sqrtmrho2 * dz0
+            spot = spot + alpha * abs_f**beta * dw * vols
+        elif scheme == 'Andersen':
+            vole = vol
+            spot = spot + alpha * abs_f**beta * (sqrtmrho2 * vols * dz0 + rho / nu * (vole - vols))
+        else:
+            raise ValueError("Unknown scheme in FBSABR: " + scheme)
+
+        # Calculate payoff
+        if is_payoff[i]:
+            w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
+            w = np.asarray(w).reshape(1, -1)
+            k = np.asarray(strikes[payoff_count]).reshape(1, -1)
+            payoff = np.maximum(w * (spot - k), 0.0)
+            rpayoff = np.mean(payoff, axis=0)
+            mc_prices.append(rpayoff)
+            payoff_count += 1
+
+    np.seterr(divide='warn')
+
+    return np.asarray(mc_prices)
+
+
+def calculate_fbsabr_alpha(ln_vol, fwd, beta):
+    """ Calculate parameter alpha with our definition in terms of ln_vol, i.e.
+        alpha = ln_vol * fwd ^ (1.0 - beta) """
+    floor = 0.00001
+    abs_f = np.maximum(np.abs(fwd), floor)
+    return ln_vol * abs_f ** (1.0 - beta)
+
+if __name__ == "__main__":
+    EXPIRIES = [0.05, 0.10, 0.25, 0.5]
+    NSTRIKES = 50
+    FWD = -0.005
+    SHIFT = 0.03
+    SFWD = FWD + SHIFT
+    IS_CALL = False
+    ARE_CALLS = [IS_CALL] * NSTRIKES
+    ARE_CALLS = [ARE_CALLS] * len(EXPIRIES)
+    LNVOL = 0.25
+    # Spread method
+    # SPREADS = np.linspace(-200, 200, NSTRIKES)
+    # SPREADS = np.asarray([SPREADS] * len(EXPIRIES))
+    # STRIKES = FWD + SPREADS / 10000.0
+    # SSTRIKES = STRIKES + SHIFT
+    # XAXIS = SPREADS
+    # Distribution method
+    np_expiries = np.asarray(EXPIRIES).reshape(-1, 1)
+    PERCENT = np.linspace(0.01, 0.99, NSTRIKES)
+    PERCENT = np.asarray([PERCENT] * len(EXPIRIES))
+    ITO = -0.5 * LNVOL**2 * np_expiries
+    DIFF = LNVOL * np.sqrt(np_expiries) * sp.norm.ppf(PERCENT)
+    SSTRIKES = SFWD * np.exp(ITO + DIFF)
+    STRIKES = SSTRIKES - SHIFT
+    XAXIS = STRIKES
+
+    PARAMETERS = {'LnVol': LNVOL, 'Beta': 0.1, 'Nu': 0.50, 'Rho': -0.25}
+    NUM_MC = 100 * 1000
+    POINTS_PER_YEAR = 25
+    # SCHEME = 'Andersen'
+    SCHEME = 'Euler'
+
+    # Calculate MC prices
+    mc_timer = timer.Stopwatch("MC")
+    mc_timer.trigger()
+    MC_PRICES = price(EXPIRIES, STRIKES, ARE_CALLS, FWD, PARAMETERS, NUM_MC, POINTS_PER_YEAR,
+                      scheme=SCHEME)
+    mc_timer.stop()
+    mc_timer.print()
+
+    # print(MC_PRICES)
+
+    # Convert to IV and compare against approximate closed-form
+    import black
+    import bachelier
+    mc_ivs = []
+    for a, expiry in enumerate(EXPIRIES):
+        mc_iv = []
+        for j, sstrike in enumerate(SSTRIKES[a]):
+            # mc_iv.append(black.implied_vol(expiry, sstrike, IS_CALL, SFWD, MC_PRICES[a, j]))
+            mc_iv.append(bachelier.implied_vol(expiry, STRIKES[a, j], IS_CALL, FWD, MC_PRICES[a, j]))
+        mc_ivs.append(mc_iv)
+
+    plt.figure(figsize=(10, 8))
+    plt.subplots_adjust(hspace=0.40)
+    plt.subplot(2, 2, 1)
+    plt.plot(XAXIS[0], mc_ivs[0], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[0]}")
+    plt.subplot(2, 2, 2)
+    plt.plot(XAXIS[1], mc_ivs[1], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[1]}")
+    plt.subplot(2, 2, 3)
+    plt.plot(XAXIS[2], mc_ivs[2], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[2]}")
+    plt.subplot(2, 2, 4)
+    plt.plot(XAXIS[3], mc_ivs[3], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[3]}")
+
+    plt.show()

sdevpy-0.0.1/src/sdevpy/analytics/mcheston.py

@@ -0,0 +1,203 @@
+""" Monte-Carlo simulation for Heston model (vanillas). The model is defined as
+    dS = sqrt(v) * S * dW
+    dv = kappa * (theta - v) * dt + xi * sqrt(v) * dZ with <dW, dZ> = rho
+    """
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy.stats as sp
+# from analytics.sabr import calculate_alpha
+from tools.timegrids import SimpleTimeGridBuilder
+from tools import timer
+
+
+def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_per_year=10):
+    """ Calculate vanilla prices under Heston model by Monte-Carlo simulation"""
+    scale = fwd
+    if scale < 0.0:
+        raise ValueError("Negative forward")
+
+    # Temporarily turn off the warnings for division by 0. This is because on certain paths,
+    # the spot becomes so close to 0 that Python effectively handles it as 0. This results in
+    # a warning when taking a negative power of it. However, this is not an issue as Python
+    # correctly finds +infinity and since we use a floor, this case is correctly handled.
+    np.seterr(divide='ignore')
+
+    # Build time grid
+    time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
+    time_grid_builder.add_grid(expiries)
+    time_grid = time_grid_builder.complete_grid()
+    num_factors = 2
+
+    # Find payoff times
+    is_payoff = np.in1d(time_grid, expiries)
+
+    # Retrieve parameters
+    lnvol = parameters['LnVol']
+    kappa = parameters['Kappa']
+    theta = parameters['Theta']
+    xi = parameters['Xi']
+    rho = parameters['Rho']
+    sqrtmrho2 = np.sqrt(1.0 - rho**2)
+    v0 = calculate_v0(lnvol)
+
+    # Draw all gaussians
+    # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
+
+    # Define dimensions
+    mean = np.zeros(num_factors)
+    corr = np.zeros((num_factors, num_factors))
+    for c in range(num_factors):
+        corr[c, c] = 1.0
+
+    # Draw for each step
+    seed = 42
+    rng = np.random.RandomState(seed)
+
+    # Initialize paths
+    spot = np.ones((2 * num_mc, 1)) * fwd
+    vol2 = np.ones((2 * num_mc, 1)) * v0
+
+    # Loop over time grid
+    ts = te = 0
+    payoff_count = 0
+    mc_prices = []
+    for i, t in enumerate(time_grid):
+        ts = te
+        te = t
+        dt = te - ts
+        sqrt_dt = np.sqrt(dt)
+
+        # Evolve
+        dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
+        dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
+        dz0 = dz[:, 0].reshape(-1, 1)
+        dz1 = dz[:, 1].reshape(-1, 1)
+
+        # Evolve vol
+        vol2s = np.abs(vol2)
+        sqrt_vol2s = np.sqrt(vol2s)
+        vol2e = vol2s + kappa * (theta - vol2s) * dt + xi * sqrt_vol2s * dz1
+        vol2e = np.abs(vol2e)
+        vol2 = vol2e
+
+        # Evolve spot
+        intvol2 = 0.5 * (vol2s + vol2e) * dt
+        ito = 0.5 * intvol2
+        dw = rho * dz1 + sqrtmrho2 * dz0
+        spot *= np.exp(-ito + sqrt_vol2s * dw)
+
+        # Calculate payoff
+        if is_payoff[i]:
+            w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
+            w = np.asarray(w).reshape(1, -1)
+            k = np.asarray(strikes[payoff_count]).reshape(1, -1)
+            payoff = np.maximum(w * (spot - k), 0.0)
+            rpayoff = np.mean(payoff, axis=0)
+            mc_prices.append(rpayoff)
+            payoff_count += 1
+
+    np.seterr(divide='warn')
+
+    return np.asarray(mc_prices)
+
+def calculate_v0(lnvol):
+    return lnvol**2
+
+
+if __name__ == "__main__":
+    EXPIRIES = [0.5, 1.0, 5.0, 10.0]
+    NSTRIKES = 50
+    FWD = -0.005
+    SHIFT = 0.03
+    SFWD = FWD + SHIFT
+    IS_CALL = False
+    ARE_CALLS = [IS_CALL] * NSTRIKES
+    ARE_CALLS = [ARE_CALLS] * len(EXPIRIES)
+    LNVOL = 0.25
+    # Spread method
+    # SPREADS = np.linspace(-200, 200, NSTRIKES)
+    # SPREADS = np.asarray([SPREADS] * len(EXPIRIES))
+    # STRIKES = FWD + SPREADS / 10000.0
+    # SSTRIKES = STRIKES + SHIFT
+    # XAXIS = SPREADS
+    # Distribution method
+    np_expiries = np.asarray(EXPIRIES).reshape(-1, 1)
+    PERCENT = np.linspace(0.01, 0.99, NSTRIKES)
+    PERCENT = np.asarray([PERCENT] * len(EXPIRIES))
+    ITO = -0.5 * LNVOL**2 * np_expiries
+    DIFF = LNVOL * np.sqrt(np_expiries) * sp.norm.ppf(PERCENT)
+    SSTRIKES = SFWD * np.exp(ITO + DIFF)
+    STRIKES = SSTRIKES - SHIFT
+    XAXIS = STRIKES
+
+    THETA = LNVOL**2
+    PARAMETERS = {'LnVol': LNVOL, 'Kappa': 1.0, 'Theta': THETA, 'Xi': 0.50, 'Rho': -0.25}
+    NUM_MC = 100 * 1000
+    POINTS_PER_YEAR = 25
+    # SCHEME = 'LogAndersen'
+    # SCHEME = 'LogEuler'
+
+    # Calculate MC prices
+    mc_timer = timer.Stopwatch("MC")
+    mc_timer.trigger()
+    MC_PRICES = price(EXPIRIES, SSTRIKES, ARE_CALLS, SFWD, PARAMETERS, NUM_MC, POINTS_PER_YEAR)
+    mc_timer.stop()
+    mc_timer.print()
+
+    # Convert to IV and compare against approximate closed-form
+    import black
+    import bachelier
+    mc_ivs = []
+    n_ivs = []
+    for a, expiry in enumerate(EXPIRIES):
+        mc_iv = []
+        cf_iv = []
+        n_iv = []
+        for j, sstrike in enumerate(SSTRIKES[a]):
+            mc_iv.append(black.implied_vol(expiry, sstrike, IS_CALL, SFWD, MC_PRICES[a, j]))
+            n_iv.append(bachelier.implied_vol_solve(expiry, STRIKES[a, j], IS_CALL, FWD,
+                                                    MC_PRICES[a, j]))
+        mc_ivs.append(mc_iv)
+        n_ivs.append(n_iv)
+
+    plt.figure(figsize=(10, 8))
+    plt.subplots_adjust(hspace=0.40)
+    plt.subplot(2, 2, 1)
+    plt.plot(XAXIS[0], mc_ivs[0], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[0]}")
+    plt.subplot(2, 2, 2)
+    plt.plot(XAXIS[1], mc_ivs[1], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[1]}")
+    plt.subplot(2, 2, 3)
+    plt.plot(XAXIS[2], mc_ivs[2], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[2]}")
+    plt.subplot(2, 2, 4)
+    plt.plot(XAXIS[3], mc_ivs[3], label='MC')
+    plt.legend(loc='best')
+    plt.title(f"Expiry: {EXPIRIES[3]}")
+
+    plt.show()
+
+    # plt.figure(figsize=(10, 8))
+    # plt.subplots_adjust(hspace=0.40)
+    # plt.subplot(2, 2, 1)
+    # plt.plot(XAXIS[0], n_ivs[0], label='MC')
+    # plt.legend(loc='best')
+    # plt.title(f"NVOL Expiry: {EXPIRIES[0]}")
+    # plt.subplot(2, 2, 2)
+    # plt.plot(XAXIS[1], n_ivs[1], label='MC')
+    # plt.legend(loc='best')
+    # plt.title(f"NVOL Expiry: {EXPIRIES[1]}")
+    # plt.subplot(2, 2, 3)
+    # plt.plot(XAXIS[2], n_ivs[2], label='MC')
+    # plt.legend(loc='best')
+    # plt.title(f"NVOL Expiry: {EXPIRIES[2]}")
+    # plt.subplot(2, 2, 4)
+    # plt.plot(XAXIS[3], n_ivs[3], label='MC')
+    # plt.legend(loc='best')
+    # plt.title(f"NVOL Expiry: {EXPIRIES[3]}")
+
+    # plt.show()