qablet-basic 0.2.2__cp310-none-win_amd64.whl

qablet/base/base.py

@@ -0,0 +1,47 @@
+# Define Base Class for Models
+from abc import ABC, abstractmethod
+
+
+# Define Base Class for State Object for all Models
+class ModelStateBase(ABC):
+    """Class to maintain the state during a model execution."""
+
+    def __init__(self, timetable, dataset):
+        self.stats = {}
+
+    def set_stat(self, key: str, val):
+        self.stats[key] = val
+
+
+class Model(ABC):
+    """Base class for all models."""
+
+    @abstractmethod
+    def state_class(self):
+        """The class that maintains state for this model."""
+        ...
+
+    @abstractmethod
+    def price_method(self):
+        """The method that calculates price."""
+        ...
+
+    def price(self, timetable, dataset):
+        """Calculate price of contract.
+
+        Parameters:
+            timetable (dict): timetable for the contract.
+            dataset (dict): dataset for the model.
+
+        Returns:
+            price (float): price of contract
+            stats (dict): stats such as standard error
+
+        """
+
+        model_state = (self.state_class())(timetable, dataset)
+        price = self.price_method()(
+            timetable["events"], model_state, dataset, timetable["expressions"]
+        )
+
+        return price, model_state.stats

qablet/base/fixed.py

@@ -0,0 +1,13 @@
+# Define the fixed model
+
+from .._qablet import fixed_price
+from .base import Model, ModelStateBase
+
+
+# Define a determinitic Model that just uses forwards
+class FixedModel(Model):
+    def state_class(self):
+        return ModelStateBase
+
+    def price_method(self):
+        return fixed_price

qablet/base/flags.py

@@ -0,0 +1,7 @@
+from enum import IntFlag
+
+
+class Stats(IntFlag):
+    PV_VEC = 1
+    CHOICES = 2
+    PV_GRID = 4

qablet/base/mc.py

@@ -0,0 +1,33 @@
+# Generic MC model
+
+from .base import Model, ModelStateBase
+from abc import abstractmethod
+
+from .._qablet import mc_price
+
+
+# Define Base Class for State Object for MC Models
+# Todo add the abstract methods and what else is expected from this class.
+class MCStateBase(ModelStateBase):
+    """Class to maintain the state of a single asset MC process."""
+
+    def get_value(self, unit):
+        """Return the value of the asset at the current time,
+        if this asset is handled by the model, otherwise return None."""
+        return None
+
+    @abstractmethod
+    def advance(self, new_time: float):
+        ...
+
+    def set_stat(self, key: str, val):
+        self.stats[key] = val
+
+
+# Define Base Class for MC Models
+class MCModel(Model):
+    """Abstract base class for all Monte Carlo models where the stochastic model
+    is implemented in the python class."""
+
+    def price_method(self):
+        return mc_price

qablet/base/tests/test_schemas.py

@@ -0,0 +1,48 @@
+# Description: Tests for the Heston model for vanilla options.
+
+import unittest
+import numpy as np
+
+
+from qablet.base.utils import Discounter
+
+
+class TestDiscountSchema(unittest.TestCase):
+    """Tests for the discount schemas."""
+
+    def test_discounts(self):
+        """Test the Discounter class."""
+
+        # define a discount curve using the zero rate schema
+        times = np.array([0.0, 1.0, 2.0, 5.0])
+        zero_rates = np.array([0.04, 0.04, 0.045, 0.05])
+
+        test_times = [0.1, 1.0, 3.0, 5.0]
+        expected_logdf = [
+            0.1 * 0.04,
+            1.0 * 0.04,
+            2.0 * 0.045 + (0.05 * 5 - 0.045 * 2) * (3 - 2) / (5 - 2),
+            5.0 * 0.05,
+        ]
+
+        # define a discount curve using the zero rate schema
+        zero_data = ("ZERO_RATES", np.column_stack((times, zero_rates)))
+
+        # define a discount curve using the log discount schema
+        log_dfs = -times * zero_rates
+        logdf_data = ("LOG_DISCOUNTS", np.column_stack((times, log_dfs)))
+
+        for df_data in [zero_data, logdf_data]:
+            discounter = Discounter(df_data)
+            schema_name = df_data[0]
+            print(f"Testing {schema_name} schema")
+            with self.subTest(schema_name=schema_name):
+                for time, logdf in zip(test_times, expected_logdf):
+                    df = discounter.discount(time)
+                    expected_df = np.exp(-logdf)
+                    self.assertAlmostEqual(df, expected_df, places=6)
+                    print(f"{df:11.6f} {expected_df:11.6f} {df - expected_df:9.6f}")
+
+
+if __name__ == "__main__":
+    unittest.main()

qablet/base/utils.py

@@ -0,0 +1,56 @@
+# Utility classes and functions for models.
+
+from scipy import interpolate
+import numpy as np
+
+
+# Define a class for discount factors and rates.
+class Discounter:
+    """A class for discount factors and rates."""
+
+    def __init__(self, discount_data):
+        data_type, data = discount_data
+        if data_type == "LOG_DISCOUNTS":
+            # the columns are times and log discounts
+            times = data[:, 0]
+            log_discounts = data[:, 1]
+        elif data_type == "ZERO_RATES":
+            # the columns are times and zero rates
+            times = data[:, 0]
+            zero_rates = data[:, 1]
+            log_discounts = -zero_rates * times
+
+        self.log_discount_fn = interpolate.interp1d(times, log_discounts)
+
+    def rate(self, end, start=0):
+        ld_end, ld_start = self.log_discount_fn([end, start])
+
+        return (ld_start - ld_end) / (end - start)
+
+    def discount(self, t):
+        return np.exp(self.log_discount_fn(t))
+
+
+# Define a class for forwards of an asset.
+class Forwards:
+    """A class for forwards and forward rates."""
+
+    def __init__(self, forwards_data):
+        _, data = forwards_data
+
+        times = data[:, 0]
+        fwds = data[:, 1]
+
+        self.log_forward_fn = interpolate.interp1d(times, np.log(fwds))
+
+    def rate(self, end, start=0):
+        ld_end, ld_start = self.log_forward_fn([end, start])
+        return (ld_end - ld_start) / (end - start)
+
+    def forward(self, t):
+        return np.exp(self.log_forward_fn(t))
+
+
+def discounter_from_dataset(dataset):
+    """Return a discounter from a dataset."""
+    return Discounter(dataset["ASSETS"][dataset["BASE"]])

qablet/black_scholes/fd.py

@@ -0,0 +1,16 @@
+# Black Scholes model using finite difference method
+
+
+from qablet.base.base import Model, ModelStateBase
+from .._qablet import fd_blackscholes_price
+
+
+# Define the Model Class
+class BSFDModel(Model):
+    __PARAM_SCHEMA_NAME__ = "BS"
+
+    def state_class(self):
+        return ModelStateBase
+
+    def price_method(self):
+        return fd_blackscholes_price

qablet/heston/mc.py

@@ -0,0 +1,131 @@
+# Monte Carlo Pricer for Heston Model
+
+import numpy as np
+from math import sqrt
+from qablet.base.mc import MCStateBase, MCModel
+from numpy.random import Generator, SFC64
+from qablet.base.utils import Forwards
+
+
+# Define a class for the state of a single asset Heston MC process
+class HestonStateMC(MCStateBase):
+    def __init__(self, timetable, dataset):
+        super().__init__(timetable, dataset)
+
+        self.shape = dataset["MC"]["PATHS"]
+        assert self.shape % 2 == 0, "Number of paths must be even"
+        self.n = self.shape >> 1  # divide by 2
+
+        # create a random number generator
+        self.rng = Generator(SFC64(dataset["MC"]["SEED"]))
+
+        self.asset = dataset["HESTON"]["ASSET"]
+        self.asset_fwd = Forwards(dataset["ASSETS"][self.asset])
+        self.spot = self.asset_fwd.forward(0)
+
+        self.heston_params = (
+            dataset["HESTON"]["LONG_VAR"],
+            dataset["HESTON"]["VOL_OF_VAR"],
+            dataset["HESTON"]["MEANREV"],
+            dataset["HESTON"]["CORRELATION"],
+        )
+
+        # Initialize the arrays
+        self.x_vec = np.zeros(self.shape)  # processes x (log stock)
+        self.v_vec = np.full(
+            self.shape, dataset["HESTON"]["INITIAL_VAR"]
+        )  # processes v (variance)
+
+        # We will reduce time spent in memory allocation by creating arrays in advance
+        # and reusing them in the `advance` function which is called repeatedly.
+        # though the values from one timestep are not reused in the next.
+        self.tmp_vec = np.empty(self.shape, dtype=np.float64)
+        self.dz1_vec = np.empty(self.shape, dtype=np.float64)
+        self.dz2_vec = np.empty(self.shape, dtype=np.float64)
+        self.vol_vec = np.empty(self.shape, dtype=np.float64)
+        self.sv_vec = np.empty(self.shape, dtype=np.float64)
+        self.cur_time = 0
+
+    def advance(self, new_time):
+        """Update x_vec, v_vec in place when we move simulation by time dt."""
+        dt = new_time - self.cur_time
+        if dt < 1e-10:
+            return
+
+        (theta, vol_of_variance, mean_reversion_speed, correlation) = self.heston_params
+        fwd_rate = self.asset_fwd.rate(new_time, self.cur_time)
+
+        sqrtdt = sqrt(dt)
+        n = self.n
+
+        # To improve preformance we will break up the operations into np.multiply,
+        # np.add, etc. and use the `out` parameter to avoid creating temporary arrays.
+
+        # generate the random numbers
+        # we calculate dz1 = normal(0,1) * sqrtdt
+        self.rng.standard_normal(
+            n, out=self.dz1_vec[0:n]
+        )  # not much difference using out= or not
+        np.multiply(sqrtdt, self.dz1_vec[0:n], out=self.dz1_vec[0:n])
+        np.negative(self.dz1_vec[0:n], out=self.dz1_vec[n:])  # antithetic variates
+
+        # we calculate dz2 = normal(0,1) * sqrtdt * sqrt(1 - correlation * correlation) + correlation * dz1
+        self.rng.standard_normal(n, out=self.dz2_vec[0:n])
+        np.multiply(
+            sqrtdt * sqrt(1 - correlation * correlation),
+            self.dz2_vec[0:n],
+            out=self.dz2_vec[0:n],
+        )
+        np.negative(self.dz2_vec[0:n], out=self.dz2_vec[n:])  # antithetic variates
+        np.multiply(correlation, self.dz1_vec, out=self.tmp_vec)  # second term
+        np.add(self.dz2_vec, self.tmp_vec, out=self.dz2_vec)
+
+        # vol = sqrt(max(v, 0))
+        np.maximum(0.0, self.v_vec, out=self.vol_vec)
+        np.sqrt(self.vol_vec, out=self.vol_vec)
+
+        # update the current value of x (log Stock process)
+        # first term: x += (fwd_rate - vol * vol / 2.) * dt
+        np.multiply(self.vol_vec, self.vol_vec, out=self.tmp_vec)
+        np.divide(self.tmp_vec, 2, out=self.tmp_vec)
+        np.subtract(fwd_rate, self.tmp_vec, out=self.tmp_vec)
+        np.multiply(self.tmp_vec, dt, out=self.tmp_vec)
+        np.add(self.x_vec, self.tmp_vec, out=self.x_vec)
+
+        # second term: x += vol * dz1
+        np.multiply(self.vol_vec, self.dz1_vec, out=self.tmp_vec)
+        np.add(self.x_vec, self.tmp_vec, out=self.x_vec)
+
+        # update the current value of v (variance process)
+        # first term: v += mean_reversion_speed * (theta - v) * dt
+        np.subtract(theta, self.v_vec, out=self.tmp_vec)
+        np.multiply(self.tmp_vec, (mean_reversion_speed * dt), out=self.tmp_vec)
+        np.add(self.v_vec, self.tmp_vec, out=self.v_vec)
+
+        # second term: v += vol_of_variance * vol * dz2
+        np.multiply(vol_of_variance, self.vol_vec, out=self.tmp_vec)
+        np.multiply(self.tmp_vec, self.dz2_vec, out=self.tmp_vec)
+        np.add(self.v_vec, self.tmp_vec, out=self.v_vec)
+
+        # Millstein correction
+        # third term: v += 0.25 * vol_of_variance * vol_of_variance * (dz2 ** 2 - dt)
+        np.multiply(self.dz2_vec, self.dz2_vec, out=self.tmp_vec)
+        np.subtract(self.tmp_vec, dt, out=self.tmp_vec)
+        np.multiply(
+            0.25 * vol_of_variance * vol_of_variance, self.tmp_vec, out=self.tmp_vec
+        )
+        np.add(self.v_vec, self.tmp_vec, out=self.v_vec)
+
+        self.cur_time = new_time
+
+    def get_value(self, unit):
+        """Return the value of the unit at the current time."""
+        if unit == self.asset:
+            return self.spot * np.exp(self.x_vec)
+        else:
+            return None
+
+
+class HestonMCModel(MCModel):
+    def state_class(self):
+        return HestonStateMC

qablet/hullwhite/fd.py

@@ -0,0 +1,16 @@
+# Hullwhite model using finite difference method
+
+
+from qablet.base.base import Model, ModelStateBase
+from .._qablet import fd_hullwhite_price
+
+
+# Define the Model Class
+class HWFDModel(Model):
+    __PARAM_SCHEMA_NAME__ = "HW"
+
+    def state_class(self):
+        return ModelStateBase
+
+    def price_method(self):
+        return fd_hullwhite_price

qablet/local_vol/mc.py

@@ -0,0 +1,16 @@
+# Local Vol model using Monte Carlo method
+
+
+from qablet.base.base import Model, ModelStateBase
+from .. import _qablet
+
+
+# Define the Model Class
+class LVMCModel(Model):
+    __PARAM_SCHEMA_NAME__ = "LV"
+
+    def state_class(self):
+        return ModelStateBase
+
+    def price_method(self):
+        return _qablet.mc_lv_price

qablet_basic-0.2.2.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: qablet_basic
+Version: 0.2.2
+Summary: A suite of basic models to price qablet contracts. See qablet-contracts for details.
+Project-URL: Documentation, https://qablet-academy.github.io/intro/

qablet_basic-0.2.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+qablet_basic-0.2.2.dist-info/METADATA,sha256=ErmXKJ0HNva75X7nOqJc-LIPcEzq0NaPm9MiiqKvI_4,218
+qablet_basic-0.2.2.dist-info/WHEEL,sha256=S0rB2hDy1vo9ABZi7A01rQ8AAoGmft-elqksCH-s-Bw,95
+qablet/base/base.py,sha256=7C3eLnCa41QZJ_q2SNSAcAr-5Q_sKbHFTkWAoCM-Vh0,1260
+qablet/base/fixed.py,sha256=whP8JoNtAMFvWigKJsQ0suhSr9pwvBk3JI9g9vx_E6Q,307
+qablet/base/flags.py,sha256=ES4RZzlsvm-_H2ajxLqh4OKnYNp1vbMfWTZB4a0A6hg,103
+qablet/base/mc.py,sha256=3KK_I11tqE2-793GC5XRrkTpIWXkbZWL6EF30hdmuVA,952
+qablet/base/tests/test_schemas.py,sha256=LqUMZLRBI2Cq-iEHybEkHpIxkNpBdgPrBTUsq-nMoLg,1661
+qablet/base/utils.py,sha256=Yly7mGHxjeqkVyhgP0fhs8tZr0rLymH2BgzcXDVIxxc,1693
+qablet/black_scholes/fd.py,sha256=Rca9LBvQOBwgvM919NrMP0L6kITu51tu_TxPAx1XNNM,374
+qablet/black_scholes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qablet/heston/mc.py,sha256=W7blKSNlTVLjrnq-bXBirUafn6JIt6q51dlhGJqpsCU,5486
+qablet/hullwhite/fd.py,sha256=plH3uygS37DSWfA6MwDEgkrQ38dVDKvVgmoLovEiH8A,364
+qablet/local_vol/mc.py,sha256=2c4pVvcZdMjPhwqWf8eLcdKcmS3vTJaphg0i8bQbWzc,341
+qablet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qablet/_qablet.cp310-win_amd64.pyd,sha256=_qLyti5jZ-M7jRHqcAPbztpQzaQZ6OhxeJrWBgajJAM,1267200
+qablet_basic-0.2.2.dist-info/RECORD,,

qablet_basic-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.4.0)
+Root-Is-Purelib: false
+Tag: cp310-none-win_amd64