deriweave-python 0.3.0__cp312-cp312-win_amd64.whl

deriweave_py/composition.py

@@ -0,0 +1,560 @@
+"""Composable contract descriptions for the native DeriWeave pricing engine.
+
+Objects here are *recipes*, not wrappers around live C++ pointers.  They can be
+reused in as many products as needed. On price(), the recipes are converted to
+fresh, exclusively owned DeriWeave C++ expressions and products.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from math import isfinite
+from numbers import Real
+from enum import Enum
+from types import MappingProxyType
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._core import PricingResult, SimulationSettings, MarketPath, Cashflow
+from typing import Any, Mapping, Sequence
+
+
+def _number(value: float, name: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, Real):
+        raise TypeError(f"{name} must be a real number")
+    v = float(value)
+    if not isfinite(v):
+        raise ValueError(f"{name} must be finite")
+    return v
+
+
+class _ExerciseTime(Enum):
+    CURRENT = "exercise"
+
+
+ExerciseTime = _ExerciseTime.CURRENT
+"""Symbolic decision date for Spot/Variance inside an American contract."""
+
+
+def _time(value: float, name: str) -> float:
+    result = _number(value, name)
+    if result < 0:
+        raise ValueError(f"{name} must be non-negative")
+    return result
+
+
+def _observation_time(value: float | _ExerciseTime) -> float | str:
+    return "exercise" if value is ExerciseTime else _time(value, "observation date")
+
+
+def _freeze(obj: Any) -> Any:
+    if isinstance(obj, Mapping):
+        return MappingProxyType({k: _freeze(v) for k, v in obj.items()})
+    if isinstance(obj, (list, tuple)):
+        return tuple(_freeze(v) for v in obj)
+    return obj
+
+
+@dataclass(frozen=True)
+class Asset:
+    identifier: str
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.identifier, str) or not self.identifier:
+            raise ValueError("Asset identifier must be a non-empty string")
+
+    def __str__(self) -> str:
+        return self.identifier
+
+
+def _asset_name(asset: Asset | str) -> str:
+    if isinstance(asset, Asset):
+        return asset.identifier
+    if not isinstance(asset, str) or not asset:
+        raise TypeError("asset must be an Asset or a non-empty string")
+    return asset
+
+
+@dataclass(frozen=True)
+class ValueExpression:
+    """Declarative description of a DeriWeave ValueExpression."""
+
+    kind: str
+    fields: Mapping[str, Any]
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "fields", _freeze(self.fields))
+
+    def to_spec(self) -> dict[str, Any]:
+        return {"kind": self.kind, **_recursive_copy(self.fields)}
+
+    def __mul__(self, factor: float) -> ValueExpression:
+        return Scaled(self, factor)
+
+    def __rmul__(self, factor: float) -> ValueExpression:
+        return Scaled(self, factor)
+
+
+def _recursive_copy(obj: Any) -> Any:
+    if isinstance(obj, Mapping):
+        return {k: _recursive_copy(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_recursive_copy(v) for v in obj]
+    return obj
+
+
+def _expr(value: ValueExpression) -> dict[str, Any]:
+    if not isinstance(value, ValueExpression):
+        raise TypeError("Expected ValueExpression (use Constant(number) for a constant)")
+    return value.to_spec()
+
+
+def Spot(asset: Asset | str, at: float | _ExerciseTime) -> ValueExpression:
+    return ValueExpression("spot", {"asset": _asset_name(asset), "at": _observation_time(at)})
+
+
+def Variance(asset: Asset | str, at: float | _ExerciseTime) -> ValueExpression:
+    """Heston's instantaneous variance V_t, *not* its volatility."""
+    return ValueExpression("variance", {"asset": _asset_name(asset), "at": _observation_time(at)})
+
+
+def Constant(value: float) -> ValueExpression:
+    return ValueExpression("constant", {"value": _number(value, "value")})
+
+
+def Scaled(value: ValueExpression, factor: float) -> ValueExpression:
+    return ValueExpression("scaled", {"value": _expr(value), "factor": _number(factor, "factor")})
+
+
+def _strike(strike: float | ValueExpression) -> float | dict[str, Any]:
+    if isinstance(strike, ValueExpression):
+        return _expr(strike)
+    value = _number(strike, "strike")
+    if value < 0:
+        raise ValueError("Fixed strike must be non-negative; use Constant for a floating expression")
+    return value
+
+
+def Call(value: ValueExpression, strike: float | ValueExpression) -> ValueExpression:
+    return ValueExpression("call", {"value": _expr(value), "strike": _strike(strike)})
+
+
+def Put(value: ValueExpression, strike: float | ValueExpression) -> ValueExpression:
+    return ValueExpression("put", {"value": _expr(value), "strike": _strike(strike)})
+
+
+def Digital(value: ValueExpression, threshold: float | ValueExpression,
+            amount: float = 1.0, comparison: str = ">=") -> ValueExpression:
+    if comparison not in ("<", "<=", ">", ">="):
+        raise ValueError("comparison must be one of <, <=, >, >=")
+    if _number(amount, "amount") < 0:
+        raise ValueError("Digital amount must be non-negative")
+    return ValueExpression("digital", {
+        "value": _expr(value), "threshold": (_expr(threshold) if isinstance(threshold, ValueExpression) else _number(threshold, "threshold")),
+        "amount": _number(amount, "amount"), "comparison": comparison,
+    })
+
+
+def Basket(items: Sequence[ValueExpression], weights: Sequence[float]) -> ValueExpression:
+    parts = [_expr(item) for item in items]
+    w = [_number(weight, "weight") for weight in weights]
+    if any(weight < 0 for weight in w) or (w and not any(weight > 0 for weight in w)):
+        raise ValueError("Basket weights must be non-negative with at least one positive weight")
+    if not parts or len(parts) != len(w):
+        raise ValueError("Basket items and weights must have the same nonzero length")
+    return ValueExpression("basket", {"items": parts, "weights": w})
+
+
+def Average(items: Sequence[ValueExpression] | Asset | str, *,
+            dates: Sequence[float] | None = None, method: str = "arithmetic") -> ValueExpression:
+    """Average a list of expressions, or one asset observed at multiple dates."""
+    if isinstance(items, (Asset, str)):
+        if dates is None:
+            raise ValueError("dates are required when Average receives an asset")
+        values = [Spot(items, t) for t in dates]
+    else:
+        if dates is not None:
+            raise ValueError("dates are only valid when Average receives an asset")
+        values = list(items)
+    if not values:
+        raise ValueError("Average requires at least one observation")
+    if method not in ("arithmetic", "geometric"):
+        raise ValueError("Average method must be arithmetic or geometric")
+    return ValueExpression("average", {"items": [_expr(v) for v in values], "method": method})
+
+
+def WorstOf(items: Sequence[ValueExpression]) -> ValueExpression:
+    parts = [_expr(item) for item in items]
+    if not parts:
+        raise ValueError("WorstOf requires at least one expression")
+    return ValueExpression("worst_of", {"items": parts})
+
+
+def BestOf(items: Sequence[ValueExpression]) -> ValueExpression:
+    parts = [_expr(item) for item in items]
+    if not parts:
+        raise ValueError("BestOf requires at least one expression")
+    return ValueExpression("best_of", {"items": parts})
+
+
+def Conditional(condition: ValueExpression, if_true: ValueExpression,
+                if_false: ValueExpression) -> ValueExpression:
+    """Condition must evaluate to exactly 0 or 1 (typically a Digital)."""
+    return ValueExpression("conditional", {
+        "condition": _expr(condition), "if_true": _expr(if_true), "if_false": _expr(if_false),
+    })
+
+
+@dataclass(frozen=True)
+class CashflowRule:
+    payment_date: float
+    amount: ValueExpression
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "payment_date", _time(self.payment_date, "payment_date"))
+        _require_expr(self.amount)
+
+    def to_spec(self) -> dict[str, Any]:
+        return {"payment_date": _number(self.payment_date, "payment_date"),
+                "amount": _expr(self.amount)}
+
+
+@dataclass(frozen=True, init=False)
+class ComposedProduct:
+    rules: tuple[CashflowRule, ...]
+
+    def __init__(self, rules: Sequence[CashflowRule]):
+        items = tuple(rules)
+        if not items or any(not isinstance(r, CashflowRule) for r in items):
+            raise ValueError("ComposedProduct needs one or more CashflowRule objects")
+        object.__setattr__(self, "rules", items)
+
+    def to_spec(self) -> dict[str, Any]:
+        return {"kind": "composed", "rules": [rule.to_spec() for rule in self.rules]}
+
+
+def Product(payoff: ValueExpression | Sequence[CashflowRule], *,
+            payment_date: float | None = None) -> ComposedProduct:
+    """Convenience: Product(Call(...), payment_date=1.0) or Product([rules...])."""
+    if isinstance(payoff, ValueExpression):
+        if payment_date is None:
+            raise ValueError("payment_date is mandatory for a single payoff")
+        return ComposedProduct([CashflowRule(payment_date, payoff)])
+    if payment_date is not None:
+        raise ValueError("Do not provide payment_date when passing CashflowRule objects")
+    return ComposedProduct(payoff)
+
+
+@dataclass(frozen=True, init=False)
+class DiscreteBarrier:
+    """Discrete knock-in/out wrapper; no rebate.
+
+    Monitor either one underlying on monitoring_dates, or arbitrary expressions
+    with observations=[(date, expression), ...]. These modes are exclusive.
+    """
+    product: ComposedProduct | DiscreteBarrier
+    level: float
+    direction: str
+    activation: str
+    underlying: str | None
+    monitoring_dates: tuple[float, ...] | None
+    observations: tuple[tuple[float, ValueExpression], ...] | None
+
+    def __init__(self, product: ComposedProduct | DiscreteBarrier, *, level: float,
+                 direction: str = "down", activation: str = "out",
+                 underlying: Asset | str | None = None,
+                 monitoring_dates: Sequence[float] | None = None,
+                 observations: Sequence[tuple[float, ValueExpression]] | None = None):
+        _product_spec(product)
+        if direction not in ("down", "up") or activation not in ("in", "out"):
+            raise ValueError("direction must be down/up and activation must be in/out")
+        direct = underlying is not None and monitoring_dates is not None and observations is None
+        custom = observations is not None and underlying is None and monitoring_dates is None
+        if not (direct or custom):
+            raise ValueError("Provide underlying+monitoring_dates OR observations, not both")
+        obs = None if observations is None else tuple((
+            _time(t, "observation date"), _require_expr(v)) for t, v in observations)
+        dates = None if monitoring_dates is None else tuple(_time(t, "monitoring date") for t in monitoring_dates)
+        if (obs is not None and not obs) or (dates is not None and not dates):
+            raise ValueError("Barrier needs at least one monitoring observation")
+        object.__setattr__(self, "product", product)
+        object.__setattr__(self, "level", _number(level, "level"))
+        object.__setattr__(self, "direction", direction)
+        object.__setattr__(self, "activation", activation)
+        object.__setattr__(self, "underlying", None if underlying is None else _asset_name(underlying))
+        object.__setattr__(self, "monitoring_dates", dates)
+        object.__setattr__(self, "observations", obs)
+
+    def to_spec(self) -> dict[str, Any]:
+        result = {"kind": "barrier", "product": self.product.to_spec(),
+                  "level": self.level, "direction": self.direction, "activation": self.activation}
+        if self.observations is not None:
+            result["observations"] = [
+                {"date": t, "value": _expr(expr)} for t, expr in self.observations]
+        else:
+            result["asset"] = self.underlying
+            result["monitoring_dates"] = list(self.monitoring_dates or ())
+        return result
+
+
+def _require_expr(value: ValueExpression) -> ValueExpression:
+    _expr(value)
+    return value
+
+
+@dataclass(frozen=True)
+class SpotControl:
+    asset: Asset | str
+    at: float
+
+    def to_spec(self) -> dict[str, Any]:
+        return {"kind": "spot", "asset": _asset_name(self.asset), "at": _number(self.at, "at")}
+
+
+@dataclass(frozen=True)
+class Market:
+    """Quotes mapped by asset name. Insertion order is the model's asset order."""
+    spots: Mapping[Asset | str, float]
+    rate: float
+    dividend_yields: Mapping[Asset | str, float] | None = None
+    valuation_date: date | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.spots, Mapping):
+            raise TypeError("spots must map asset names to quotes")
+        def snapshot(values: Mapping, label: str) -> Mapping:
+            if not isinstance(values, Mapping):
+                raise TypeError(f"{label} must map asset names to values")
+            result: dict[str, float] = {}
+            for key, value in values.items():
+                name = _asset_name(key)
+                if name in result:
+                    raise ValueError(f"Duplicate asset name in {label}: {name}")
+                result[name] = _number(value, label)
+            return MappingProxyType(result)
+        object.__setattr__(self, "spots", snapshot(self.spots, "spots"))
+        if self.dividend_yields is not None:
+            object.__setattr__(self, "dividend_yields", snapshot(self.dividend_yields, "dividend_yields"))
+
+    def to_spec(self) -> dict[str, Any]:
+        if not self.spots:
+            raise ValueError("Market requires at least one asset")
+        names = [_asset_name(name) for name in self.spots]
+        if len(set(names)) != len(names):
+            raise ValueError("Duplicate asset names")
+        divs = {} if self.dividend_yields is None else self.dividend_yields
+        if set(divs) - set(names):
+            raise ValueError("dividend_yields contains an unknown asset")
+        d = self.valuation_date if self.valuation_date is not None else date.today()
+        if not isinstance(d, date):
+            raise TypeError("valuation_date must be datetime.date or None")
+        return {"assets": names,
+                "spots": [_number(v, "spot") for v in self.spots.values()],
+                "dividend_yields": [_number(divs.get(name, 0.0), "dividend yield") for name in names],
+                "rate": _number(self.rate, "rate"),
+                "year": d.year, "month": d.month, "day": d.day}
+
+
+def _vector(values: float | Sequence[float] | Mapping[str, float],
+            assets: Sequence[str], label: str) -> list[float]:
+    if isinstance(values, Mapping):
+        if set(values) != set(assets):
+            raise ValueError(f"{label} keys must match market assets")
+        return [_number(values[name], label) for name in assets]
+    if isinstance(values, Real):
+        if len(assets) != 1:
+            raise ValueError(f"Scalar {label} only valid for one asset")
+        return [_number(values, label)]
+    result = [_number(v, label) for v in values]
+    if len(result) != len(assets):
+        raise ValueError(f"{label} length must equal the market asset count")
+    return result
+
+
+def _matrix(correlation: Sequence[Sequence[float]] | None, size: int) -> list[list[float]]:
+    if correlation is None:
+        return [[float(i == j) for j in range(size)] for i in range(size)]
+    result = [[_number(x, "correlation") for x in row] for row in correlation]
+    if len(result) != size or any(len(row) != size for row in result):
+        raise ValueError(f"Correlation matrix must be {size}x{size}")
+    return result
+
+
+def _params(values: Mapping[str, float] | Sequence[Mapping[str, float]] |
+            Mapping[str, Mapping[str, float]], assets: Sequence[str],
+            fields: Sequence[str]) -> list[list[float]]:
+    if isinstance(values, Mapping) and set(values) == set(fields) and len(assets) == 1:
+        rows = [values]
+    elif isinstance(values, Mapping):
+        if set(values) != set(assets):
+            raise ValueError("Model parameter asset names must match market")
+        rows = [values[name] for name in assets]
+    else:
+        rows = list(values)
+    if len(rows) != len(assets):
+        raise ValueError("Model parameter count must match market assets")
+    result = []
+    for row in rows:
+        if not isinstance(row, Mapping) or set(row) != set(fields):
+            raise ValueError(f"Model parameters must have fields {tuple(fields)}")
+        result.append([_number(row[field], field) for field in fields])
+    return result
+
+
+@dataclass(frozen=True)
+class BlackScholes:
+    volatilities: float | Sequence[float] | Mapping[str, float]
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        return {"kind": "black_scholes", "volatilities": _vector(self.volatilities, assets, "volatility"),
+                "correlation": _matrix(self.correlation, len(assets))}
+
+
+@dataclass(frozen=True)
+class Heston:
+    parameters: Mapping | Sequence[Mapping]
+    rho: float | None = None
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        spec = {"kind": "heston", "parameters": _params(self.parameters, assets, ("v0", "kappa", "theta", "xi"))}
+        if self.rho is not None:
+            if self.correlation is not None:
+                raise ValueError("Provide rho or a full correlation matrix, not both")
+            if len(assets) != 1:
+                raise ValueError("rho is only valid for single-asset Heston")
+            spec["rho"] = _number(self.rho, "rho")
+        else:
+            if self.correlation is None:
+                raise ValueError("Heston requires rho (single asset) or a full 2N x 2N correlation")
+            spec["correlation"] = _matrix(self.correlation, 2 * len(assets))
+        return spec
+
+
+@dataclass(frozen=True)
+class Merton:
+    parameters: Mapping | Sequence[Mapping]
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        return {"kind": "merton", "parameters": _params(self.parameters, assets, ("sigma", "lambda", "mu", "delta")),
+                "correlation": _matrix(self.correlation, len(assets))}
+
+
+@dataclass(frozen=True)
+class Kou:
+    parameters: Mapping | Sequence[Mapping]
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        return {"kind": "kou", "parameters": _params(self.parameters, assets, ("sigma", "lambda", "p", "eta_plus", "eta_minus")),
+                "correlation": _matrix(self.correlation, len(assets))}
+
+
+@dataclass(frozen=True)
+class VarianceGamma:
+    sigmas: float | Sequence[float] | Mapping[str, float]
+    thetas: float | Sequence[float] | Mapping[str, float]
+    nu: float
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        return {"kind": "variance_gamma", "sigmas": _vector(self.sigmas, assets, "sigma"),
+                "thetas": _vector(self.thetas, assets, "theta"), "nu": _number(self.nu, "nu"),
+                "correlation": _matrix(self.correlation, len(assets))}
+
+
+@dataclass(frozen=True)
+class NIG:
+    sigmas: float | Sequence[float] | Mapping[str, float]
+    thetas: float | Sequence[float] | Mapping[str, float]
+    nu: float
+    correlation: Sequence[Sequence[float]] | None = None
+
+    def to_spec(self, assets: Sequence[str]) -> dict[str, Any]:
+        return {"kind": "nig", "sigmas": _vector(self.sigmas, assets, "sigma"),
+                "thetas": _vector(self.thetas, assets, "theta"), "nu": _number(self.nu, "nu"),
+                "correlation": _matrix(self.correlation, len(assets))}
+
+
+def _product_spec(product: Any) -> dict[str, Any]:
+    from .structured import AutocallProduct
+    if not isinstance(product, (ComposedProduct, DiscreteBarrier, AutocallProduct)):
+        raise TypeError("Expected ComposedProduct, DiscreteBarrier or AutocallProduct")
+    return product.to_spec()
+
+
+def _settings(settings: SimulationSettings | None) -> SimulationSettings:
+    from . import _core
+    if settings is not None and not isinstance(settings, _core.SimulationSettings):
+        raise TypeError("settings must be SimulationSettings or None")
+    return settings if settings is not None else _core.SimulationSettings()
+
+
+def _market_model(market: Market, model: Any) -> tuple[dict[str, Any], dict[str, Any]]:
+    if not isinstance(market, Market):
+        raise TypeError("market must be Market")
+    if not isinstance(model, (BlackScholes, Heston, Merton, Kou, VarianceGamma, NIG)):
+        raise TypeError("Unknown model type")
+    ms = market.to_spec()
+    return ms, model.to_spec(ms["assets"])
+
+
+def price(product: Any, *, market: Market,
+          model: BlackScholes | Heston | Merton | Kou | VarianceGamma | NIG,
+          settings: SimulationSettings | None = None,
+          control: SpotControl | None = None) -> PricingResult:
+    """Price a composed contract or evaluate a frozen exercise policy in C++.
+
+    n_simulations counts observations (two paths per antithetic observation).
+    A SpotControl requires settings.use_control_variate=True. Training a policy
+    is a separate explicit operation; this function never learns a policy.
+    """
+    from . import _core
+    if control is not None and not isinstance(control, SpotControl):
+        raise TypeError("control must be SpotControl or None")
+    mc = _settings(settings)
+    ms, model_spec = _market_model(market, model)
+    ctrl = None if control is None else control.to_spec()
+    if isinstance(product, _core.ExercisePolicy):
+        return _core.price_exercise_policy(product, ms, model_spec, mc, ctrl)
+    return _core.price_composed(_product_spec(product), ms, model_spec, mc, ctrl)
+
+
+def simulate_path(*, market: Market, model: Any, dates: Sequence[float],
+                  seed: int = 42) -> MarketPath:
+    """Generate one native path on exact dates starting at zero; requires NumPy."""
+    from . import _core
+    ms, model_spec = _market_model(market, model)
+    return _core.simulate_path(ms, model_spec, list(dates), seed)
+
+
+def evaluate(product: Any, path: MarketPath) -> list[Cashflow]:
+    """Return undiscounted native Cashflow objects on a supplied MarketPath."""
+    from . import _core
+    return _core.evaluate(_product_spec(product), path)
+
+
+def evaluate_expression(value: ValueExpression, path: MarketPath) -> float:
+    """Evaluate an expression on a native MarketPath without simulation."""
+    from . import _core
+    return _core.evaluate_expression(_expr(value), path)
+
+
+def simulation_dates(product: Any, *, settings: SimulationSettings | None = None,
+                     control: SpotControl | None = None) -> list[float]:
+    """Inspect the native numerical date union, independently of payment dates."""
+    from . import _core
+    if control is not None and not isinstance(control, SpotControl):
+        raise TypeError("control must be SpotControl or None")
+    return _core.simulation_dates(_product_spec(product), _settings(settings),
+                                 None if control is None else control.to_spec())
+
+
+def has_finite_spot_moment(*, market: Market, model: Kou | VarianceGamma | NIG,
+                           asset: Asset | str, order: float = 2) -> bool:
+    """Use the engine's moment-domain check (Kou, VG and NIG only)."""
+    from . import _core
+    ms, model_spec = _market_model(market, model)
+    return _core.has_finite_spot_moment(model_spec, ms, _asset_name(asset), _number(order, "order"))

deriweave_py/licenses/COPYING.BSD

@@ -0,0 +1,26 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/

deriweave_py/licenses/COPYING.MINPACK

@@ -0,0 +1,51 @@
+Minpack Copyright Notice (1999) University of Chicago.  All rights reserved
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above
+copyright notice, this list of conditions and the following
+disclaimer.
+
+2. Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials
+provided with the distribution.
+
+3. The end-user documentation included with the
+redistribution, if any, must include the following
+acknowledgment:
+
+   "This product includes software developed by the
+   University of Chicago, as Operator of Argonne National
+   Laboratory.
+
+Alternately, this acknowledgment may appear in the software
+itself, if and wherever such third-party acknowledgments
+normally appear.
+
+4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS"
+WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE
+UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND
+THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE
+OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY
+OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR
+USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF
+THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4)
+DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION
+UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL
+BE CORRECTED.
+
+5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT
+HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF
+ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT,
+INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF
+ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF
+PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER
+SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT
+(INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE,
+EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE
+POSSIBILITY OF SUCH LOSS OR DAMAGES.