sdevpy 1.0.4__tar.gz → 1.0.5__tar.gz

{sdevpy-1.0.4/src/sdevpy.egg-info → sdevpy-1.0.5}/PKG-INFO

@@ -1,16 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.4
+Version: 1.0.5
 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.6
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: pandas
 Requires-Dist: pyperclip
 Requires-Dist: numpy

{sdevpy-1.0.4 → sdevpy-1.0.5}/pyproject.toml

@@ -4,7 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.4"
+version = "1.0.5"
+license-files = []
 authors = [
   { name="Sebastien Gurrieri", email="sebgur@gmail.com" },
 ]
@@ -13,7 +14,6 @@ readme = "README.md"
 requires-python = ">=3.6"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [

sdevpy-1.0.5/src/sdevpy/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.5'

sdevpy-1.0.5/src/sdevpy/analytics/americantree.py

@@ -0,0 +1,103 @@
+""" Simple example of binomial tree to value American options in Black-Scholes """
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from sdevpy.analytics import black
+from sdevpy.tree import trees
+
+
+def option_price(ttm, strike, is_call, is_american, spot, vol, rf_rate, div_rate, disc_rate,
+                 method='trinomial', n_steps = 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):
+    """ Price of a payoff using binomial or trinomial trees under Black-Scholes model """
+    if method == 'binomial':
+        tree = trees.BinomialTree(n_steps)
+    else:
+        tree = trees.TrinomialTree(n_steps)
+
+    pv = tree.price(payoff, spot, vol, rf_rate, div_rate, disc_rate)
+
+    return pv
+
+
+if __name__ == "__main__":
+    ttm = 2.5
+    strike = 106.0
+    is_call = False
+    is_american = False
+    vol = 0.20
+    spot = 100.0
+    rf_rate = 0.05
+    div_rate = 0.02
+    disc_rate = 0.03
+    payoff = trees.Payoff(ttm, strike, is_call, is_american)
+
+    repeat = 10
+    # bin_range = range(50, 54, 2)
+    # tri_range = range(20, 24, 2)
+    bin_range = range(200, 2000, 50)
+    tri_range = range(100, 1000, 25)
+
+    # Binomial
+    print("\nCalculating Binomial")
+    bin_p = []
+    bin_t = []
+    for n_steps in bin_range:
+        start = time.time()
+        for _ in range(repeat):
+            p = price(payoff, spot, vol, rf_rate, div_rate, disc_rate, 'binomial', n_steps)
+        bin_t.append(time.time() - start)
+        print(p)
+        bin_p.append(p)
+
+    # Trinomial
+    print("\nCalculating Trinomial")
+    tri_p = []
+    tri_t = []
+    for n_steps in tri_range:
+        start = time.time()
+        for _ in range(repeat):
+            p = price(payoff, spot, vol, rf_rate, div_rate, disc_rate, 'trinomial', n_steps)
+        tri_t.append(time.time() - start)
+        print(p)
+        tri_p.append(p)
+
+    print(f"Binomial(price): {bin_p[-1]:.4f}")
+    print(f"Binomial(time): {bin_t[-1]:.4f}")
+    print(f"Trinomial(price): {tri_p[-1]:.4f}")
+    print(f"Trinomial(time): {tri_t[-1]:.4f}")
+
+    # Closed-Form
+    if not payoff.is_american:
+        fwd = spot * np.exp((rf_rate - div_rate) * ttm)
+        cf = np.exp(-disc_rate * ttm) * black.price(ttm, strike, is_call, fwd, vol)
+        print(f"Vanilla CF: {cf:.4f}")
+        cf_t = np.linspace(0, tri_t[-1], 100)
+        cf_p = [0.0] * 100 # Error 0 for vanilla
+
+        # Reframe as relative errors
+        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')
+    plt.plot(tri_t, tri_p, label='Trinomial Tree Price')
+    if not payoff.is_american:
+        plt.plot(cf_t, cf_p, label='Vanilla CF Price')
+    # # plt.plot(steps_range, trinomial_prices, label='Trinomial Tree Price')
+    # plt.hlines(bs_price, steps_range[0], steps_range[-1], colors='r', linestyles='dashed', label='Black-Scholes Price')
+    plt.title('Convergence to Black-Scholes Price for Call Options')
+    plt.xlabel('Runtime')
+    plt.ylabel('Option Price')
+    plt.legend()
+    plt.show()
+
+

{sdevpy-1.0.4 → sdevpy-1.0.5}/src/sdevpy/analytics/black.py

@@ -2,15 +2,13 @@
 import numpy as np
 import scipy.stats
 from scipy.optimize import minimize_scalar
-# import py_vollib.black.implied_volatility as jaeckel
 from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
-import tensorflow as tf
-import tensorflow_probability as tfp
+# import tensorflow as tf
+# import tensorflow_probability as tfp
 from sdevpy import settings
 
 N = scipy.stats.norm.cdf
 # Ninv = scipy.stats.norm.ppf
-tf_N = tfp.distributions.Normal(0.0, 1.0)
 
 
 def price(expiry, strike, is_call, fwd, vol):
@@ -21,6 +19,7 @@ def price(expiry, strike, is_call, fwd, vol):
     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
@@ -31,6 +30,7 @@ def implied_vol_jaeckel(expiry, strike, is_call, fwd, 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}
@@ -45,47 +45,47 @@ def implied_vol(expiry, strike, is_call, fwd, fwd_price):
 
     return res.x
 
-
-def price_and_greeks(expiry, strike, spot, vol, rate, div):
-    """ Calculate call PV and sensitivities by AAD on Black-Scholes CF """
-    tf_spot = tf.convert_to_tensor(spot, dtype='float32')
-    tf_vol = tf.convert_to_tensor(vol)
-    tf_time = tf.convert_to_tensor(expiry, dtype='float32')
-    tf_rate = tf.convert_to_tensor(rate, dtype='float32')
-    tf_div = tf.constant(div)
-
-    with tf.GradientTape(persistent=True) as tape:
-        tape.watch([tf_spot, tf_vol, tf_time, tf_rate])
-        with tf.GradientTape(persistent=True) as tape2nd:
-            tape2nd.watch([tf_spot, tf_vol])
-
-            fwd = tf_spot * tf.math.exp((tf_rate - tf_div) * tf_time)
-            stdev = tf_vol * tf.math.sqrt(tf_time)
-            d1 = tf.math.log(fwd / strike) / stdev + 0.5 * stdev
-            d2 = d1 - stdev
-            df = tf.math.exp(-tf_rate * tf_time)
-            pv = df * (fwd * tf_N.cdf(d1) - strike * tf_N.cdf(d2))
-
-        # Calculate delta and vega
-        g_delta = tape2nd.gradient(pv, tf_spot)
-        g_vega = tape2nd.gradient(pv, tf_vol)
-
-    delta = tape.gradient(pv, tf_spot)
-    gamma = tape.gradient(g_delta, tf_spot)
-    vega = tape.gradient(pv, tf_vol)
-    theta = tape.gradient(pv, tf_time)
-    dv01 = tape.gradient(pv, tf_rate)
-    volga = tape.gradient(g_vega, tf_vol)
-    vanna = tape.gradient(g_delta, tf_vol)
-
-    # Scale
-    vega = vega.numpy() * settings.VEGA_SCALING
-    theta = -theta.numpy() * settings.THETA_SCALING
-    dv01 = dv01.numpy() * settings.DV01_SCALING
-    volga = volga.numpy() * settings.VOLGA_SCALING
-    vanna = vanna.numpy() * settings.VANNA_SCALING
-
-    return [pv.numpy(), delta.numpy(), gamma.numpy(), vega, theta, dv01, volga, vanna]
+# Moved to tf_black to avoid slow loading of tf when not needed
+# def price_and_greeks(expiry, strike, spot, vol, rate, div):
+#     """ Calculate call PV and sensitivities by AAD on Black-Scholes CF """
+#     tf_spot = tf.convert_to_tensor(spot, dtype='float32')
+#     tf_vol = tf.convert_to_tensor(vol)
+#     tf_time = tf.convert_to_tensor(expiry, dtype='float32')
+#     tf_rate = tf.convert_to_tensor(rate, dtype='float32')
+#     tf_div = tf.constant(div)
+
+#     with tf.GradientTape(persistent=True) as tape:
+#         tape.watch([tf_spot, tf_vol, tf_time, tf_rate])
+#         with tf.GradientTape(persistent=True) as tape2nd:
+#             tape2nd.watch([tf_spot, tf_vol])
+
+#             fwd = tf_spot * tf.math.exp((tf_rate - tf_div) * tf_time)
+#             stdev = tf_vol * tf.math.sqrt(tf_time)
+#             d1 = tf.math.log(fwd / strike) / stdev + 0.5 * stdev
+#             d2 = d1 - stdev
+#             df = tf.math.exp(-tf_rate * tf_time)
+#             pv = df * (fwd * tf_N.cdf(d1) - strike * tf_N.cdf(d2))
+
+#         # Calculate delta and vega
+#         g_delta = tape2nd.gradient(pv, tf_spot)
+#         g_vega = tape2nd.gradient(pv, tf_vol)
+
+#     delta = tape.gradient(pv, tf_spot)
+#     gamma = tape.gradient(g_delta, tf_spot)
+#     vega = tape.gradient(pv, tf_vol)
+#     theta = tape.gradient(pv, tf_time)
+#     dv01 = tape.gradient(pv, tf_rate)
+#     volga = tape.gradient(g_vega, tf_vol)
+#     vanna = tape.gradient(g_delta, tf_vol)
+
+#     # Scale
+#     vega = vega.numpy() * settings.VEGA_SCALING
+#     theta = -theta.numpy() * settings.THETA_SCALING
+#     dv01 = dv01.numpy() * settings.DV01_SCALING
+#     volga = volga.numpy() * settings.VOLGA_SCALING
+#     vanna = vanna.numpy() * settings.VANNA_SCALING
+
+#     return [pv.numpy(), delta.numpy(), gamma.numpy(), vega, theta, dv01, volga, vanna]
 
 # def performance(spot_vol, repo_rate, div_rate, expiry, strike, fixings):
 #     shape = spot_vol.shape

sdevpy-1.0.5/src/sdevpy/analytics/tf_black.py

@@ -0,0 +1,52 @@
+""" Utilities for Black-Scholes model """
+import numpy as np
+import scipy.stats
+from scipy.optimize import minimize_scalar
+import tensorflow as tf
+import tensorflow_probability as tfp
+from sdevpy import settings
+
+N = scipy.stats.norm.cdf
+tf_N = tfp.distributions.Normal(0.0, 1.0)
+
+
+def price_and_greeks(expiry, strike, spot, vol, rate, div):
+    """ Calculate call PV and sensitivities by AAD on Black-Scholes CF """
+    tf_spot = tf.convert_to_tensor(spot, dtype='float32')
+    tf_vol = tf.convert_to_tensor(vol)
+    tf_time = tf.convert_to_tensor(expiry, dtype='float32')
+    tf_rate = tf.convert_to_tensor(rate, dtype='float32')
+    tf_div = tf.constant(div)
+
+    with tf.GradientTape(persistent=True) as tape:
+        tape.watch([tf_spot, tf_vol, tf_time, tf_rate])
+        with tf.GradientTape(persistent=True) as tape2nd:
+            tape2nd.watch([tf_spot, tf_vol])
+
+            fwd = tf_spot * tf.math.exp((tf_rate - tf_div) * tf_time)
+            stdev = tf_vol * tf.math.sqrt(tf_time)
+            d1 = tf.math.log(fwd / strike) / stdev + 0.5 * stdev
+            d2 = d1 - stdev
+            df = tf.math.exp(-tf_rate * tf_time)
+            pv = df * (fwd * tf_N.cdf(d1) - strike * tf_N.cdf(d2))
+
+        # Calculate delta and vega
+        g_delta = tape2nd.gradient(pv, tf_spot)
+        g_vega = tape2nd.gradient(pv, tf_vol)
+
+    delta = tape.gradient(pv, tf_spot)
+    gamma = tape.gradient(g_delta, tf_spot)
+    vega = tape.gradient(pv, tf_vol)
+    theta = tape.gradient(pv, tf_time)
+    dv01 = tape.gradient(pv, tf_rate)
+    volga = tape.gradient(g_vega, tf_vol)
+    vanna = tape.gradient(g_delta, tf_vol)
+
+    # Scale
+    vega = vega.numpy() * settings.VEGA_SCALING
+    theta = -theta.numpy() * settings.THETA_SCALING
+    dv01 = dv01.numpy() * settings.DV01_SCALING
+    volga = volga.numpy() * settings.VOLGA_SCALING
+    vanna = vanna.numpy() * settings.VANNA_SCALING
+
+    return [pv.numpy(), delta.numpy(), gamma.numpy(), vega, theta, dv01, volga, vanna]

sdevpy-1.0.5/src/sdevpy/cointegration/back_testing.py

@@ -0,0 +1,233 @@
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from sdevpy.cointegration import coint_trading as ct
+from sdevpy.cointegration import utils as ut
+from sdevpy.cointegration import data_io as myio
+from sdevpy.cointegration import mean_reversion as my_mean_rev
+import math
+from tqdm import tqdm # for console progress bar
+
+# input string 
+# "['EURUSD Curncy', 'GBPUSD Curncy', 'JPYUSD Curncy', 'SGDUSD Curncy', 'CNHUSD Curncy']"
+# we need to remove all "[", "]" and "'", then split by "," and then create a list
+def name_list_string_to_name_list(name_list_str):
+    res_str = name_list_str.replace(" '", "")
+    res_str = res_str.replace("'", "")
+    res_str = res_str.replace('[', '')
+    res_str = res_str.replace(']', '')
+    name_list = list(res_str.split(','))
+    return name_list
+
+
+def weigths_list_string_to_float_list(weigths_list_str):
+    res_str = weigths_list_str.replace('[', '')
+    res_str = res_str.replace(']', '')
+    float_list = [float(idx) for idx in res_str.split(',')]
+    return float_list
+
+
+# Given a fixed basket, from date, trade date, now date
+# compute the sharpe ratio, z_score, 5D realized return and 10D realized return from trade date
+def back_test_one_trade(FROM, TRADE_DATE, NOW, name_list, weights_XXXUSD, zscore_TRADE_DATE, df_fx_spot):
+    df_fx_name_list_XXXUSD = df_fx_spot[name_list]
+
+    # compute the basket up to NOW, because we need to compute the realized 5D and 10D returns
+    basket_up_to_NOW = ut.compute_basket(df_fx_name_list_XXXUSD.loc[FROM:NOW], weights_XXXUSD)
+
+    # compute the stdev as if we were on the TRADE DATE, this is used for computing the return in terms of ZScore
+    stdev_up_to_trade_date = np.std(basket_up_to_NOW.loc[:TRADE_DATE])
+
+    basket_from_trade_date_to_NOW = basket_up_to_NOW.loc[TRADE_DATE:NOW]
+
+    basket_2D_rtns_from_TRADE_DATE = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_NOW, 2, stdev_up_to_trade_date).iloc[0]
+    basket_5D_rtns_from_TRADE_DATE = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_NOW, 5, stdev_up_to_trade_date).iloc[0]
+    basket_10D_rtns_from_TRADE_DATE = ut.compute_x_day_historical_returns_in_SD(basket_from_trade_date_to_NOW, 10, stdev_up_to_trade_date).iloc[0]
+
+    min_max_res_2D = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_NOW, 2, stdev_up_to_trade_date).iloc[0]
+    min_2D_rtns_in_SD = min_max_res_2D['min']
+    max_2D_rtns_in_SD = min_max_res_2D['max']
+
+    min_max_res_5D = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_NOW, 5, stdev_up_to_trade_date).iloc[0]
+    min_5D_rtns_in_SD = min_max_res_5D['min']
+    max_5D_rtns_in_SD = min_max_res_5D['max']
+
+    min_max_res_10D = ut.min_max_return_x_days_in_SD(basket_from_trade_date_to_NOW, 10, stdev_up_to_trade_date).iloc[0]
+    min_10D_rtns_in_SD = min_max_res_10D['min']
+    max_10D_rtns_in_SD = min_max_res_10D['max']
+
+    if math.isnan(basket_10D_rtns_from_TRADE_DATE):
+        raise Exception('Trade DATE is less than 10 days ago.')
+
+    if zscore_TRADE_DATE > 0:
+        # flip the return sign if zscore is above 0, because we sell. The basket goes down and we earn
+        basket_2D_rtns_from_TRADE_DATE = -basket_2D_rtns_from_TRADE_DATE
+        basket_5D_rtns_from_TRADE_DATE = -basket_5D_rtns_from_TRADE_DATE
+        basket_10D_rtns_from_TRADE_DATE = -basket_10D_rtns_from_TRADE_DATE
+
+        # so the max draw down is the negative of the max returns
+        max_2D_draw_down_in_SD = -max_2D_rtns_in_SD
+        max_5D_draw_down_in_SD = -max_5D_rtns_in_SD
+        max_10D_draw_down_in_SD = -max_10D_rtns_in_SD
+    else:
+        # we buy so that max draw down is teh min returns
+        max_2D_draw_down_in_SD = min_2D_rtns_in_SD
+        max_5D_draw_down_in_SD = min_5D_rtns_in_SD
+        max_10D_draw_down_in_SD = min_10D_rtns_in_SD
+
+    #if the max draw down is a positive number, we floor it to 0 to show there is no loss   
+    max_2D_draw_down_in_SD = np.minimum(max_2D_draw_down_in_SD, 0.0)
+    max_5D_draw_down_in_SD = np.minimum(max_5D_draw_down_in_SD, 0.0)
+    max_10D_draw_down_in_SD = np.minimum(max_10D_draw_down_in_SD, 0.0)    
+
+    res_dict = {'2D Realized Rtns from Trade Date in SD': basket_2D_rtns_from_TRADE_DATE,
+                '5D Realized Rtns from Trade Date in SD': basket_5D_rtns_from_TRADE_DATE,
+                '10D Realized Rtns from Trade Date in SD': basket_10D_rtns_from_TRADE_DATE,
+                '2D max draw down in SD': max_2D_draw_down_in_SD,
+                '5D max draw down in SD': max_5D_draw_down_in_SD,
+                '10D max draw down in SD': max_10D_draw_down_in_SD,
+                'basket stdev on Trade Date': stdev_up_to_trade_date
+                }
+
+    return res_dict
+
+# res_df_filtered - output from coint_trading.filter_cointegration_basket
+def back_test_many_trades(res_df_filtered, NOW, df_fx_spot):
+    back_test_res = []
+
+    num_rows = len(res_df_filtered)
+
+    for idx in tqdm(range(num_rows)):
+        FROM = res_df_filtered['From'].iloc[idx]
+        TRADE_DATE = res_df_filtered['Today'].iloc[idx]
+        TRADE_DATE = pd.to_datetime(TRADE_DATE, format='%Y-%m-%d')
+
+        name_str = res_df_filtered['currency pairs'].iloc[idx]
+        name_list = name_list_string_to_name_list(name_str)
+
+        weights_XXXUSD_str = res_df_filtered['unadj weights in XXXUSD'].iloc[idx]
+        weights_XXXUSD = weigths_list_string_to_float_list(weights_XXXUSD_str)
+
+        Sharpe_5D = res_df_filtered['5D Sharpe Ratio'].iloc[idx]
+        SD_on_Trade_Date = res_df_filtered['SD Current'].iloc[idx]
+
+        Stop_Loss_in_SD = res_df_filtered['Stop Loss in SD'].iloc[idx]
+
+        half_life_in_days = res_df_filtered['half life in days'].iloc[idx]
+
+        range_in_SD_current = res_df_filtered['Range in SD current'].iloc[idx]
+
+        abs_SD_on_Trade_Date = np.abs(SD_on_Trade_Date)
+
+        one_month_trace_5pct = res_df_filtered['+/- 1 month trace (5%)'].iloc[idx]
+        one_month_trace_10pct = res_df_filtered['+/- 1 month trace (10%)'].iloc[idx]
+        one_month_eigen_5pct = res_df_filtered['+/- 1 month eigen (5%)'].iloc[idx]
+        one_month_eigen_10pct = res_df_filtered['+/- 1 month eigen (10%)'].iloc[idx]
+
+        res_dict = back_test_one_trade(FROM, TRADE_DATE, NOW, name_list, weights_XXXUSD, 
+                                       SD_on_Trade_Date, df_fx_spot)
+
+        basket_stdev = res_dict['basket stdev on Trade Date']
+
+        mean_rev_level = res_df_filtered['mean_rev_level'].iloc[idx]
+
+        back_test_res.append((FROM, TRADE_DATE, NOW, name_list, weights_XXXUSD, Sharpe_5D,
+                              SD_on_Trade_Date, abs_SD_on_Trade_Date, Stop_Loss_in_SD,
+                              res_dict['2D Realized Rtns from Trade Date in SD'],
+                              res_dict['5D Realized Rtns from Trade Date in SD'],
+                              res_dict['10D Realized Rtns from Trade Date in SD'],
+                              res_dict['2D max draw down in SD'],
+                              res_dict['5D max draw down in SD'],
+                              res_dict['10D max draw down in SD'],
+                              basket_stdev, mean_rev_level, half_life_in_days, range_in_SD_current,
+                              one_month_trace_5pct, one_month_trace_10pct,
+                              one_month_eigen_5pct, one_month_eigen_10pct))
+
+        #--- end of for ind in tqdm(res_df_filtered.index):
+
+    res_df = pd.DataFrame(back_test_res, columns =['FROM', 'Trade Date', 'Now', 'currency pairs',
+                                                   'unadj weights in XXXUSD', 'Sharpe Ratio on Trade Date',
+                                                   'Z Score on Trade Date', 'Abs Z Score on Trade Date',
+                                                   'Distance to max/min SD', '2D Realized Rtns in SD',
+                                                   '5D Realized Rtns in SD', '10D Realized Rtns in SD',
+                                                   '2D max DD in SD', '5D max DD in SD', '10D max DD in SD',
+                                                   'basket stdev on Trade Date', 'mean_rev_level on Trade Date',
+                                                   'half life in days', 'Range in SD current',
+                                                   '+/- 1 month trace (5%)', '+/- 1 month trace (10%)',
+                                                   '+/- 1 month eigen (5%)', '+/- 1 month eigen (10%)'])
+
+    return res_df
+
+# Take the results of back_test_many_trades and then compute the back test diagnostics 
+def one_back_test_summary_table(back_test_res_df, start_date, end_date, Sharpe_threshold, ZScore_threshold):
+
+    upper_SD_condition = back_test_res_df['Z Score on Trade Date'] > ZScore_threshold 
+    lower_SD_condition = back_test_res_df['Z Score on Trade Date'] < -ZScore_threshold 
+    Sharpe_condition = back_test_res_df['Sharpe Ratio on Trade Date'] > Sharpe_threshold
+
+    start_date_condition = back_test_res_df['Trade Date'] > pd.Timestamp(start_date) 
+    end_date_condition = back_test_res_df['Trade Date'] < pd.Timestamp(end_date)
+
+    # -----------apply conditions
+    my_trade_df = back_test_res_df[Sharpe_condition]
+    my_trade_df = my_trade_df[upper_SD_condition | lower_SD_condition] 
+    my_trade_df = my_trade_df[start_date_condition]
+    my_trade_df = my_trade_df[end_date_condition]
+
+    total = len(my_trade_df)
+
+    output_table = []
+
+    column_list = ['2D Realized Rtns in SD', '5D Realized Rtns in SD', '10D Realized Rtns in SD']
+
+    for column in column_list: 
+        positive_return_condition = my_trade_df[column] > 0.0 
+        num_pos_rtn = len(my_trade_df[positive_return_condition]) 
+        num_neg_rtn = len(my_trade_df[~positive_return_condition])
+
+        pos_rtn_pct = round(num_pos_rtn/total, 3) 
+        neg_rtn_pct = round(num_neg_rtn/total, 3)     
+
+        rtns_median = np.median(my_trade_df[column]) 
+        rtns_mean = np.mean(my_trade_df[column]) 
+        rtns_std = np.std(my_trade_df[column])
+
+        first_3_char = column[:3]
+
+        output_table.append((start_date, 
+                             end_date, 
+                             Sharpe_threshold, 
+                             ZScore_threshold, 
+                             first_3_char, 
+                             pos_rtn_pct,
+                             neg_rtn_pct, 
+                             total, 
+                             rtns_median, 
+                             rtns_mean, 
+                             rtns_std))
+
+    res_df = pd.DataFrame(output_table, columns =['Period Start', 
+                                                  'Period End', 
+                                                  'Sharpe threshold', 
+                                                  'SD threshold', 
+                                                  'Rtns type', 
+                                                  'Pos %', 
+                                                  'Neg %', 
+                                                  'Total', 
+                                                  'Rtns median', 
+                                                  'Rtns mean', 
+                                                  'Rtns stdev'
+                                                  ])
+
+    return res_df, my_trade_df
+
+
+def several_back_test_summary_tables(back_test_res_df, start_dates, end_dates, Sharpe_thresholds, ZScore_thresholds):
+    output_df = pd.DataFrame()
+    for start, end in zip(start_dates, end_dates): 
+        for Sharpe in Sharpe_thresholds: 
+            for zscore in ZScore_thresholds: 
+                df_one_table, my_trade_df = one_back_test_summary_table(back_test_res_df, start, end, Sharpe, zscore)
+                output_df = pd.concat([output_df, df_one_table], axis=0)
+
+    return output_df

sdevpy-1.0.5/src/sdevpy/cointegration/black_analytics.py

@@ -0,0 +1,45 @@
+import numpy as np
+from scipy.stats import norm
+from scipy import optimize
+
+# undiscounted black option price
+def black_option_price(f, # forward, double
+                       k, # strike, double
+                       t, # time to maturity, double
+                       v, # implied volatility, double
+                       c_or_p # call (1) or put (-1), integer
+                       ):
+
+    d_1 = (np.log(f/k)+0.5*v*v*t)/(v*np.sqrt(t))
+    d_2 = d_1 - v*np.sqrt(t)
+    if c_or_p == 1 :
+        return f * norm.cdf(d_1) - k * norm.cdf(d_2)
+    elif c_or_p == -1 :
+        return k * norm.cdf(-d_2) - f * norm.cdf(-d_1)
+    else:
+        raise ValueError('c_or_p is expected to be 1 for call or -1 for put.')
+
+#undiscounted black option vega
+def black_option_vega(f, # forward, double
+                      k, # strike, double
+                      t, # time to maturity, double
+                      v  # implied volatility, double
+                      ):
+
+    d_1 = (np.log(f / k) + 0.5 * v * v * t) / (v * np.sqrt(t))
+    return f * norm.pdf(d_1) * np.sqrt(t)
+
+#compute black implied volatility
+def black_implied_vol(p,  # option price, double
+                      f,  # forward, double
+                      k,  # strike, double
+                      t,  # time to maturity, double
+                      c_or_p,  # call (1) or put (-1), integer
+                      init_guess = 0.2 # initial guess
+                      ):
+
+    f_ivol = lambda x: black_option_price(f, k, t, x, c_or_p) - p
+    f_vega = lambda x: black_option_vega(f, k, t, x)
+    black_implied_vol = optimize.newton(f_ivol, init_guess, f_vega)
+
+    return black_implied_vol