quantark 0.1.1__tar.gz → 0.2.0__tar.gz

{quantark-0.1.1 → quantark-0.2.0}/CHANGELOG.md

@@ -5,6 +5,20 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 During 0.x the public API may still change between minor versions.
 
+## [0.1.2] - 2026-06-13
+
+### Added
+- Credit dual-measure framework: a recovery convention layer
+  (`quantark.asset.credit.conventions`, `STANDARD_RECOVERY=0.40`) that
+  separates the canonical shared-curve **hazard01** factor from the
+  recovery-converted **CS01** used by products and SIMM. Curve shocks stay
+  in hazard space; spread stresses convert through the recovery convention.
+- Single-name CDS **roll-down / as-of pricing** via effective and maturity
+  dates (seasoned and forward-start), with `schedule_asof` and a
+  total-return coupon cash ledger threaded through the dynamic-scenario and
+  backtest engines. SIMM buckets the remaining tenor. (Basket as-of is
+  deferred.)
+
 ## [0.1.1] - 2026-06-11
 
 ### Added

{quantark-0.1.1 → quantark-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantark
-Version: 0.1.1
+Version: 0.2.0
 Summary: Modular derivatives pricing and risk library: options, autocallables, bonds, VaR, SIMM
 Project-URL: Homepage, https://github.com/deiiiiii93/quantark
 Project-URL: Repository, https://github.com/deiiiiii93/quantark
@@ -34,6 +34,7 @@ Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: scipy>=1.10.0
 Requires-Dist: seaborn>=0.12.0
 Provides-Extra: dev
+Requires-Dist: pytest-xdist>=3.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
@@ -73,6 +74,13 @@ QuantArk is designed with a clean, modular architecture that separates concerns
   - Monte Carlo VaR (simulation-based with stress testing)
 - **Bond Pricing**: Fixed rate bonds, FRNs, and bond options
 - **Interest Rate Swaps**: Pricing and risk metrics (DV01)
+- **FX Derivatives**: Garman-Kohlhagen vanilla, digital, and quanto options;
+  spot / forward / swap delta-one products with two-curve discounting
+- **FX Portfolio & Risk**: `FXPortfolio` plus full integration with the
+  portfolio risk stack — FX stress testing, Value-at-Risk (parametric /
+  historical / Monte Carlo with two-rate factors), multi-day dynamic scenarios,
+  delta-neutral backtest hedging, and ISDA SIMM v2.6 initial margin
+  (one `FXPosition` feeds all five; see `example/fx_portfolio_risk_demo.py`)
 - **Greeks Calculation**:
   - Analytical Greeks using closed-form formulas
   - Numerical Greeks using finite difference method (FDM)
@@ -168,6 +176,43 @@ print(f"Rho:   {analytical_greeks['rho']:.6f}")
 
 ```
 
+### FX Options
+
+```python
+from datetime import datetime
+
+from quantark.asset.fx.engine.analytical import GarmanKohlhagenEngine
+from quantark.asset.fx.product import CurrencyPair
+from quantark.asset.fx.product.option import FxVanillaOption
+from quantark.param import SpotQuote, FlatVolSurface, FlatRateCurve
+from quantark.priceenv import FxPricingEnvironment
+from quantark.util.enum import OptionType
+
+fx_env = FxPricingEnvironment(
+    valuation_date=datetime(2026, 6, 12),
+    spot_quote=SpotQuote(spot=1.20),            # EUR/USD
+    domestic_curve=FlatRateCurve(rate=0.05),    # USD
+    foreign_curve=FlatRateCurve(rate=0.03),     # EUR
+    vol_surface=FlatVolSurface(volatility=0.10),
+)
+
+option = FxVanillaOption(
+    currency_pair=CurrencyPair("EUR", "USD"),
+    strike=1.25,
+    option_type=OptionType.CALL,
+    maturity=1.0,
+    notional_foreign=1_000_000.0,   # 1m EUR
+)
+
+engine = GarmanKohlhagenEngine()
+print(f"Price: {engine.price(option, fx_env):,.2f} USD")
+print(f"Delta: {engine.calculate_greeks(option, fx_env)['delta']:,.2f} EUR")
+```
+
+See `example/fx_vanilla_option_demo.py`, `example/fx_digital_option_demo.py`,
+`example/fx_quanto_option_demo.py`, and `example/fx_deltaone_demo.py` for
+digitals, quantos, and delta-one products.
+
 For portfolio Value-at-Risk (parametric, historical, and Monte Carlo engines
 with risk-factor attribution), see the runnable demos:
 `example/parametric_var_demo.py`, `example/portfolio_var_demo.py`, and
@@ -217,6 +262,16 @@ The demo showcases:
 3. Put-Call Parity verification
 4. Comparison between analytical and numerical Greeks
 
+### FX portfolio across the full risk stack
+
+```bash
+python example/fx_portfolio_risk_demo.py   # one FX book through all four risk modules
+python example/fx_stress_test_demo.py      # FX stress testing (spot/vol/two-rate shocks)
+python example/fx_var_demo.py              # FX VaR (parametric / historical / Monte Carlo)
+python example/fx_dynamic_scenario_demo.py # multi-day FX path simulation
+python example/fx_backtest_demo.py         # FX delta-neutral hedging backtest
+```
+
 ## Project Structure
 
 ```
@@ -241,10 +296,16 @@ QuantArk/
 │   │   ├── engine/    # Bond pricing engines
 │   │   ├── product/   # Bond products
 │   │   └── riskmeasures/  # Bond risk measures
-│   └── rate/          # Interest rate derivatives
-│       ├── engine/    # IR pricing engines
-│       ├── product/   # IR products
-│       └── riskmeasures/  # IR risk measures
+│   ├── rate/          # Interest rate derivatives
+│   │   ├── engine/    # IR pricing engines
+│   │   ├── product/   # IR products
+│   │   └── riskmeasures/  # IR risk measures
+│   └── fx/            # FX derivatives
+│       ├── engine/    # Garman-Kohlhagen, digital, quanto, delta-one
+│       ├── process/   # Garman-Kohlhagen process
+│       ├── product/   # Options (vanilla/digital/quanto) and delta-one
+│       ├── report/    # Formatted pricing reports
+│       └── riskmeasures/  # FX Greeks calculator
 ├── param/              # Market data parameters
 │   ├── div/           # Dividend yields
 │   ├── quote/         # Spot quotes
@@ -265,10 +326,11 @@ QuantArk/
 │   └── config.py      # VaR configuration
 ├── portfolio/         # Portfolio management
 │   ├── equity/        # Equity portfolios
-│   └── fi/            # Fixed income portfolios
-├── backtest/          # Hedging strategy backtesting
-├── dynamicscenario/   # Multi-day scenario simulation
-├── stresstest/        # Stress testing framework
+│   ├── fi/            # Fixed income portfolios
+│   └── fx/            # FX portfolios (FXPortfolio / FXPosition)
+├── backtest/          # Hedging strategy backtesting (equity / fi / fx)
+├── dynamicscenario/   # Multi-day scenario simulation (equity / fi / fx)
+├── stresstest/        # Stress testing framework (equity / fi / fx)
 ├── util/              # Utilities
 │   ├── enum/          # Enumerations
 │   └── exceptions.py  # Exception hierarchy

{quantark-0.1.1 → quantark-0.2.0}/README.md

@@ -34,6 +34,13 @@ QuantArk is designed with a clean, modular architecture that separates concerns
   - Monte Carlo VaR (simulation-based with stress testing)
 - **Bond Pricing**: Fixed rate bonds, FRNs, and bond options
 - **Interest Rate Swaps**: Pricing and risk metrics (DV01)
+- **FX Derivatives**: Garman-Kohlhagen vanilla, digital, and quanto options;
+  spot / forward / swap delta-one products with two-curve discounting
+- **FX Portfolio & Risk**: `FXPortfolio` plus full integration with the
+  portfolio risk stack — FX stress testing, Value-at-Risk (parametric /
+  historical / Monte Carlo with two-rate factors), multi-day dynamic scenarios,
+  delta-neutral backtest hedging, and ISDA SIMM v2.6 initial margin
+  (one `FXPosition` feeds all five; see `example/fx_portfolio_risk_demo.py`)
 - **Greeks Calculation**:
   - Analytical Greeks using closed-form formulas
   - Numerical Greeks using finite difference method (FDM)
@@ -129,6 +136,43 @@ print(f"Rho:   {analytical_greeks['rho']:.6f}")
 
 ```
 
+### FX Options
+
+```python
+from datetime import datetime
+
+from quantark.asset.fx.engine.analytical import GarmanKohlhagenEngine
+from quantark.asset.fx.product import CurrencyPair
+from quantark.asset.fx.product.option import FxVanillaOption
+from quantark.param import SpotQuote, FlatVolSurface, FlatRateCurve
+from quantark.priceenv import FxPricingEnvironment
+from quantark.util.enum import OptionType
+
+fx_env = FxPricingEnvironment(
+    valuation_date=datetime(2026, 6, 12),
+    spot_quote=SpotQuote(spot=1.20),            # EUR/USD
+    domestic_curve=FlatRateCurve(rate=0.05),    # USD
+    foreign_curve=FlatRateCurve(rate=0.03),     # EUR
+    vol_surface=FlatVolSurface(volatility=0.10),
+)
+
+option = FxVanillaOption(
+    currency_pair=CurrencyPair("EUR", "USD"),
+    strike=1.25,
+    option_type=OptionType.CALL,
+    maturity=1.0,
+    notional_foreign=1_000_000.0,   # 1m EUR
+)
+
+engine = GarmanKohlhagenEngine()
+print(f"Price: {engine.price(option, fx_env):,.2f} USD")
+print(f"Delta: {engine.calculate_greeks(option, fx_env)['delta']:,.2f} EUR")
+```
+
+See `example/fx_vanilla_option_demo.py`, `example/fx_digital_option_demo.py`,
+`example/fx_quanto_option_demo.py`, and `example/fx_deltaone_demo.py` for
+digitals, quantos, and delta-one products.
+
 For portfolio Value-at-Risk (parametric, historical, and Monte Carlo engines
 with risk-factor attribution), see the runnable demos:
 `example/parametric_var_demo.py`, `example/portfolio_var_demo.py`, and
@@ -178,6 +222,16 @@ The demo showcases:
 3. Put-Call Parity verification
 4. Comparison between analytical and numerical Greeks
 
+### FX portfolio across the full risk stack
+
+```bash
+python example/fx_portfolio_risk_demo.py   # one FX book through all four risk modules
+python example/fx_stress_test_demo.py      # FX stress testing (spot/vol/two-rate shocks)
+python example/fx_var_demo.py              # FX VaR (parametric / historical / Monte Carlo)
+python example/fx_dynamic_scenario_demo.py # multi-day FX path simulation
+python example/fx_backtest_demo.py         # FX delta-neutral hedging backtest
+```
+
 ## Project Structure
 
 ```
@@ -202,10 +256,16 @@ QuantArk/
 │   │   ├── engine/    # Bond pricing engines
 │   │   ├── product/   # Bond products
 │   │   └── riskmeasures/  # Bond risk measures
-│   └── rate/          # Interest rate derivatives
-│       ├── engine/    # IR pricing engines
-│       ├── product/   # IR products
-│       └── riskmeasures/  # IR risk measures
+│   ├── rate/          # Interest rate derivatives
+│   │   ├── engine/    # IR pricing engines
+│   │   ├── product/   # IR products
+│   │   └── riskmeasures/  # IR risk measures
+│   └── fx/            # FX derivatives
+│       ├── engine/    # Garman-Kohlhagen, digital, quanto, delta-one
+│       ├── process/   # Garman-Kohlhagen process
+│       ├── product/   # Options (vanilla/digital/quanto) and delta-one
+│       ├── report/    # Formatted pricing reports
+│       └── riskmeasures/  # FX Greeks calculator
 ├── param/              # Market data parameters
 │   ├── div/           # Dividend yields
 │   ├── quote/         # Spot quotes
@@ -226,10 +286,11 @@ QuantArk/
 │   └── config.py      # VaR configuration
 ├── portfolio/         # Portfolio management
 │   ├── equity/        # Equity portfolios
-│   └── fi/            # Fixed income portfolios
-├── backtest/          # Hedging strategy backtesting
-├── dynamicscenario/   # Multi-day scenario simulation
-├── stresstest/        # Stress testing framework
+│   ├── fi/            # Fixed income portfolios
+│   └── fx/            # FX portfolios (FXPortfolio / FXPosition)
+├── backtest/          # Hedging strategy backtesting (equity / fi / fx)
+├── dynamicscenario/   # Multi-day scenario simulation (equity / fi / fx)
+├── stresstest/        # Stress testing framework (equity / fi / fx)
 ├── util/              # Utilities
 │   ├── enum/          # Enumerations
 │   └── exceptions.py  # Exception hierarchy

{quantark-0.1.1 → quantark-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quantark"
-version = "0.1.1"
+version = "0.2.0"
 description = "Modular derivatives pricing and risk library: options, autocallables, bonds, VaR, SIMM"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -42,7 +42,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["pytest>=7.0.0"]
+dev = ["pytest>=7.0.0", "pytest-xdist>=3.0.0"]
 
 [project.urls]
 Homepage = "https://github.com/deiiiiii93/quantark"

{quantark-0.1.1 → quantark-0.2.0}/quantark/__init__.py

@@ -1,3 +1,3 @@
 """QuantArk: professional financial derivatives pricing library."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{quantark-0.1.1 → quantark-0.2.0}/quantark/asset/__init__.py

@@ -3,6 +3,8 @@ Asset classes for different derivative types.
 """
 from . import equity
 from . import bond
+from . import fx
+from . import credit
 
-__all__ = ['equity', 'bond']
+__all__ = ['equity', 'bond', 'fx', 'credit']
 

quantark-0.2.0/quantark/asset/credit/__init__.py

@@ -0,0 +1,20 @@
+"""Credit derivatives asset class (CDS, basket CDS)."""
+from quantark.asset.credit.product import (
+    CDS,
+    ProtectionSide,
+    BasketCDS,
+    BasketType,
+    CopulaType,
+)
+from quantark.asset.credit.engine.analytical import CDSReducedFormEngine
+from quantark.asset.credit.engine.mc import BasketCDSEngine
+
+__all__ = [
+    "CDS",
+    "ProtectionSide",
+    "BasketCDS",
+    "BasketType",
+    "CopulaType",
+    "CDSReducedFormEngine",
+    "BasketCDSEngine",
+]

quantark-0.2.0/quantark/asset/credit/conventions.py

@@ -0,0 +1,29 @@
+"""
+Market conventions for translating between CDS quoted spreads and hazard
+intensities.
+
+Under the credit triangle ``s = lambda (1 - R)`` a quoted-spread move maps to a
+hazard-intensity move only once a recovery rate is fixed. The hazard curve is
+shared across positions that may carry different contractual recoveries, so a
+*curve-level* spread shock is undefined unless a recovery convention is supplied
+explicitly; this module provides the ISDA-standard default and the conversion.
+"""
+from quantark.util.exceptions import ValidationError
+
+#: ISDA-standard senior-unsecured recovery, used as the default convention when
+#: a curve-level spread shock must be converted to a hazard shift and no
+#: instrument-specific recovery is supplied.
+STANDARD_RECOVERY = 0.40
+
+
+def spread_shift_to_hazard_shift(
+    spread_shift: float, recovery: float = STANDARD_RECOVERY
+) -> float:
+    """Absolute spread move -> hazard move: ``Δlambda = Δs / (1 - R)``."""
+    lgd = 1.0 - recovery
+    if lgd <= 1e-6:
+        raise ValidationError(
+            "Spread-to-hazard conversion is undefined at full recovery (R=1): "
+            "the spread s = lambda (1 - R) is identically zero."
+        )
+    return spread_shift / lgd

quantark-0.2.0/quantark/asset/credit/engine/__init__.py

@@ -0,0 +1,4 @@
+"""Credit pricing engines."""
+from .base_credit_engine import BaseCreditEngine
+
+__all__ = ["BaseCreditEngine"]

quantark-0.2.0/quantark/asset/credit/engine/analytical/__init__.py

@@ -0,0 +1,4 @@
+"""Analytical / semi-analytical credit pricing engines."""
+from .reduced_form import CDSReducedFormEngine
+
+__all__ = ["CDSReducedFormEngine"]

quantark-0.2.0/quantark/asset/credit/engine/analytical/reduced_form.py

@@ -0,0 +1,220 @@
+"""
+CDS pricing engine for a reduced-form model (hazard read from the curve).
+
+The premium and protection legs are valued by numerical integration of the
+survival and discount curves supplied by the
+:class:`~quantark.priceenv.CreditPricingEnvironment`. The hazard curve may be
+flat (constant intensity) or term-structured; this engine reads survival and
+default-density from the curve and so handles both.
+"""
+import math
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+from quantark.asset.credit.engine.base_credit_engine import BaseCreditEngine
+from quantark.asset.credit.engine.schedule import (
+    cds_coupon_schedule,
+    cds_coupon_schedule_asof,
+    year_fraction_act365,
+)
+from quantark.asset.credit.product.cds import CDS
+from quantark.priceenv import CreditPricingEnvironment
+from quantark.util.exceptions import NumericalError
+
+# Daily integration step (years) for the protection leg and premium accrual.
+_DT = 1.0 / 365.0
+# Remaining maturities below this (years) are treated as a matured contract.
+_EPS = 1e-9
+
+# Zero result returned for a matured / expired CDS.
+_EXPIRED: Dict[str, float] = {
+    "premium_leg": 0.0,
+    "protection_leg": 0.0,
+    "fair_spread": 0.0,
+    "fair_spread_bps": 0.0,
+    "present_value": 0.0,
+}
+
+
+def _time_grid(start: float, end: float) -> np.ndarray:
+    """Integration grid on ``[start, end]`` ending exactly at ``end``.
+
+    ``start`` is the protection-start offset (years from the valuation date),
+    nonzero only for a forward-starting contract whose effective date lies in
+    the future; it is zero for a spot or seasoned trade.
+    """
+    span = max(end - start, 0.0)
+    n_steps = max(1, int(math.ceil(span / _DT)))
+    return np.linspace(start, end, n_steps + 1)
+
+
+class CDSReducedFormEngine(BaseCreditEngine):
+    """Reduced-form CDS pricing engine valuing premium and protection legs."""
+
+    def price(self, product: CDS, env: CreditPricingEnvironment) -> float:
+        """Present value to the protection holder per ``product.side``."""
+        res = self.calculate(product, env)
+        return product.side_sign * res["present_value"]
+
+    def calculate(self, product: CDS, env: CreditPricingEnvironment) -> Dict[str, float]:
+        """
+        Value both legs and the fair spread.
+
+        Returns a dict with ``premium_leg``, ``protection_leg``,
+        ``fair_spread``, ``fair_spread_bps`` and ``present_value`` — the last
+        always from the protection *buyer*'s perspective
+        (``protection_leg - premium_leg``).
+
+        For a *dated* contract (``product.effective_date`` set) the contract is
+        valued as of ``env.valuation_date``: settled coupons are excluded, the
+        remaining maturity is measured from the contractual dates, and a matured
+        contract values to zero.
+        """
+        schedule, prot_start, prot_end, as_of_time = self._as_of_params(product, env)
+        if prot_end <= prot_start + _EPS:  # matured — nothing left to value
+            return dict(_EXPIRED)
+
+        protection_leg = self._protection_leg(product, env, prot_start, prot_end)
+        rpv01 = self._premium_leg(
+            product, env, 1.0, schedule, prot_start, prot_end, as_of_time
+        )
+        if rpv01 <= 0:
+            raise NumericalError("CDS risky annuity (RPV01) is non-positive")
+
+        premium_leg = product.coupon_spread * rpv01
+        present_value = protection_leg - premium_leg
+        fair_spread = protection_leg / rpv01
+        return {
+            "premium_leg": premium_leg,
+            "protection_leg": protection_leg,
+            "fair_spread": fair_spread,
+            "fair_spread_bps": fair_spread * 10_000.0,
+            "present_value": present_value,
+        }
+
+    def fair_spread(self, product: CDS, env: CreditPricingEnvironment) -> float:
+        """Par (fair) running spread that sets the contract PV to zero."""
+        return self.calculate(product, env)["fair_spread"]
+
+    # ------------------------------------------------------------------ #
+    # As-of resolution
+    # ------------------------------------------------------------------ #
+    @staticmethod
+    def _as_of_params(
+        product: CDS, env: CreditPricingEnvironment
+    ) -> Tuple[List[Tuple[float, float]], float, float, float]:
+        """
+        Resolve ``(schedule, protection_start, protection_end, as_of_time)`` for
+        valuation, with all times measured *from the valuation date* (consistent
+        with the as-of-dated discount and survival curves).
+
+        * ``protection_start`` — years until protection begins. Zero for a spot
+          or seasoned trade; positive for a forward-starting contract whose
+          effective date is still in the future.
+        * ``protection_end`` — years until the contract matures.
+        * ``as_of_time`` — *signed* seasoning: years elapsed since the effective
+          date (negative before the effective date). Used to anchor the
+          accrued-on-default leg to the original coupon calendar.
+
+        For an un-dated contract this is the legacy tenor-based schedule starting
+        immediately (``protection_start = 0``, ``as_of_time = 0``).
+        """
+        if not product.is_dated:
+            schedule = cds_coupon_schedule(product.maturity, product.payment_freq)
+            return schedule, 0.0, product.maturity, 0.0
+
+        as_of_time = year_fraction_act365(product.effective_date, env.valuation_date)
+        total = year_fraction_act365(product.effective_date, product.maturity_date)
+        protection_end = total - as_of_time
+        protection_start = max(0.0, -as_of_time)  # forward-start delay, else 0
+        if protection_end <= protection_start + _EPS:
+            return [], protection_start, protection_end, as_of_time
+        schedule = cds_coupon_schedule_asof(
+            product.effective_date,
+            product.maturity_date,
+            product.payment_freq,
+            env.valuation_date,
+        )
+        return schedule, protection_start, protection_end, as_of_time
+
+    # ------------------------------------------------------------------ #
+    # Legs
+    # ------------------------------------------------------------------ #
+    def _protection_leg(
+        self,
+        product: CDS,
+        env: CreditPricingEnvironment,
+        prot_start: float,
+        prot_end: float,
+    ) -> float:
+        """PV of the default-contingent payment N*(1-R)*E[DF * default density].
+
+        Integrated only over the live protection window ``[prot_start, prot_end]``
+        (times from the valuation date). ``prot_start`` is nonzero only for a
+        forward-starting contract, so no protection is credited before the
+        effective date.
+        """
+        lgd = product.notional * (1.0 - product.recovery_rate)
+        grid = _time_grid(prot_start, prot_end)
+        pv = 0.0
+        for i in range(1, len(grid)):
+            t = float(grid[i])
+            density = env.get_default_density(t)
+            discount = env.get_discount_factor(t)
+            pv += lgd * discount * density * (t - float(grid[i - 1]))
+        return pv
+
+    def _premium_leg(
+        self,
+        product: CDS,
+        env: CreditPricingEnvironment,
+        spread: float,
+        schedule: List[Tuple[float, float]],
+        prot_start: float,
+        prot_end: float,
+        as_of_time: float,
+    ) -> float:
+        """
+        PV of the premium leg for a given running ``spread``.
+
+        Linear in ``spread``; calling with ``spread=1.0`` yields the risky
+        annuity (RPV01). Includes scheduled coupons (survival-weighted) plus
+        premium accrued from the last coupon date to the default date. ``schedule``
+        already holds only the unsettled coupons with payment times relative to
+        the valuation date; ``as_of_time`` is the signed seasoning offset so the
+        accrued-on-default leg references the correct contractual coupon dates,
+        and accrual is only credited inside the live protection window.
+        """
+        notional = product.notional
+        payment_interval = 1.0 / product.payment_freq
+
+        # Scheduled coupon payments, conditional on survival. The schedule
+        # includes the final (possibly short) stub coupon ending at maturity,
+        # and each coupon's accrual is the actual period since the prior coupon.
+        pv_scheduled = 0.0
+        for t, accrual in schedule:
+            survival = env.get_survival_probability(t)
+            discount = env.get_discount_factor(t)
+            pv_scheduled += spread * notional * accrual * discount * survival
+
+        # Premium accrued to the default date (paid on default). The default
+        # time ``t`` is measured from valuation; the contractual elapsed time is
+        # ``as_of_time + t`` so the last coupon date is found on the original
+        # calendar. Accrual is credited only over the live protection window
+        # (a forward-starting trade accrues nothing before its effective date).
+        grid = _time_grid(prot_start, prot_end)
+        pv_accrued = 0.0
+        for i in range(1, len(grid)):
+            t = float(grid[i])
+            contractual_t = as_of_time + t
+            last_payment_time = payment_interval * int(contractual_t / payment_interval)
+            if last_payment_time >= contractual_t:
+                last_payment_time -= payment_interval
+            accrual_period = contractual_t - last_payment_time
+            density = env.get_default_density(t)
+            discount = env.get_discount_factor(t)
+            accrued = spread * notional * accrual_period
+            pv_accrued += accrued * discount * density * (t - float(grid[i - 1]))
+
+        return pv_scheduled + pv_accrued

quantark-0.2.0/quantark/asset/credit/engine/base_credit_engine.py

@@ -0,0 +1,31 @@
+"""
+Base class for credit pricing engines.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict
+
+from quantark.asset.credit.product.base_credit_product import BaseCreditProduct
+from quantark.priceenv import CreditPricingEnvironment
+
+
+class BaseCreditEngine(ABC):
+    """
+    Abstract base class for credit pricing engines.
+
+    Engines compute present values and risk measures from a product
+    specification and a :class:`CreditPricingEnvironment`.
+    """
+
+    @abstractmethod
+    def price(
+        self, product: BaseCreditProduct, env: CreditPricingEnvironment
+    ) -> float:
+        """Present value of the product from the position holder's perspective."""
+
+    def calculate_greeks(
+        self, product: BaseCreditProduct, env: CreditPricingEnvironment
+    ) -> Dict[str, float]:
+        """Risk measures for the product. Default: not implemented per engine."""
+        raise NotImplementedError(
+            f"{type(self).__name__} does not implement calculate_greeks"
+        )

quantark-0.2.0/quantark/asset/credit/engine/mc/__init__.py

@@ -0,0 +1,4 @@
+"""Monte-Carlo credit pricing engines."""
+from .basket_copula import BasketCDSEngine
+
+__all__ = ["BasketCDSEngine"]