moqua 0.2.2__tar.gz → 0.2.4__tar.gz

{moqua-0.2.2 → moqua-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moqua
-Version: 0.2.2
+Version: 0.2.4
 Summary: Quantitative Finance Tools
 Author: M. Drici
 Requires-Dist: numpy

{moqua-0.2.2 → moqua-0.2.4}/moqua/__init__.py

@@ -20,6 +20,9 @@ from .core import (
     log_returns
 )
 
+# Explicitly expose subpackages for better discovery
+from . import contracts, engine, instruments
+
 # ==========================================
 # 2. PRICING (Moteurs & Instruments)
 # ==========================================
@@ -65,4 +68,4 @@ from .outputs import (
     create_excel_report
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.4"

moqua-0.2.4/moqua/pricing/engine/__init__.py

@@ -0,0 +1 @@
+# Init file for engine module

moqua-0.2.4/moqua/pricing/engine/bachelier.py

@@ -0,0 +1,83 @@
+import numpy as np
+from moqua.core import pdf, cdf
+from moqua.pricing.contracts import Calculator, Engine, Option, Market
+from functools import cached_property
+
+class BachelierCalculator(Calculator):
+
+    def __init__(self, F, K, T, r, sigma_N, w):
+        self.F       = np.asarray(F, float)
+        self.K       = np.asarray(K, float)
+        self.T       = np.asarray(T, float)
+        self.r       = np.asarray(r, float)
+        self.sigma_N = np.asarray(sigma_N, float)
+        self.w       = np.asarray(w, float)
+
+    @cached_property
+    def discount(self):
+        return np.exp(-self.r * self.T)
+
+    @cached_property
+    def mask(self):
+        return (self.T <= 0.0) | (self.sigma_N <= 1e-10)
+
+    @cached_property
+    def safe_sqrt_T(self):
+        return np.where(~self.mask, np.sqrt(self.T), 1.0)
+
+    @cached_property
+    def d(self):
+        return (self.F - self.K) / (self.sigma_N * self.safe_sqrt_T)
+
+    @cached_property
+    def price(self):
+        val = self.discount * (
+            self.w * (self.F - self.K) * cdf(self.w * self.d) + 
+            self.sigma_N * np.sqrt(np.maximum(self.T, 0.0)) * pdf(self.d)
+        )
+        payoff = np.maximum(0.0, self.w * (self.F - self.K))
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def delta(self):
+        val = self.w * self.discount * cdf(self.w * self.d)
+        payoff = np.where(self.w * (self.F - self.K) > 0, self.w * self.discount, 0.0)
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def gamma(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            val = self.discount * pdf(self.d) / (self.sigma_N * self.safe_sqrt_T)
+        return self._result(np.where(self.mask, 0.0, val))
+
+    @cached_property
+    def vega(self):
+        val = self.discount * self.safe_sqrt_T * pdf(self.d)
+        return self._result(np.where(self.mask, 0.0, val))
+
+    @cached_property
+    def rho(self):
+        val = -self.T * self.price
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+    @cached_property
+    def theta(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            term1 = -(self.discount * self.sigma_N * pdf(self.d)) / (2.0 * np.sqrt(np.maximum(self.T, 1e-10)))
+        
+        term2 = self.r * self.price
+        val = (term1 + term2) / 365.0
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+
+class BachelierEngine(Engine):
+    def calculator(self, option: Option, market: Market):
+        if market.F is None and market.S is None:
+            raise ValueError("Bachelier requires 'forward' or 'spot'.")
+        
+        F = market.F if market.F is not None else market.S * np.exp(market.r * option.T)
+        
+        return BachelierCalculator(
+            F=F, K=option.K,   # No np.maximum(F, 1e-10) because Bachelier handles negative F and K!
+            T=option.T, r=market.r, sigma_N=market.sigma, w=option.w
+        )

moqua-0.2.4/moqua/pricing/engine/black76.py

@@ -0,0 +1,95 @@
+import numpy as np
+from moqua.core import pdf, cdf
+from moqua.pricing.contracts import Calculator, Engine, Option, Market
+from functools import cached_property
+
+class Black76Calculator(Calculator):
+
+    def __init__(self, F, K, T, r, sigma, w):
+        self.F     = np.asarray(F, float)
+        self.K     = np.asarray(K, float)
+        self.T     = np.asarray(T, float)
+        self.r     = np.asarray(r, float)
+        self.sigma = np.asarray(sigma, float)
+        self.w     = np.asarray(w, float)
+
+    @cached_property
+    def discount(self):
+        return np.exp(-self.r * self.T)
+
+    @cached_property
+    def mask(self):
+        return (self.T <= 0.0) | (self.sigma <= 1e-10)
+
+    @cached_property
+    def vol_sqrt_T(self):
+        return self.sigma * np.sqrt(np.maximum(self.T, 0.0))
+
+    @cached_property
+    def safe_vol(self):
+        return np.where(~self.mask, self.vol_sqrt_T, 1.0)
+
+    @cached_property
+    def d1(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            return (np.log(self.F / self.K) + (0.5 * self.sigma ** 2) * self.T) / self.safe_vol
+    
+    @cached_property
+    def d2(self):
+        return self.d1 - self.vol_sqrt_T
+
+    @cached_property
+    def price(self):
+        val = self.w * self.discount * (self.F * cdf(self.w * self.d1) - self.K * cdf(self.w * self.d2))
+        payoff = np.maximum(0.0, self.w * (self.F - self.K))
+
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def delta(self):
+
+        val = self.w * self.discount * cdf(self.w * self.d1)
+        payoff = np.where(self.w * (self.F - self.K) > 0, self.w * self.discount, 0.0)
+        
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def gamma(self):
+
+        with np.errstate(divide='ignore', invalid='ignore'):
+            val = self.discount * pdf(self.d1) / (self.F * self.vol_sqrt_T)
+        bad = self.mask | (self.F <= 0)
+        
+        return self._result(np.where(bad, 0.0, val))
+
+    @cached_property
+    def vega(self):
+        val = self.F * self.discount * pdf(self.d1) * np.sqrt(np.maximum(self.T, 0.0))
+        return self._result(np.where(self.mask, 0.0, val))
+
+    @cached_property
+    def rho(self):
+        val = -self.T * self.price
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+    @cached_property
+    def theta(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            term1 = -(self.F * self.discount * pdf(self.d1) * self.sigma) / (2.0 * np.sqrt(np.maximum(self.T, 1e-10)))
+        
+        term2 = self.r * self.price
+        val = (term1 + term2) / 365.0
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+
+class Black76Engine(Engine):
+    def calculator(self, option: Option, market: Market):
+        if market.F is None and market.S is None:
+            raise ValueError("Black76 requires 'forward' or 'spot'.")
+        
+        F = market.F if market.F is not None else market.S * np.exp(market.r * option.T)
+        
+        return Black76Calculator(
+            F=np.maximum(F, 1e-10), K=option.K, 
+            T=option.T, r=market.r, sigma=market.sigma, w=option.w
+        )

moqua-0.2.4/moqua/pricing/engine/black_scholes.py

@@ -0,0 +1,100 @@
+import numpy as np
+from moqua.core import pdf, cdf
+from moqua.pricing.contracts import Calculator, Engine, Option, Market
+from functools import cached_property
+
+class BlackScholesCalculator(Calculator):
+    
+    def __init__(self, S, K, T, r, sigma, w):
+        self.S     = np.asarray(S, float)
+        self.K     = np.asarray(K, float)
+        self.T     = np.asarray(T, float)
+        self.r     = np.asarray(r, float)
+        self.sigma = np.asarray(sigma, float)
+        self.w     = np.asarray(w, float)
+
+    # Private helpers
+    @cached_property
+    def discount(self):
+        return np.exp(-self.r * self.T)
+
+    @cached_property
+    def mask(self):
+        return (self.T <= 0) | (self.sigma <= 1e-10)
+    
+    @cached_property
+    def vol_sqrt_T(self):
+        return self.sigma * np.sqrt(np.maximum(self.T, 0.0))
+    
+    @cached_property
+    def safe_vol(self):
+        return np.where(~self.mask, self.vol_sqrt_T, 1.0)
+
+    @cached_property
+    def d1(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            return (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / self.safe_vol
+
+    @cached_property
+    def d2(self):
+        return self.d1 - self.vol_sqrt_T
+
+    @cached_property
+    def price(self):
+
+        val    = self.w * (self.S * cdf(self.w * self.d1) - self.K * self.discount * cdf(self.w * self.d2))
+        payoff = np.maximum(0.0, self.w * (self.S - self.K))
+
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def delta(self):
+
+        val    = self.w * cdf(self.w * self.d1)
+        payoff = np.where(self.w * (self.S - self.K) > 0, self.w, 0.0)    # ITM -> w, OTM -> 0
+
+        return self._result(np.where(self.mask, payoff, val))
+
+    @cached_property
+    def gamma(self):
+
+        with np.errstate(divide='ignore', invalid='ignore'):
+            val = pdf(self.d1) / (self.S * self.vol_sqrt_T)
+        bad = self.mask | (self.S <= 0)
+        
+        return self._result(np.where(bad, 0.0, val))
+
+    @cached_property
+    def vega(self):
+
+        val = self.S * pdf(self.d1) * np.sqrt(np.maximum(self.T, 0.0))
+        
+        return self._result(np.where(self.mask, 0.0, val))
+
+    @cached_property
+    def rho(self):
+
+        val = self.w * self.K * self.T * self.discount * cdf(self.w * self.d2)
+
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+    @cached_property
+    def theta(self):
+
+        with np.errstate(divide='ignore', invalid='ignore'):
+            term1 = -(self.S * pdf(self.d1) * self.sigma) / (2.0 * np.sqrt(np.maximum(self.T, 1e-10)))
+
+        term2 = -self.w * self.r * self.K * self.discount * cdf(self.w * self.d2)
+        val   = (term1 + term2) / 365.0
+
+        return self._result(np.where(self.T <= 0, 0.0, val))
+
+
+class BlackScholesEngine(Engine):
+    def calculator(self, option: Option, market: Market):
+        if market.S is None: raise ValueError("Spot is missing")
+        return BlackScholesCalculator(
+            S=np.maximum(market.S, 1e-10), K=option.K,
+            T=option.T, r=market.r, sigma=market.sigma, w=option.w
+        )
+

moqua-0.2.4/moqua/pricing/instruments/__init__.py

@@ -0,0 +1 @@
+# Init file for instruments module

moqua-0.2.4/moqua/pricing/instruments/european_option.py

@@ -0,0 +1,37 @@
+import numpy as np
+from moqua.pricing.contracts import Calculator, Engine, Option, Market
+
+class EuropeanOptionPricer:
+
+    def __init__(self, engine: Engine, yield_curve=None, vol_surface=None):
+        self.engine = engine
+        self.yield_curve = yield_curve
+        self.vol_surface = vol_surface
+
+    def set_engine(self, new_engine: Engine):
+        self.engine = new_engine
+
+    def get_calculator(self, K, T, spot=None, forward=None, r=None, sigma=None, option_type='call') -> Calculator:
+        w = np.where(np.asarray(option_type) == 'call', 1.0, -1.0)
+        option = Option(K=K, T=T, w=w)
+        
+        if r is not None:
+            r_val = r
+        elif self.yield_curve is not None:
+            r_val = self.yield_curve.get_rate(T)
+        else:
+            raise ValueError("You must provide 'r' directly or configure a 'yield_curve'.")
+            
+        if sigma is not None:
+            sigma_val = sigma
+        elif self.vol_surface is not None:
+            sigma_val = self.vol_surface.get_vol(K, T)
+        else:
+            raise ValueError("You must provide 'sigma' directly or configure a 'vol_surface'.")
+
+        market = Market(
+            r=r_val,
+            sigma=sigma_val,
+            S=spot, F=forward
+        )
+        return self.engine.calculator(option, market)

{moqua-0.2.2 → moqua-0.2.4}/moqua.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moqua
-Version: 0.2.2
+Version: 0.2.4
 Summary: Quantitative Finance Tools
 Author: M. Drici
 Requires-Dist: numpy

{moqua-0.2.2 → moqua-0.2.4}/moqua.egg-info/SOURCES.txt

@@ -13,6 +13,12 @@ moqua.egg-info/requires.txt
 moqua.egg-info/top_level.txt
 moqua/pricing/__init__.py
 moqua/pricing/contracts.py
+moqua/pricing/engine/__init__.py
+moqua/pricing/engine/bachelier.py
+moqua/pricing/engine/black76.py
+moqua/pricing/engine/black_scholes.py
+moqua/pricing/instruments/__init__.py
+moqua/pricing/instruments/european_option.py
 src/erf_cody.cpp
 src/lets_be_rational.cpp
 src/normaldistribution.cpp

{moqua-0.2.2 → moqua-0.2.4}/setup.py

@@ -26,7 +26,7 @@ ext_modules = [
 
 setup(
     name="moqua",
-    version="0.2.2",
+    version="0.2.4",
     packages=find_packages(),
     ext_modules=ext_modules,
     install_requires=[