sdevpy 1.0.3__tar.gz → 1.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 1.0.3
+Version: 1.0.4
 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
@@ -13,7 +13,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas
 Requires-Dist: pyperclip
-Requires-Dist: py_vollib
 Requires-Dist: numpy
 Requires-Dist: tensorflow
 Requires-Dist: scikit-learn

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.3"
+version = "1.0.4"
 authors = [
   { name="Sebastien Gurrieri", email="sebgur@gmail.com" },
 ]
@@ -17,7 +17,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-	"pandas","pyperclip","py_vollib","numpy","tensorflow",
+	"pandas","pyperclip","numpy","tensorflow",
   "scikit-learn", "tensorflow_probability", "silence_tensorflow"
 ]
 

sdevpy-1.0.4/src/sdevpy/__init__.py

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

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/analytics/bachelier.py

@@ -12,6 +12,21 @@ def price(expiry, strike, is_call, fwd, vol):
     return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
 
 
+def price_straddles(expiries, strikes, fwd, vols):
+    expiries_ = np.asarray(expiries).reshape(-1, 1)
+    prices = []
+    for i, expiry in enumerate(expiries_):
+        k_prices = []
+        for j, k in enumerate(strikes[i]):
+            iv = vols[i, j]
+            call_price = price(expiry, k, True, fwd, iv)
+            put_price = price(expiry, k, False, fwd, iv)
+            k_prices.append(call_price[0] + put_price[0])
+        prices.append(k_prices)
+
+    return np.asarray(prices)
+
+
 def implied_vol(expiry, strike, is_call, fwd, fwd_price):
     """ P. Jaeckel's method in "Implied Normal Volatility", 6th Jun. 2017 """
     m = fwd - strike

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

@@ -2,7 +2,8 @@
 import numpy as np
 import scipy.stats
 from scipy.optimize import minimize_scalar
-import py_vollib.black.implied_volatility as jaeckel
+# 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
 from sdevpy import settings

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/maths/optimization.py

@@ -66,7 +66,7 @@ class SciPyOptimizer(Optimizer):
             popsize = self.kwargs.get('popsize', 15)
             strategy = self.kwargs.get('strategy', 'best1bin')
             recombination = self.kwargs.get('recombination', 0.7)
-            mutation = self.kwargs.get('mutation', (0.5, 1.0))
+            mutation = self.kwargs.get('mutation', (0.5, 1.0)) # ToDo: parameter not used
             result = opt.differential_evolution(f, x0=x0, args=args, bounds=bounds, atol=atol,
                                                 popsize=popsize, strategy=strategy,
                                                 recombination=recombination)
@@ -88,16 +88,20 @@ class MultiOptimizer(Optimizer):
 
     def minimize(self, f, x0=None, args=(), bounds=None):
         result = None
+        nfev = 0
         for i, optimizer in enumerate(self.optimizers_):
             print("Trying optimization using " + self.methods_[i] + ": ", end='')
             result = optimizer.minimize(f, x0, args, bounds)
+            nfev = nfev + result.nfev
             if result.fun < self.mtol_:
-                print("SUCCESS!")
+                print("Good enough!")
                 break
+            elif i < len(self.methods_) - 1:
+                print("Continuing")
             else:
-                print("FAILURE")
+                print("Stopping")
         
-        return result
+        return result, nfev
 
 
 if __name__ == "__main__":

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovolgen.py

@@ -10,13 +10,13 @@ from sdevpy.tools.timer import Stopwatch
 
 
 # ################ Runtime configuration ##########################################################
-# MODEL_TYPE = "SABR"
-MODEL_TYPE = "McSABR"
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
 # MODEL_TYPE = "FbSABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
 SHIFT = 0.03
-NUM_SAMPLES = 35 * 1000
+NUM_SAMPLES = 35 * 100
 # The 4 parameters below are only relevant for models whose reference is calculated by MC
 NUM_EXPIRIES = 10
 NUM_STRIKES = 5

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovolplot.py

@@ -8,7 +8,8 @@ from sdevpy.tools import clipboard
 
 
 def plot_transform_surface(expiries, strikes, are_calls, fwd, ref_prices, mod_prices, title_,
-                           transform='ShiftedBlackScholes'):
+                           transform='ShiftedBlackScholes', ref_name='Reference',
+                           mod_name='Model'):
     """ Calculate quantities to display for the surface and display them in charts. Transformed
         quantities available are: Price, ShiftedBlackScholes (3%) and Bachelier (normal vols). """
     # Transform prices
@@ -27,8 +28,8 @@ def plot_transform_surface(expiries, strikes, are_calls, fwd, ref_prices, mod_pr
     for i in range(num_rows):
         for j in range(num_cols):
             k = num_cols * i + j
-            axs[i, j].plot(strikes[k], ref_disp[k], color='blue', label='Reference')
-            axs[i, j].plot(strikes[k], mod_disp[k], color='red', label='Model')
+            axs[i, j].plot(strikes[k], ref_disp[k], color='blue', label=ref_name)
+            axs[i, j].plot(strikes[k], mod_disp[k], color='red', label=mod_name)
             axs[i, j].xaxis.set_major_formatter(mtick.PercentFormatter(xmax=1, decimals=1))
             axs[i, j].yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1, decimals=0))
             axs[i, j].set_xlabel('Strike')

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/projects/stovol/stovoltrain.py

@@ -23,8 +23,8 @@ from sdevpy.projects.stovol import stovolplot as xplt
 
 
 # ################ Runtime configuration ##########################################################
-# MODEL_TYPE = "SABR"
-MODEL_TYPE = "McSABR"
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
 # MODEL_TYPE = "FbSABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
@@ -38,9 +38,9 @@ TRAIN = True
 if USE_TRAINED is False and TRAIN is False:
     raise RuntimeError("When not using pre-trained models, a new model must be trained")
 
-NUM_SAMPLES = 500 * 1000 # Number of samples to read from sample files
+NUM_SAMPLES = 2 * 1000 * 1000 # Number of samples to read from sample files
 TRAIN_PERCENT = 0.90 # Proportion of dataset used for training (rest used for test)
-EPOCHS = 200
+EPOCHS = 100
 BATCH_SIZE = 1000
 SHOW_VOL_CHARTS = True # Show smile section charts
 # For comparison to reference values (accuracy of reference)
@@ -141,11 +141,12 @@ print(f"> Drop-out rate: {DROP_OUT:.2f}")
 # ################ Train the model ################################################################
 if TRAIN:
     # Learning rate scheduler
-    INIT_LR = 1.0e-2
+    INIT_LR = 1.0e-3
     FINAL_LR = 1.0e-4
-    DECAY = 0.97
-    STEPS = 250
-    lr_schedule = FlooredExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS)
+    TARGET_EPOCH = EPOCHS * 0.90  # Epoch by which we plan to be down to 110% of final LR
+    PERIODS = 10  # Number of oscillation periods until target epoch
+    # lr_schedule = FlooredExponentialDecay(INIT_LR, FINAL_LR, DECAY, STEPS)
+    lr_schedule = FlooredExponentialDecay(NUM_SAMPLES, BATCH_SIZE, TARGET_EPOCH, INIT_LR, FINAL_LR)
 
     # Optimizer
     optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/projects/stovolinverse/stovolinvgen.py

@@ -20,9 +20,10 @@ NUM_SAMPLES = 1000 * 1000
 NUM_EXPIRIES = 15
 NUM_MC = 100 * 1000 # 100 * 1000
 POINTS_PER_YEAR = 25 # 25
-SEED = 1234 # [1357, 8642, 1000, 8888, 4444, 2222, 1111, 4321, 1234, 42]
+SEED = 8888 # [1357, 8642, 1000, 8888, 4444, 2222, 1111, 4321, 1234, 42]
 SPREADS = [-200, -100, -75, -50, -25, -10, 0, 10, 25, 50, 75, 100, 200]
 USE_NVOL = True
+NOISE = 0.01  # Relative size of noise
 
 print(">> Set up runtime configuration")
 project_folder = os.path.join(settings.WORKFOLDER, "stovolinv")
@@ -38,8 +39,13 @@ generator = stovolfactory.set_generator(MODEL_TYPE, SHIFT, NUM_EXPIRIES, num_mc=
 
 # ################ Select training ranges #########################################################
 # SABR
-RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
-          'Beta': [0.1, 0.9], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
+# RANGES = {'Ttm': [1.0 / 12.0, 6.0], 'F': [0.05, 0.06], 'LnVol': [0.20, 0.40],
+#           'Beta': [0.1, 0.9], 'Nu': [0.2, 1.0], 'Rho': [-0.5, 0.2]} # 6y
+RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [0.05, 0.06], 'LnVol': [0.20, 0.40],
+          'Beta': [0.1, 0.9], 'Nu': [0.2, 1.0], 'Rho': [-0.5, 0.2]} #  All times
+
+# RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
+#           'Beta': [0.1, 0.9], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
 # # FBSABR
 # RANGES = {'Ttm': [1.0 / 12.0, 5.0], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
 #           'Beta': [0.25, 0.75], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
@@ -58,7 +64,7 @@ print(">> Generate dataset")
 print(f"> Generate {NUM_SAMPLES:,} price samples")
 timer_gen = Stopwatch("Generating Samples")
 timer_gen.trigger()
-data_df = generator.generate_samples_inverse(NUM_SAMPLES, RANGES, SPREADS, USE_NVOL)
+data_df = generator.generate_samples_inverse(NUM_SAMPLES, RANGES, SPREADS, USE_NVOL, rel_noise=NOISE)
 timer_gen.stop()
 
 timer_out = Stopwatch("File Output")

{sdevpy-1.0.3 → sdevpy-1.0.4}/src/sdevpy/projects/stovolinverse/stovolinvtrain.py

@@ -17,28 +17,28 @@ from sdevpy.machinelearning.callbacks import RefCallback
 from sdevpy.machinelearning import datasets
 from sdevpy.tools import filemanager
 from sdevpy.tools.timer import Stopwatch
-# from sdevpy.tools import clipboard
 from sdevpy.maths.metrics import bps_rmse, tf_bps_rmse, tf_mse, mse, tf_rmse, rmse
 from sdevpy.volsurfacegen.stovolfactory import set_generator
 from sdevpy.projects.stovol import stovolplot as xplt
+from sdevpy.analytics import bachelier
 
 
 # ################ ToDo ###########################################################################
-# Start additional script with simplified function starting from trained model only, to test
-# against classic calibration, shifting parameters, sensies, etc.
-
-# We could generate market points from SABR, then generate a new set from a slightly different
-# set of SABR parameters such as a rho move, a nu move, etc. Then re-calibrate by optimization
-# vs using the network and see if they produce expected move. For instance if the second
-# market is a rho move of +10%, do the standard optimization and the network produce a set
-# of parameters that correspond to +10% in rho?
-# Then we can create a new market that corresponds to an infinitesimal move in the generating
-# SABR parameters, and see if that translates into an expected infinitesimal move in the result.
-
-# This method should allow us to calculate the sensitivity to market by AAD. That's quite an 
-# advantage, as for the regular method we can't AAD through calibration/optimization.
-
-# Compare vegas
+# At the comparison check between model and calibration, we tried adding random noise to the normal
+# vols used for comparison, on top of their values that come from a chosen SABR model. This way the
+# vols we apply the model/calibration to are not longer exactly SABR.
+# The issue was that the model was going off track very quickly with increasing size of noise.
+# Incidentally, the optimization says "FAILURE" but this is likely to be because the tolerance is
+# very small. We should try to make the tolerance larger and see how it goes.
+
+# So the idea would be to include non-SABR points in the training dataset. This could be done by the
+# same noise technique in reverse. Generate random SABR parameters, calculate the normal vols, then
+# add noise on the normal vols, then calculate prices. But then in principle we should calibrate
+# SABR to those prices again, to lear the truly optimium SABR parameters. However, isn't it possible
+# to simply consider the original SABR (before the noise) as the likely optimum? At least, we could
+# start the optimization there. It sounds likely that over a big range of data, these original SABRs
+# could overall be near-optimum enough. Which would then avoid us the trouble of going through the
+# calibration during the training.
 # ################ Module versions ################################################################
 print("TensorFlow version: " + tf.__version__)
 # print("Keras version: " + tf.keras.__version__)
@@ -53,18 +53,18 @@ MODEL_TYPE = "SABR"
 # MODEL_TYPE = "McZABR"
 # MODEL_TYPE = "McHeston"
 # MODEL_ID = "SABR_3L_64n" # For pre-trained model ID (we can pre-train several versions)
-MODEL_ID = MODEL_TYPE # For pre-trained model ID (we can pre-train several versions)
+MODEL_ID = "SABR" # MODEL_TYPE # For pre-trained model ID (we can pre-train several versions)
 SHIFT = 0.03
 USE_TRAINED = True
 DOWNLOAD_MODELS = False # Only used when USE_TRAINED is True
 DOWNLOAD_DATASETS = False # Use when already created/downloaded
-TRAIN = True
+TRAIN = False
 if USE_TRAINED is False and TRAIN is False:
     raise RuntimeError("When not using pre-trained models, a new model must be trained")
 
-NUM_SAMPLES = 200 * 1000#2 * 1000 * 1000 # Number of samples to read from sample files
+NUM_SAMPLES = 1000 * 1000#2 * 1000 * 1000 # Number of samples to read from sample files
 TRAIN_PERCENT = 0.90 # Proportion of dataset used for training (rest used for test)
-EPOCHS = 50
+EPOCHS = 300
 BATCH_SIZE = 1000
 SHOW_VOL_CHARTS = True # Show smile section charts
 # For comparison to reference values (accuracy of reference)
@@ -151,7 +151,7 @@ else:
     # Initialize the model
     HIDDEN_LAYERS = ['softplus', 'softplus', 'softplus']
     # NUM_NEURONS = 128
-    NUM_NEURONS = 64
+    NUM_NEURONS = 128
     DROP_OUT = 0.0
     keras_model = compose_model(input_dim, output_dim, HIDDEN_LAYERS, NUM_NEURONS, DROP_OUT)
     topology = { 'layers': HIDDEN_LAYERS, 'neurons': NUM_NEURONS, 'dropout': DROP_OUT}
@@ -167,8 +167,8 @@ print(f"> Drop-out rate: {DROP_OUT:.2f}")
 # ################ Train the model ################################################################
 if TRAIN:
     # Learning rate scheduler
-    INIT_LR = 1.0e-2#1.0e-2
-    FINAL_LR = 1.0e-3#1.0e-4
+    INIT_LR = 1.0e-3#1.0e-2
+    FINAL_LR = 1.0e-4#1.0e-4
     TARGET_EPOCH = EPOCHS * 0.90  # Epoch by which we plan to be down to 110% of final LR
     PERIODS = 10  # Number of oscillation periods until target epoch
 
@@ -227,15 +227,16 @@ print(f"> RMSE on test set: {test_rmse:,.2f}")
 if SHOW_VOL_CHARTS:
     print("> Choosing a sample parameter set to display chart")
     NUM_STRIKES = 100
-    PARAMS = { 'LnVol': 0.20, 'Beta': 0.5, 'Nu': 0.55, 'Rho': -0.25, 'Gamma': 0.7, 'Kappa': 1.0,
+    PARAMS = { 'LnVol': 0.30, 'Beta': 0.5, 'Nu': 0.50, 'Rho': -0.10, 'Gamma': 0.7, 'Kappa': 1.0,
                 'Theta': 0.03, 'Xi': 0.35 }
-    FWD = 0.028
+    FWD = 0.055
 
     # Any number of expiries can be calculated, but for optimum display choose no more than 6
     if MODEL_TYPE == "FbSABR":
         EXPIRIES = np.asarray([0.25, 0.50, 1.0, 2.0, 5.0, 10.0]).reshape(-1, 1) # Only trained up to 5y
     else:
         EXPIRIES = np.asarray([0.25, 0.50, 1.0, 5.0, 10.0, 30.0]).reshape(-1, 1)
+        # EXPIRIES = np.asarray([0.25, 0.50, 1.0, 2.0, 3.0, 5.0]).reshape(-1, 1)
     NUM_EXPIRIES = EXPIRIES.shape[0]
 
     # Calculate market strikes and prices on the training spreads
@@ -247,12 +248,16 @@ if SHOW_VOL_CHARTS:
     mkt_strikes = TRAINING_SPREADS / 10000.0 + FWD
 
     # Calculate market prices and vols
-    mkt_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, True)
-    mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, False)
+    rel_noise = 0.02
+    noise_thresh = 0.9
+    mkt_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, True,
+                                             rel_noise=rel_noise, noise_thresh=noise_thresh)
+    mkt_prices = bachelier.price_straddles(EXPIRIES, mkt_strikes, FWD, mkt_vols)
+    # mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, False)
 
     # Use model to get parameters at each expiry, then calculate parameters and then prices
     mod_params, mod_vols = generator.price_straddles_mod(model, EXPIRIES, mkt_strikes, FWD,
-                                                           mkt_vols, True)
+                                                         mkt_vols, True)
     # mod_vols = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, mod_params, True)
 
     # mkt_prices = generator.price_straddles_ref(EXPIRIES, mkt_strikes, FWD, PARAMS, False)

sdevpy-1.0.4/src/sdevpy/thirdparty/py_lets_be_rational/__init__.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+"""
+py_lets_be_rational
+~~~~~~~~~~~~~~~~~~~
+
+Pure python implementation of Peter Jaeckel's LetsBeRational.
+
+:copyright: © 2017 Gammon Capital LLC
+:license: MIT, see LICENSE for more details.
+
+About LetsBeRational:
+~~~~~~~~~~~~~~~~~~~~~
+
+The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
+
+======================================================================================
+Copyright © 2013-2014 Peter Jäckel.
+
+Permission to use, copy, modify, and distribute this software is freely granted,
+provided that this notice is preserved.
+
+WARRANTY DISCLAIMER
+The Software is provided "as is" without warranty of any kind, either express or implied,
+including without limitation any implied warranties of condition, uninterrupted use,
+merchantability, fitness for a particular purpose, or non-infringement.
+======================================================================================
+"""
+
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import black
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import normalised_black
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import normalised_black_call
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import implied_volatility_from_a_transformed_rational_guess
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import implied_volatility_from_a_transformed_rational_guess_with_limited_iterations
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import normalised_implied_volatility_from_a_transformed_rational_guess
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import normalised_implied_volatility_from_a_transformed_rational_guess_with_limited_iterations
+from sdevpy.thirdparty.py_lets_be_rational.lets_be_rational import normalised_vega
+from sdevpy.thirdparty.py_lets_be_rational.normaldistribution import norm_cdf
+
+# from py_lets_be_rational.lets_be_rational import black
+# from py_lets_be_rational.lets_be_rational import normalised_black
+# from py_lets_be_rational.lets_be_rational import normalised_black_call
+# from py_lets_be_rational.lets_be_rational import implied_volatility_from_a_transformed_rational_guess
+# from py_lets_be_rational.lets_be_rational import implied_volatility_from_a_transformed_rational_guess_with_limited_iterations
+# from py_lets_be_rational.lets_be_rational import normalised_implied_volatility_from_a_transformed_rational_guess
+# from py_lets_be_rational.lets_be_rational import normalised_implied_volatility_from_a_transformed_rational_guess_with_limited_iterations
+# from py_lets_be_rational.lets_be_rational import normalised_vega
+# from py_lets_be_rational.normaldistribution import norm_cdf

sdevpy-1.0.4/src/sdevpy/thirdparty/py_lets_be_rational/constants.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+
+"""
+py_lets_be_rational.constants
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pure python implementation of Peter Jaeckel's LetsBeRational.
+
+:copyright: © 2017 Gammon Capital LLC
+:license: MIT, see LICENSE for more details.
+
+About LetsBeRational:
+~~~~~~~~~~~~~~~~~~~~~
+
+The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .
+
+======================================================================================
+Copyright © 2013-2014 Peter Jäckel.
+
+Permission to use, copy, modify, and distribute this software is freely granted,
+provided that this notice is preserved.
+
+WARRANTY DISCLAIMER
+The Software is provided "as is" without warranty of any kind, either express or implied,
+including without limitation any implied warranties of condition, uninterrupted use,
+merchantability, fitness for a particular purpose, or non-infringement.
+======================================================================================
+"""
+
+from __future__ import absolute_import
+
+from sys import float_info
+DBL_MIN, DBL_MAX = float_info.min, float_info.max
+# from _testcapi import DBL_MIN, DBL_MAX
+
+import sys
+from math import sqrt
+
+DBL_EPSILON = sys.float_info.epsilon
+
+SQRT_DBL_EPSILON = sqrt(DBL_EPSILON)
+FOURTH_ROOT_DBL_EPSILON = sqrt(SQRT_DBL_EPSILON)
+EIGHTH_ROOT_DBL_EPSILON = sqrt(FOURTH_ROOT_DBL_EPSILON)
+SIXTEENTH_ROOT_DBL_EPSILON = sqrt(EIGHTH_ROOT_DBL_EPSILON)
+SQRT_DBL_MIN = sqrt(DBL_MIN)
+SQRT_DBL_MAX = sqrt(DBL_MAX)
+
+# Set this to 0 if you want positive results for (positive) denormalized inputs, else to DBL_MIN.
+# Note that you cannot achieve full machine accuracy from denormalized inputs!
+DENORMALIZATION_CUTOFF = 0
+
+VOLATILITY_VALUE_TO_SIGNAL_PRICE_IS_BELOW_INTRINSIC = -DBL_MAX
+VOLATILITY_VALUE_TO_SIGNAL_PRICE_IS_ABOVE_MAXIMUM = DBL_MAX
+
+ONE_OVER_SQRT_TWO = 0.7071067811865475244008443621048490392848359376887
+ONE_OVER_SQRT_TWO_PI = 0.3989422804014326779399460599343818684758586311649
+SQRT_TWO_PI = 2.506628274631000502415765284811045253006986740610
+
+TWO_PI = 6.283185307179586476925286766559005768394338798750
+SQRT_PI_OVER_TWO = 1.253314137315500251207882642405522626503493370305  # sqrt(pi/2) to avoid misinterpretation.
+SQRT_THREE = 1.732050807568877293527446341505872366942805253810
+SQRT_ONE_OVER_THREE = 0.577350269189625764509148780501957455647601751270
+TWO_PI_OVER_SQRT_TWENTY_SEVEN = 1.209199576156145233729385505094770488189377498728  # 2*pi/sqrt(27)
+PI_OVER_SIX = 0.523598775598298873077107230546583814032861566563