/// Black-76 call — actual code from ReflexLibs.Ai/options/black76
/// High-precision NormDist injectable: StandardNormDist (f64, erfc tail-stable)
/// or StandardNormDistDecimal (128-bit, 28-digit arithmetic)
#[inline]
pub fn price_of_call_nd<N: NormDist>(
    nd: &N,
    forward: f64, strike: f64, time_to_expiry: f64, volatility: f64,
) -> Result<f64, Black76Error> {
    if forward <= 0.0 { return Err(Black76Error::NegativeForward); }
    let t_vol = volatility * time_to_expiry.sqrt();
    let d1 = (forward / strike).ln() / t_vol + 0.5 * t_vol;
    let d2 = d1 - t_vol;
    Ok((forward * nd.cdf(d1) - strike * nd.cdf(d2)).max(0.0))
}

// f64 — StandardNormDist (erfc-based, tail-stable)
let price = price_of_call_nd(&StandardNormDist, F, K, T_market, sigma)?;

// Decimal128 — StandardNormDistDecimal (28-digit arithmetic)
let price = lognormal_decimal::price_of_call_nd(
    &StandardNormDistDecimal, F, K, T_market, sigma)?;

// Time-dilated — FOMC/NFP event warping baked into T
let T_market = dilation.scale_interval(now, expiry);
let price = price_of_call_nd(&StandardNormDist, F, K, T_market, sigma)?;

Rust in ReflexLibs

Recent Updates

// Two ports, one MathIR — dual provenance for every future stochastic-vol family

public static class HestonNormalFromPaper {    // Path A — SSRN 2445328, negative-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// Φ(τ,u,ν₀) = exp(C(τ) + D(τ)ν₀ − iu·x₀)  ← paper convention

}

public static class HestonNormalFromHeritage { // Path B — heritage, positive-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// phi(u) = exp(cv + dv·v0 + i·u·forward), called with −u ← heritage convention

}

// Cross-check: |A − B| < 1e-10 on 25 randomised parameter sweeps.

// Sidani Table 1: reproduced at 5e-5 by BOTH paths.  Heritage vectors: 1e-9.

// Priority: explicit Version > AsOf-inferred > default (V2)

public static bool IsCoicopValidAsOf(string coicop, EcoicopVersion version)

=> coicop switch {

    "CP023" => version is V2 or V3,   // COICOP 2018 — from Feb 2026

    "CP022" => version is V1,          // COICOP 1999 — pre Feb 2026

    _       => true                    // era-independent

};

use rust_decimal_macros::dec;



// Exact decimal arithmetic — no float rounding

let result = dec!(0.1) + dec!(0.2);

assert_eq!(result, dec!(0.3)); // ✓ exact



// C# cross-validation:

// decimal r = 0.1m + 0.2m;

// Debug.Assert(r == 0.3m); // ✓ same result

// Black-76 call price — Heritage C++ reference implementation
// 15 years in production. Every port validates against this.
constexpr inline double call_price(
    double F, double K, double D, double sigma, double T) noexcept {
    const auto total_vol = sigma * std::sqrt(T);
    const auto d1 = (std::log(F / K) + 0.5 * sigma * sigma * T) / total_vol;
    const auto d2 = d1 - total_vol;
    return D * (F * N(d1) - K * N(d2));
}

C++ in ReflexLibs

Recent Updates

// Two ports, one MathIR — dual provenance for every future stochastic-vol family

public static class HestonNormalFromPaper {    // Path A — SSRN 2445328, negative-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// Φ(τ,u,ν₀) = exp(C(τ) + D(τ)ν₀ − iu·x₀)  ← paper convention

}

public static class HestonNormalFromHeritage { // Path B — heritage, positive-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// phi(u) = exp(cv + dv·v0 + i·u·forward), called with −u ← heritage convention

}

// Cross-check: |A − B| < 1e-10 on 25 randomised parameter sweeps.

// Sidani Table 1: reproduced at 5e-5 by BOTH paths.  Heritage vectors: 1e-9.

// SABR implied vol — Hagan et al. approximation

pub fn sabr_vol(f: f64, k: f64, t: f64, alpha: f64, beta: f64, rho: f64, nu: f64) -> f64 {

// Full Hagan formula — handles ATM, smile wings, and time decay

// Cross-validated against C++ reference to 1e-12 precision

}

// Rustification philosophy:

// No NaN propagation → Result<f64, PricingError>

// No exceptions      → explicit error handling

// No unsafe          → safe abstractions only

// No hidden state    → pure functions, injectable dependencies

// Bitwise parity     → same output as C++ reference

// Black-76 call — actual pattern from ReflexLibs.Ai
// High-precision INormDist<T> injectable — ErfcNormDist for tail-stable deep OTM puts
// At parity with Rust: same _nd pattern, same injectable trait
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static OneOf<double, Black76Error> PriceOfCallNd(
    INormDist nd,
    double forward, double strike,
    double timeToExpiry, double volatility) {
    if (forward <= 0) return Black76Error.NegativeForward;
    var tVol = volatility * Math.Sqrt(timeToExpiry);
    var d1 = Math.Log(forward / strike) / tVol + 0.5 * tVol;
    var d2 = d1 - tVol;
    return Math.Max(forward * nd.Cdf(d1) - strike * nd.Cdf(d2), 0);
}

// f64 — ErfcNormDist (erfc-based, tail-stable)
var price = PriceOfCallNd(new ErfcNormDist(), F, K, T_market, sigma);

// Decimal128 — DecimalNormDist (28-digit System.Decimal)
var price = PriceOfCallNdDecimal(new DecimalNormDist(), F, K, T_market, sigma);

// Time-dilated: FOMC + NFP event warping
var T_market = dilation.ScaleInterval(now, expiry);
var price = PriceOfCallNd(new ErfcNormDist(), F, K, T_market, sigma);

C# in ReflexLibs

Recent Updates

// Two ports, one MathIR — dual provenance for every future stochastic-vol family

public static class HestonNormalFromPaper {    // Path A — SSRN 2445328, negative-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// Φ(τ,u,ν₀) = exp(C(τ) + D(τ)ν₀ − iu·x₀)  ← paper convention

}

public static class HestonNormalFromHeritage { // Path B — heritage, positive-i

public static double PriceOfCall(double F, double K, double tau, /* ... */) { /* ... */ }

// phi(u) = exp(cv + dv·v0 + i·u·forward), called with −u ← heritage convention

}

// Cross-check: |A − B| < 1e-10 on 25 randomised parameter sweeps.

// Sidani Table 1: reproduced at 5e-5 by BOTH paths.  Heritage vectors: 1e-9.

// Priority: explicit Version > AsOf-inferred > default (V2)

public static bool IsCoicopValidAsOf(string coicop, EcoicopVersion version)

=> coicop switch {

    "CP023" => version is V2 or V3,   // COICOP 2018 — from Feb 2026

    "CP022" => version is V1,          // COICOP 1999 — pre Feb 2026

    _       => true                    // era-independent

};

// Golden key format: {GEO}.HICP.{COICOP}.{BASE}

// e.g. EUR.HICP.XTOB.2015 — HICPxT Euro Area 2015 base



var idx = InflationIndex.Parse("EUR.HICP.XTOB.2015");

// idx.GoldenKey        = "EUR.HICP.XTOB.2015"

// idx.EurostatCoicop   = "TOT_X_TBC"

// idx.LegacySymbol     = "EUR.HICPXTOB.2015"

// Black-76 call price — Go implementation (planned)
// Same MathIR spec, same test vectors, Go idioms
func CallPrice(F, K, D, sigma, T float64) (float64, error) {
    if math.IsNaN(F) { return 0, ErrNaN }
    totalVol := sigma * math.Sqrt(T)
    d1 := (math.Log(F/K) + 0.5*sigma*sigma*T) / totalVol
    d2 := d1 - totalVol
    return D * (F*normCdf(d1) - K*normCdf(d2)), nil
}

Go in ReflexLibs

// nano-math.wit — actual WIT from the repo
// package xll-ai:nano-math@6.4.12

interface special-math {
    /// Standard normal CDF Φ(x). Range: (0, 1).
    phi:  func(x: f64) -> result<f64, math-error>;
    /// Complementary error function erfc(x) = 1 - erf(x).
    erfc: func(x: f64) -> result<f64, math-error>;
}

interface decimal-math {
    /// 28-digit decimal — bit-compatible with rust_decimal + System.Decimal
    record decimal28 { lo: u32, mid: u32, hi: u32, flags: u32 }

    /// Normal CDF to ~7 significant digits in decimal arithmetic.
    phi:  func(x: f64) -> result<decimal28, math-error>;
}

/// No export ever returns NaN or Infinity — errors are explicit.
variant math-error {
    non-finite-input,
    negative-input,
    overflow,
}

// JavaScript host — inject high-precision phi into Black-76
const { phi } = await instantiate(wasmBytes);  // WIT component
const T_market = dilation.scaleInterval(now, expiry);
const price = black76Call(F, K, D, sigma, T_market, phi);  // phi injected

JavaScript in ReflexLibs

Recent Updates

# Oracle test vectors in TOML — same file drives C#, Rust, and JS tests

[[vectors]]

description = "Black-76 lognormal ATM call"

f    = 1.02

k    = 1.02

t    = 1.0

vol  = 0.20

df   = 0.98

cp   = 1

expected = 0.07797...  # identical across all three languages

// NanoTable — server-side HTML, client-side themes

var model = new NanoTableBuilder()

.AddRow(["EUR", "HICP", "XTOB", "2015", "1.0234"])

.WithTheme(NanoTheme.DarkGreen)

.Build();

var html = NanoTableRenderer.RenderHtml(model);

// Black-76 call — Type-safe, generated from MathIR
// NaN caught at compile time via Result<T, PricingError>
export function callPrice(
    F: number, K: number, D: number,
    sigma: number, T: number
): Result<number, PricingError> {
    if (Number.isNaN(F)) return { ok: false, error: PricingError.NaN };
    const totalVol = sigma * Math.sqrt(T);
    const d1 = (Math.log(F / K) + 0.5 * sigma ** 2 * T) / totalVol;
    const d2 = d1 - totalVol;
    return { ok: true, value: D * (F * normCdf(d1) - K * normCdf(d2)) };
}

TypeScript in ReflexLibs

# Black-76 call — Generated from MathIR (TOML → Python)
# Rustified style: tuple result, explicit NaN guard
def call_price(F: float, K: float, D: float,
               sigma: float, T: float) -> MathResult:
    if math.isnan(F): return (False, float('nan'))
    total_vol = sigma * math.sqrt(T)
    d1 = (math.log(F / K) + 0.5 * sigma**2 * T) / total_vol
    d2 = d1 - total_vol
    return (True, D * (F * norm_cdf(d1) - K * norm_cdf(d2)))

Python in ReflexLibs

Recent Updates

# MathIR spec — one source, five languages

[function.black76_d1]

inputs  = ["f:f64", "k:f64", "t:f64", "vol:f64"]

formula = "( ln(f/k) + 0.5 * vol^2 * t ) / ( vol * sqrt(t) )"

# Emits: C#, Rust, C++, Python, JavaScript — all correct

// Black-76 — actual CUDA kernel from ReflexLibs.Ai/cuda
// __host__ __device__ : runs on both CPU and GPU
__host__ __device__ inline float norm_cdf(float x) {
    const float INV_SQRT2 = 0.70710678118654752440f;
    return 0.5f * erfcf(-x * INV_SQRT2);
}

__host__ __device__ inline void black76_one(
    float F, float K, float T, float sigma, float DF,
    float& call, float& put) {
    float sqrtT = sqrtf(T);
    float d1 = (logf(F / K) + 0.5f * sigma * sigma * T) / (sigma * sqrtT);
    float d2 = d1 - sigma * sqrtT;
    call = DF * (F * norm_cdf(d1) - K * norm_cdf(d2));
    put  = DF * (K * norm_cdf(-d2) - F * norm_cdf(-d1));
}

__global__ void black76_kernel(
    int n, const float* F, const float* K, const float* T,
    const float* V, const float* DF, float* C, float* P) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) black76_one(F[i], K[i], T[i], V[i], DF[i], C[i], P[i]);
}

CUDA in ReflexLibs

// Black-76 call — Pure Excel LAMBDA, no VBA, no add-in
// Paste into Name Manager, use from any cell

BLACK76.CALL = LAMBDA(F, K, D, sigma, T,
  LET(
    tv,  sigma * SQRT(T),
    d1,  (LN(F/K) + 0.5*sigma^2*T) / tv,
    d2,  d1 - tv,
    D * (F * NORM.S.DIST(d1,1) - K * NORM.S.DIST(d2,1))
  )
)

Excel Lambda in ReflexLibs