hypercall_margin/

black_76.rs

//! Black-76 pricing for European options on futures contracts.
//!
//! Black-76 is the forward-price variant of Black-Scholes, used for options
//! whose underlying is a futures contract. It is mathematically equivalent to
//! running Black-Scholes with spot = forward and r = 0, then discounting the
//! result by e^(-r * tau).

use crate::black_scholes::{black_scholes, calculate_greeks};
use crate::types::OptionType;

/// Price a European option on a futures contract under Black-76.
///
/// At or past expiry (`time_to_expiry <= 0`) the price is just intrinsic
/// value. There is nothing left to discount, and the `e^(-r * tau)` factor
/// would be greater than 1 for negative `tau`, inflating expired options above
/// intrinsic.
pub fn black_76_price(
    option_type: &OptionType,
    forward: f64,
    strike: f64,
    time_to_expiry: f64,
    risk_free_rate: f64,
    volatility: f64,
) -> f64 {
    if time_to_expiry <= 0.0 {
        return match option_type {
            OptionType::Call => (forward - strike).max(0.0),
            OptionType::Put => (strike - forward).max(0.0),
        };
    }

    let discount = (-risk_free_rate * time_to_expiry).exp();
    discount
        * black_scholes(
            option_type,
            forward,
            strike,
            time_to_expiry,
            0.0,
            volatility,
        )
}

/// Solve for implied volatility under Black-76, given an observed market
/// price. Returns `None` when the price violates no-arbitrage bounds or the
/// solver fails to converge.
pub fn black_76_implied_vol(
    option_type: &OptionType,
    forward: f64,
    strike: f64,
    time_to_expiry: f64,
    risk_free_rate: f64,
    market_price: f64,
) -> Option<f64> {
    let undiscounted_price = market_price * (risk_free_rate * time_to_expiry).exp();
    calculate_implied_volatility(
        option_type,
        forward,
        strike,
        time_to_expiry,
        0.0,
        undiscounted_price,
        None,
    )
}

fn calculate_implied_volatility(
    option_type: &OptionType,
    spot: f64,
    strike: f64,
    time_to_expiry: f64,
    risk_free_rate: f64,
    market_price: f64,
    initial_vol: Option<f64>,
) -> Option<f64> {
    if time_to_expiry <= 0.0 {
        return None;
    }

    let intrinsic = match option_type {
        OptionType::Call => (spot - strike).max(0.0),
        OptionType::Put => (strike - spot).max(0.0),
    };
    if market_price < intrinsic {
        return None;
    }

    let mut vol = initial_vol.unwrap_or(0.3);
    let max_iterations = 50;
    let tolerance = 1e-6;

    for _ in 0..max_iterations {
        let (price, _, _, vega, _) = calculate_greeks(
            option_type,
            spot,
            strike,
            time_to_expiry,
            risk_free_rate,
            vol,
        );
        let price_diff = price - market_price;

        if price_diff.abs() < tolerance {
            return Some(vol);
        }

        let vega_full = vega * 100.0;
        if vega_full.abs() < 1e-10 {
            break;
        }

        vol -= price_diff / vega_full;
        vol = vol.clamp(0.001, 5.0);
    }

    None
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn black_76_implied_vol_roundtrips_a_known_sigma() {
        let forward = 4700.0;
        let strike = 4700.0;
        let tau = 0.1;
        let r = 0.05;
        let sigma = 0.35;

        let call_price = black_76_price(&OptionType::Call, forward, strike, tau, r, sigma);
        let recovered =
            black_76_implied_vol(&OptionType::Call, forward, strike, tau, r, call_price)
                .expect("IV solver must converge for a well-formed input");

        assert!(
            (recovered - sigma).abs() < 1e-5,
            "roundtrip failed: input sigma = {sigma}, recovered = {recovered}",
        );
    }

    #[test]
    fn black_76_put_call_parity_holds_otm() {
        let forward = 4700.0;
        let strike = 4800.0;
        let tau = 0.25;
        let r = 0.05;
        let sigma = 0.35;

        let call = black_76_price(&OptionType::Call, forward, strike, tau, r, sigma);
        let put = black_76_price(&OptionType::Put, forward, strike, tau, r, sigma);
        let discount = (-r * tau).exp();
        let rhs = discount * (forward - strike);

        assert!(
            ((call - put) - rhs).abs() < 1e-9,
            "put-call parity failed: C - P = {}, expected {}",
            call - put,
            rhs,
        );
    }

    #[test]
    fn black_76_implied_vol_returns_none_below_intrinsic() {
        let forward = 5000.0;
        let strike = 4000.0;
        let tau = 0.25;
        let r = 0.05;
        let impossible_price = 500.0;

        let result =
            black_76_implied_vol(&OptionType::Call, forward, strike, tau, r, impossible_price);
        assert!(
            result.is_none(),
            "solver should refuse arb-violating prices, got {result:?}",
        );
    }

    #[test]
    fn black_76_implied_vol_returns_none_at_zero_tau() {
        let result = black_76_implied_vol(&OptionType::Call, 4700.0, 4700.0, 0.0, 0.05, 0.0);
        assert!(result.is_none(), "zero tau must yield None");
    }

    #[test]
    fn black_76_price_returns_intrinsic_at_or_past_expiry() {
        let call_zero = black_76_price(&OptionType::Call, 4700.0, 4500.0, 0.0, 0.05, 0.35);
        assert!(
            (call_zero - 200.0).abs() < 1e-9,
            "expired ITM call must equal intrinsic, got {call_zero}"
        );

        let call_neg = black_76_price(&OptionType::Call, 4700.0, 4500.0, -0.01, 0.05, 0.35);
        assert!(
            (call_neg - 200.0).abs() < 1e-9,
            "past-expiry ITM call must equal intrinsic, got {call_neg}"
        );

        let otm_call = black_76_price(&OptionType::Call, 4500.0, 4700.0, 0.0, 0.05, 0.35);
        assert!(
            otm_call.abs() < 1e-9,
            "expired OTM call must be zero, got {otm_call}"
        );

        let put_zero = black_76_price(&OptionType::Put, 4500.0, 4700.0, 0.0, 0.05, 0.35);
        assert!(
            (put_zero - 200.0).abs() < 1e-9,
            "expired ITM put must equal intrinsic, got {put_zero}"
        );
    }
}