deriweave-python 0.3.0__cp312-cp312-win_amd64.whl

deriweave_py/__init__.py

@@ -0,0 +1,112 @@
+"""Composable derivatives pricing through the native DeriWeave C++20 engine."""
+from datetime import date
+from typing import Optional, Sequence
+
+from . import _core
+from .composition import (
+    Asset, ValueExpression, Spot, Variance, Constant, Scaled, Call, Put, Digital,
+    Basket, Average, WorstOf, BestOf, Conditional, CashflowRule, ComposedProduct,
+    Product, DiscreteBarrier, SpotControl, Market, BlackScholes, Heston, Merton,
+    Kou, VarianceGamma, NIG, price, ExerciseTime, simulate_path, evaluate,
+    evaluate_expression, simulation_dates, has_finite_spot_moment,
+)
+
+from .structured import (
+    AutocallObservation, AutocallProduct, ExerciseOpportunity, Bermudan, American,
+    train_longstaff_schwartz,
+)
+
+LsmSettings = _core.LsmSettings
+ExercisePolicy = _core.ExercisePolicy
+MarketPath = _core.MarketPath
+Cashflow = _core.Cashflow
+build_info = _core.build_info
+PricingResult = _core.PricingResult
+SimulationSettings = _core.SimulationSettings
+__version__ = "0.3.0"
+
+
+def _parts(valuation_date: Optional[date]) -> tuple[int, int, int]:
+    d = date.today() if valuation_date is None else valuation_date
+    if not isinstance(d, date):
+        raise TypeError("valuation_date must be a datetime.date or None")
+    return d.year, d.month, d.day
+
+
+def european(
+    option_type: str,
+    *,
+    spot: float,
+    strike: float,
+    volatility: float,
+    rate: float,
+    maturity: float,
+    dividend_yield: float = 0.0,
+    settings: Optional[SimulationSettings] = None,
+    valuation_date: Optional[date] = None,
+) -> PricingResult:
+    """Price a European call or put under one-asset Black-Scholes."""
+    year, month, day = _parts(valuation_date)
+    return _core.price_european_bs(
+        option_type, spot, strike, volatility, rate, maturity, dividend_yield,
+        year, month, day, settings if settings is not None else SimulationSettings(),
+    )
+
+
+def asian(
+    option_type: str,
+    *,
+    spot: float,
+    strike: float,
+    volatility: float,
+    rate: float,
+    maturity: float,
+    observation_dates: Sequence[float],
+    dividend_yield: float = 0.0,
+    settings: Optional[SimulationSettings] = None,
+    valuation_date: Optional[date] = None,
+) -> PricingResult:
+    """Price a fixed-strike arithmetic Asian call or put with discrete monitoring."""
+    year, month, day = _parts(valuation_date)
+    return _core.price_asian_bs(
+        option_type, spot, strike, volatility, rate, maturity, dividend_yield,
+        list(observation_dates), year, month, day,
+        settings if settings is not None else SimulationSettings(),
+    )
+
+
+def basket(
+    option_type: str,
+    *,
+    spots: Sequence[float],
+    volatilities: Sequence[float],
+    dividend_yields: Sequence[float],
+    weights: Sequence[float],
+    correlation: Sequence[Sequence[float]],
+    strike: float,
+    rate: float,
+    maturity: float,
+    settings: Optional[SimulationSettings] = None,
+    valuation_date: Optional[date] = None,
+) -> PricingResult:
+    """Price a weighted basket call or put under correlated Black-Scholes assets."""
+    year, month, day = _parts(valuation_date)
+    return _core.price_basket_bs(
+        option_type, list(spots), list(volatilities), list(dividend_yields),
+        list(weights), [list(row) for row in correlation], strike, rate,
+        maturity, year, month, day,
+        settings if settings is not None else SimulationSettings(),
+    )
+
+
+__all__ = [
+    "PricingResult", "SimulationSettings", "european", "asian", "basket",
+    "Asset", "ValueExpression", "Spot", "Variance", "Constant", "Scaled", "Call", "Put",
+    "Digital", "Basket", "Average", "WorstOf", "BestOf", "Conditional",
+    "CashflowRule", "ComposedProduct", "Product", "DiscreteBarrier", "SpotControl",
+    "AutocallObservation", "AutocallProduct", "ExerciseOpportunity", "Bermudan", "American",
+    "ExerciseTime", "LsmSettings", "ExercisePolicy", "train_longstaff_schwartz",
+    "MarketPath", "Cashflow", "simulate_path", "evaluate", "evaluate_expression",
+    "simulation_dates", "build_info", "has_finite_spot_moment",
+    "Market", "BlackScholes", "Heston", "Merton", "Kou", "VarianceGamma", "NIG", "price",
+]

deriweave_py/_core.pyi

@@ -0,0 +1,108 @@
+from typing import Any, Sequence
+
+class SimulationSettings:
+    n_simulations: int
+    max_time_step: float
+    seed: int
+    antithetic: bool
+    use_openmp: bool
+    num_threads: int
+    use_control_variate: bool
+    block_size: int
+    def __init__(self, n_simulations: int = 20000, max_time_step: float = 1.,
+                 seed: int = 42, antithetic: bool = True, use_openmp: bool = False,
+                 num_threads: int = 1, use_control_variate: bool = False,
+                 block_size: int = 1024) -> None: ...
+
+class PricingResult:
+    @property
+    def price(self) -> float: ...
+    @property
+    def variance(self) -> float: ...
+    @property
+    def standard_error(self) -> float: ...
+    @property
+    def confidence_interval_95(self) -> tuple[float, float]: ...
+    @property
+    def observation_count(self) -> int: ...
+    @property
+    def trajectory_count(self) -> int: ...
+    @property
+    def beta(self) -> float: ...
+    @property
+    def control_requested(self) -> bool: ...
+    @property
+    def control_applied(self) -> bool: ...
+
+class LsmSettings:
+    training_paths: int
+    seed: int
+    max_time_step: float
+    polynomial_degree: int
+    max_exercise_time_step: float
+    def __init__(self, training_paths: int = 20000, seed: int = 7919,
+                 max_time_step: float = 1/52, polynomial_degree: int = 2,
+                 max_exercise_time_step: float = 1/52) -> None: ...
+
+class ExercisePolicy:
+    @property
+    def exercise_dates(self) -> list[float]: ...
+    @property
+    def required_dates(self) -> list[float]: ...
+    @property
+    def training_seed(self) -> int: ...
+    @property
+    def training_path_count(self) -> int: ...
+    @property
+    def state_dimension(self) -> int: ...
+    def fitted_degree(self, exercise_index: int) -> int | None: ...
+    def fitted_basis_size(self, exercise_index: int) -> int: ...
+
+class Cashflow:
+    @property
+    def payment_date(self) -> float: ...
+    @property
+    def amount(self) -> float: ...
+
+class MarketPath:
+    def __init__(self, dates: Sequence[float], assets: Sequence[str], prices: Any,
+                 variances: Any = None) -> None: ...
+    @property
+    def dates(self) -> list[float]: ...
+    @property
+    def assets(self) -> list[str]: ...
+    @property
+    def prices(self) -> Any: ...
+    @property
+    def variances(self) -> Any | None: ...
+    @property
+    def has_variances(self) -> bool: ...
+    def spot_at(self, asset: str, at: float) -> float: ...
+    def variance_at(self, asset: str, at: float) -> float: ...
+
+def build_info() -> dict[str, Any]: ...
+def price_composed(product: dict, market: dict, model: dict,
+                   settings: SimulationSettings, control: dict | None = None) -> PricingResult: ...
+def price_exercise_policy(policy: ExercisePolicy, market: dict, model: dict,
+                          settings: SimulationSettings, control: dict | None) -> PricingResult: ...
+def train_longstaff_schwartz(contract: dict, market: dict, model: dict,
+                            settings: LsmSettings) -> ExercisePolicy: ...
+def simulate_path(market: dict, model: dict, dates: Sequence[float], seed: int) -> MarketPath: ...
+def evaluate(product: dict, path: MarketPath) -> list[Cashflow]: ...
+def evaluate_expression(value: dict, path: MarketPath) -> float: ...
+def simulation_dates(product: dict, settings: SimulationSettings,
+                     control: dict | None = None) -> list[float]: ...
+def price_european_bs(option_type: str, spot: float, strike: float, volatility: float,
+                      rate: float, maturity: float, dividend_yield: float,
+                      year: int, month: int, day: int, settings: SimulationSettings) -> PricingResult: ...
+def price_asian_bs(option_type: str, spot: float, strike: float, volatility: float,
+                  rate: float, maturity: float, dividend_yield: float,
+                  observation_dates: Sequence[float], year: int, month: int, day: int,
+                  settings: SimulationSettings) -> PricingResult: ...
+def price_basket_bs(option_type: str, spots: Sequence[float], volatilities: Sequence[float],
+                   dividend_yields: Sequence[float], weights: Sequence[float],
+                   correlation: Sequence[Sequence[float]], strike: float, rate: float,
+                   maturity: float, year: int, month: int, day: int,
+                   settings: SimulationSettings) -> PricingResult: ...
+
+def has_finite_spot_moment(model: dict, market: dict, asset: str, order: float) -> bool: ...