Struct EquityOption 

pub struct EquityOption {
    pub base: EquityOptionBase,
    pub payoff: Box<dyn Payoff>,
    pub engine: Engine,
    pub mc: MonteCarloConfig,
    pub fd: FdConfig,
    pub heston: Option<HestonParams>,
}

Fields

base: EquityOptionBase

payoff: Box<dyn Payoff>

engine: Engine

mc: MonteCarloConfig

Monte Carlo settings (paths, time steps, scheme, sampler, seed). mc.model (GBM vs local vol) also applies to the FD engine.

fd: FdConfig

Finite difference grid settings; only consulted when engine is Engine::FiniteDifference.

heston: Option<HestonParams>

Heston parameters; required when the model is Heston.

Implementations

impl EquityOption

pub fn time_to_maturity(&self) -> f64

impl EquityOption

pub fn from_json(data: &EquityOptionData) -> Box<EquityOption>

impl EquityOption

pub fn get_premium_at_risk(&self) -> f64

pub fn try_imp_vol(&self, option_price: f64) -> Result<f64, String>

Implied Black-Scholes volatility for option_price (safeguarded Newton with arbitrage-bound checks); does not modify the option.

pub fn imp_vol(&mut self, option_price: f64) -> f64

Implied vol for option_price; leaves the option holding a flat surface at the solved vol. Panics on arbitrage-violating prices — use try_imp_vol to handle those gracefully.

pub fn get_imp_vol(&mut self) -> f64

impl EquityOption

Greeks per engine: Monte Carlo uses bump-and-reprice with common random numbers (supporting American via Longstaff-Schwartz repricing); the FD engine reads delta/gamma/theta off its own grid (so American and barrier sensitivities are engine-consistent) with vega/rho by re-solving; the remaining engines use the analytic Black-Scholes closed forms.

pub fn delta(&self) -> f64

Examples found in repository

examples/common/mod.rs (line 50)

pub fn row(label: &str, option: &EquityOption) {
    // keep the table readable: the caught panic is reported in the row
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = catch_unwind(AssertUnwindSafe(|| {
        let (pv, std_err) = if option.engine == Engine::MonteCarlo {
            let s = montecarlo::npv_with_stats(option);
            (s.pv, Some(s.std_err))
        } else {
            (option.npv(), None)
        };
        (pv, option.delta(), option.gamma(), option.vega(), option.theta(), option.rho(), std_err)
    }));
    std::panic::set_hook(hook);
    match result {
        Ok((pv, delta, gamma, vega, theta, rho, std_err)) => {
            let se = match std_err {
                Some(v) => format!("{v:.5}"),
                None => "-".to_string(),
            };
            println!(
                "{label:<34} {pv:>12.6} {delta:>10.5} {gamma:>10.5} {vega:>9.3} {theta:>9.3} {rho:>9.3} {se:>9}"
            );
        }
        Err(payload) => {
            let msg = payload
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
                .unwrap_or_else(|| "panicked".to_string());
            let short: String = msg.split(';').next().unwrap_or(&msg).chars().take(52).collect();
            println!("{label:<34} {:>12}  ({short})", "unsupported");
        }
    }
}

examples/vanilla_option.rs (line 197)

fn greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};

    common::section("Greek surfaces over (moneyness, maturity) -> runs/vanilla_option/*.html");

    // x = moneyness S/K (0.4 .. 1.6, i.e. spot 40..160 for K=100);
    // y = maturity 0.05..2.0y (short-dated ATM is where the structure lives)
    let moneyness = linspace(0.6, 1.4, 72);
    let mats = linspace(0.05, 1.0, 56);

    // a call priced analytically at (moneyness, maturity); spot = m * K
    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = EquityOptionBuilder::new()
                .spot(m * STRIKE)
                .strike(STRIKE)
                .flat_vol(VOL)
                .flat_rate(RATE)
                .dividend_yield(DIV)
                .valuation_date(asof())
                .years_to_maturity(years)
                .vanilla(PutOrCall::Call)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
        ("Vega", "vega", |o: &EquityOption| o.vega()),
        ("Theta", "theta", |o: &EquityOption| o.theta()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/vanilla_option/{file}_surface.html"),
            &Labels {
                title: &format!("Vanilla call {name} (K=100, sigma=30%, r=5%, q=2%)"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("open the HTML in a browser to rotate, zoom and hover the surfaces");
}

examples/forward_start_option.rs (line 135)

fn main() {
    common::title("FORWARD-START OPTION — S=100, strike = 1.0 x S(0.5y), T=1y, sigma=30%");

    common::section("Black-Scholes: analytic vs Monte Carlo");
    common::table_header();
    common::row(
        "Analytical (Rubinstein)",
        &base()
            .forward_start(PutOrCall::Call, 1.0, START)
            .engine(Engine::BlackScholes)
            .build(),
    );
    common::row(
        "Monte Carlo (GBM)",
        &base()
            .forward_start(PutOrCall::Call, 1.0, START)
            .engine(Engine::MonteCarlo)
            .paths(100_000)
            .build(),
    );
    common::row(
        "Finite difference (unsupported)",
        &base()
            .forward_start(PutOrCall::Call, 1.0, START)
            .engine(Engine::FiniteDifference)
            .build(),
    );

    common::section("Forward smile: Heston vs Black-Scholes");
    common::table_header();
    let bs = base()
        .forward_start(PutOrCall::Call, 1.0, START)
        .engine(Engine::BlackScholes)
        .build()
        .npv();
    common::row(
        "Heston vol-of-vol=0.001 (-> BS)",
        &base()
            .forward_start(PutOrCall::Call, 1.0, START)
            .engine(Engine::MonteCarlo)
            .heston(heston_params(1e-3, 0.0))
            .paths(50_000)
            .build(),
    );
    for (vov, rho) in [(0.2, -0.7), (0.4, -0.7), (0.6, -0.7), (0.4, 0.0)] {
        common::row(
            &format!("Heston vol-of-vol={vov}, rho={rho}"),
            &base()
                .forward_start(PutOrCall::Call, 1.0, START)
                .engine(Engine::MonteCarlo)
                .heston(heston_params(vov, rho))
                .paths(50_000)
                .build(),
        );
    }
    common::note(&format!("Black-Scholes reference: {bs:.6}"));
    common::note("the gap is the forward-smile effect — the reason to price these on a stoch-vol model");

    common::section("Strike fraction sweep (analytic)");
    common::table_header();
    for k in [0.9, 0.95, 1.0, 1.05, 1.1] {
        common::row(
            &format!("strike = {k} x S(t_f), call"),
            &base().forward_start(PutOrCall::Call, k, START).engine(Engine::BlackScholes).build(),
        );
    }

    common::section("Fixing date sweep (analytic, ATM)");
    common::table_header();
    for start in [0.1, 0.25, 0.5, 0.75, 0.9] {
        common::row(
            &format!("fixing at {:.0}% of life", start * 100.0),
            &base().forward_start(PutOrCall::Call, 1.0, start).engine(Engine::BlackScholes).build(),
        );
    }
    common::note("later fixing leaves less time to expiry, so the option is worth less");

    common::section("Identities");
    common::check(
        "immediate fixing -> vanilla struck at S0",
        forward_start_price(SPOT, 1.0, RATE, DIV, VOL, 1e-6, 1.0, PutOrCall::Call),
        base()
            .strike(SPOT)
            .vanilla(PutOrCall::Call)
            .engine(Engine::BlackScholes)
            .build()
            .npv(),
        1e-3,
    );
    let p100 = forward_start_price(100.0, 1.0, RATE, DIV, VOL, 0.5, 1.0, PutOrCall::Call);
    let p200 = forward_start_price(200.0, 1.0, RATE, DIV, VOL, 0.5, 1.0, PutOrCall::Call);
    common::check("homogeneity: price(2S) = 2 price(S)", p200, 2.0 * p100, 1e-12);
    let fs = base()
        .forward_start(PutOrCall::Call, 1.0, START)
        .engine(Engine::BlackScholes)
        .build();
    common::check("delta = price / spot (homogeneity)", fs.delta(), fs.npv() / SPOT, 1e-6);
    println!();
}

examples/binary_option.rs (line 105)

fn main() {
    common::title("BINARY OPTION — S=100 K=100 sigma=30% r=5% q=2% T=1y");

    for (name, binary_type, cash) in [
        ("cash-or-nothing (1 unit)", BinaryType::CashOrNothing, CASH),
        ("asset-or-nothing", BinaryType::AssetOrNothing, 0.0),
    ] {
        for pc in [PutOrCall::Call, PutOrCall::Put] {
            common::section(&format!("{name} {pc:?}"));
            common::table_header();
            for (label, engine) in [
                ("Analytical (closed form)", Engine::BlackScholes),
                ("Binomial (1000 steps)", Engine::Binomial),
                ("Finite difference", Engine::FiniteDifference),
                ("Monte Carlo (Sobol, 100k)", Engine::MonteCarlo),
            ] {
                common::row(label, &base().binary(pc, binary_type, cash).engine(engine).build());
            }
        }
    }
    common::note("the tree oscillates on digitals: the strike falls between terminal nodes");

    common::section("Cash amount scales linearly");
    common::table_header();
    for cash in [1.0, 100.0, 1000.0] {
        common::row(
            &format!("cash-or-nothing call, cash={cash}"),
            &base()
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, cash)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    common::section("Identities");
    let cash_call = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    let cash_put = base()
        .binary(PutOrCall::Put, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "cash call + cash put = e^{-rT}",
        cash_call.npv() + cash_put.npv(),
        (-RATE * 1.0_f64).exp(),
        1e-12,
    );

    let asset_call = base()
        .binary(PutOrCall::Call, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    let asset_put = base()
        .binary(PutOrCall::Put, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "asset call + asset put = S e^{-qT}",
        asset_call.npv() + asset_put.npv(),
        SPOT * (-DIV * 1.0_f64).exp(),
        1e-10,
    );

    common::section("Replication: asset digital = vanilla call + K cash digitals");
    let vanilla = base().vanilla(PutOrCall::Call).engine(Engine::BlackScholes).build();
    let k_cash = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, STRIKE)
        .engine(Engine::BlackScholes)
        .build();
    common::check("npv", asset_call.npv(), vanilla.npv() + k_cash.npv(), 1e-10);
    common::check("delta", asset_call.delta(), vanilla.delta() + k_cash.delta(), 1e-10);
    common::check("gamma", asset_call.gamma(), vanilla.gamma() + k_cash.gamma(), 1e-10);
    common::check("vega", asset_call.vega(), vanilla.vega() + k_cash.vega(), 1e-10);
    common::check("theta", asset_call.theta(), vanilla.theta() + k_cash.theta(), 1e-10);
    common::check("rho", asset_call.rho(), vanilla.rho() + k_cash.rho(), 1e-10);
    common::note("both sides are implemented independently, so this is a real cross-check");

    common::section("Digital risk: delta and gamma explode near the strike at expiry");
    common::table_header();
    for years in [1.0, 0.25, 0.05, 0.01] {
        common::row(
            &format!("cash-or-nothing call, T={years}y"),
            &base()
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    digital_greek_surfaces();
    println!();
}

/// The digital's Greeks are the standout case for visualizing (lack of)
/// smoothness: as maturity shrinks the delta spikes into a tall bump at the
/// strike and gamma flips sign right across it. Saved as self-contained
/// interactive HTML to `runs/binary_option/`.
fn digital_greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};
    use rustyqlib::equity::vanila_option::EquityOption;

    common::section("Digital Greek surfaces over (moneyness, maturity) -> runs/binary_option/*.html");

    // tighter moneyness band and shorter maturities: that is where the
    // digital's delta/gamma structure lives
    let moneyness = linspace(0.8, 1.2, 80);
    let mats = linspace(0.02, 1.0, 60);

    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = base()
                .spot(m * STRIKE)
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/binary_option/{file}_surface.html"),
            &Labels {
                title: &format!("Cash digital call {name} (K=100) — note the near-expiry spike"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("contrast with the vanilla surfaces: the digital is far from smooth near the strike");
}

pub fn gamma(&self) -> f64

Examples found in repository

examples/common/mod.rs (line 50)

pub fn row(label: &str, option: &EquityOption) {
    // keep the table readable: the caught panic is reported in the row
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = catch_unwind(AssertUnwindSafe(|| {
        let (pv, std_err) = if option.engine == Engine::MonteCarlo {
            let s = montecarlo::npv_with_stats(option);
            (s.pv, Some(s.std_err))
        } else {
            (option.npv(), None)
        };
        (pv, option.delta(), option.gamma(), option.vega(), option.theta(), option.rho(), std_err)
    }));
    std::panic::set_hook(hook);
    match result {
        Ok((pv, delta, gamma, vega, theta, rho, std_err)) => {
            let se = match std_err {
                Some(v) => format!("{v:.5}"),
                None => "-".to_string(),
            };
            println!(
                "{label:<34} {pv:>12.6} {delta:>10.5} {gamma:>10.5} {vega:>9.3} {theta:>9.3} {rho:>9.3} {se:>9}"
            );
        }
        Err(payload) => {
            let msg = payload
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
                .unwrap_or_else(|| "panicked".to_string());
            let short: String = msg.split(';').next().unwrap_or(&msg).chars().take(52).collect();
            println!("{label:<34} {:>12}  ({short})", "unsupported");
        }
    }
}

examples/vanilla_option.rs (line 198)

fn greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};

    common::section("Greek surfaces over (moneyness, maturity) -> runs/vanilla_option/*.html");

    // x = moneyness S/K (0.4 .. 1.6, i.e. spot 40..160 for K=100);
    // y = maturity 0.05..2.0y (short-dated ATM is where the structure lives)
    let moneyness = linspace(0.6, 1.4, 72);
    let mats = linspace(0.05, 1.0, 56);

    // a call priced analytically at (moneyness, maturity); spot = m * K
    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = EquityOptionBuilder::new()
                .spot(m * STRIKE)
                .strike(STRIKE)
                .flat_vol(VOL)
                .flat_rate(RATE)
                .dividend_yield(DIV)
                .valuation_date(asof())
                .years_to_maturity(years)
                .vanilla(PutOrCall::Call)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
        ("Vega", "vega", |o: &EquityOption| o.vega()),
        ("Theta", "theta", |o: &EquityOption| o.theta()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/vanilla_option/{file}_surface.html"),
            &Labels {
                title: &format!("Vanilla call {name} (K=100, sigma=30%, r=5%, q=2%)"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("open the HTML in a browser to rotate, zoom and hover the surfaces");
}

examples/binary_option.rs (line 106)

fn main() {
    common::title("BINARY OPTION — S=100 K=100 sigma=30% r=5% q=2% T=1y");

    for (name, binary_type, cash) in [
        ("cash-or-nothing (1 unit)", BinaryType::CashOrNothing, CASH),
        ("asset-or-nothing", BinaryType::AssetOrNothing, 0.0),
    ] {
        for pc in [PutOrCall::Call, PutOrCall::Put] {
            common::section(&format!("{name} {pc:?}"));
            common::table_header();
            for (label, engine) in [
                ("Analytical (closed form)", Engine::BlackScholes),
                ("Binomial (1000 steps)", Engine::Binomial),
                ("Finite difference", Engine::FiniteDifference),
                ("Monte Carlo (Sobol, 100k)", Engine::MonteCarlo),
            ] {
                common::row(label, &base().binary(pc, binary_type, cash).engine(engine).build());
            }
        }
    }
    common::note("the tree oscillates on digitals: the strike falls between terminal nodes");

    common::section("Cash amount scales linearly");
    common::table_header();
    for cash in [1.0, 100.0, 1000.0] {
        common::row(
            &format!("cash-or-nothing call, cash={cash}"),
            &base()
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, cash)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    common::section("Identities");
    let cash_call = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    let cash_put = base()
        .binary(PutOrCall::Put, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "cash call + cash put = e^{-rT}",
        cash_call.npv() + cash_put.npv(),
        (-RATE * 1.0_f64).exp(),
        1e-12,
    );

    let asset_call = base()
        .binary(PutOrCall::Call, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    let asset_put = base()
        .binary(PutOrCall::Put, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "asset call + asset put = S e^{-qT}",
        asset_call.npv() + asset_put.npv(),
        SPOT * (-DIV * 1.0_f64).exp(),
        1e-10,
    );

    common::section("Replication: asset digital = vanilla call + K cash digitals");
    let vanilla = base().vanilla(PutOrCall::Call).engine(Engine::BlackScholes).build();
    let k_cash = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, STRIKE)
        .engine(Engine::BlackScholes)
        .build();
    common::check("npv", asset_call.npv(), vanilla.npv() + k_cash.npv(), 1e-10);
    common::check("delta", asset_call.delta(), vanilla.delta() + k_cash.delta(), 1e-10);
    common::check("gamma", asset_call.gamma(), vanilla.gamma() + k_cash.gamma(), 1e-10);
    common::check("vega", asset_call.vega(), vanilla.vega() + k_cash.vega(), 1e-10);
    common::check("theta", asset_call.theta(), vanilla.theta() + k_cash.theta(), 1e-10);
    common::check("rho", asset_call.rho(), vanilla.rho() + k_cash.rho(), 1e-10);
    common::note("both sides are implemented independently, so this is a real cross-check");

    common::section("Digital risk: delta and gamma explode near the strike at expiry");
    common::table_header();
    for years in [1.0, 0.25, 0.05, 0.01] {
        common::row(
            &format!("cash-or-nothing call, T={years}y"),
            &base()
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    digital_greek_surfaces();
    println!();
}

/// The digital's Greeks are the standout case for visualizing (lack of)
/// smoothness: as maturity shrinks the delta spikes into a tall bump at the
/// strike and gamma flips sign right across it. Saved as self-contained
/// interactive HTML to `runs/binary_option/`.
fn digital_greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};
    use rustyqlib::equity::vanila_option::EquityOption;

    common::section("Digital Greek surfaces over (moneyness, maturity) -> runs/binary_option/*.html");

    // tighter moneyness band and shorter maturities: that is where the
    // digital's delta/gamma structure lives
    let moneyness = linspace(0.8, 1.2, 80);
    let mats = linspace(0.02, 1.0, 60);

    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = base()
                .spot(m * STRIKE)
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/binary_option/{file}_surface.html"),
            &Labels {
                title: &format!("Cash digital call {name} (K=100) — note the near-expiry spike"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("contrast with the vanilla surfaces: the digital is far from smooth near the strike");
}

pub fn vega(&self) -> f64

Examples found in repository

examples/common/mod.rs (line 50)

pub fn row(label: &str, option: &EquityOption) {
    // keep the table readable: the caught panic is reported in the row
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = catch_unwind(AssertUnwindSafe(|| {
        let (pv, std_err) = if option.engine == Engine::MonteCarlo {
            let s = montecarlo::npv_with_stats(option);
            (s.pv, Some(s.std_err))
        } else {
            (option.npv(), None)
        };
        (pv, option.delta(), option.gamma(), option.vega(), option.theta(), option.rho(), std_err)
    }));
    std::panic::set_hook(hook);
    match result {
        Ok((pv, delta, gamma, vega, theta, rho, std_err)) => {
            let se = match std_err {
                Some(v) => format!("{v:.5}"),
                None => "-".to_string(),
            };
            println!(
                "{label:<34} {pv:>12.6} {delta:>10.5} {gamma:>10.5} {vega:>9.3} {theta:>9.3} {rho:>9.3} {se:>9}"
            );
        }
        Err(payload) => {
            let msg = payload
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
                .unwrap_or_else(|| "panicked".to_string());
            let short: String = msg.split(';').next().unwrap_or(&msg).chars().take(52).collect();
            println!("{label:<34} {:>12}  ({short})", "unsupported");
        }
    }
}

examples/vanilla_option.rs (line 199)

fn greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};

    common::section("Greek surfaces over (moneyness, maturity) -> runs/vanilla_option/*.html");

    // x = moneyness S/K (0.4 .. 1.6, i.e. spot 40..160 for K=100);
    // y = maturity 0.05..2.0y (short-dated ATM is where the structure lives)
    let moneyness = linspace(0.6, 1.4, 72);
    let mats = linspace(0.05, 1.0, 56);

    // a call priced analytically at (moneyness, maturity); spot = m * K
    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = EquityOptionBuilder::new()
                .spot(m * STRIKE)
                .strike(STRIKE)
                .flat_vol(VOL)
                .flat_rate(RATE)
                .dividend_yield(DIV)
                .valuation_date(asof())
                .years_to_maturity(years)
                .vanilla(PutOrCall::Call)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
        ("Vega", "vega", |o: &EquityOption| o.vega()),
        ("Theta", "theta", |o: &EquityOption| o.theta()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/vanilla_option/{file}_surface.html"),
            &Labels {
                title: &format!("Vanilla call {name} (K=100, sigma=30%, r=5%, q=2%)"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("open the HTML in a browser to rotate, zoom and hover the surfaces");
}

examples/binary_option.rs (line 107)

fn main() {
    common::title("BINARY OPTION — S=100 K=100 sigma=30% r=5% q=2% T=1y");

    for (name, binary_type, cash) in [
        ("cash-or-nothing (1 unit)", BinaryType::CashOrNothing, CASH),
        ("asset-or-nothing", BinaryType::AssetOrNothing, 0.0),
    ] {
        for pc in [PutOrCall::Call, PutOrCall::Put] {
            common::section(&format!("{name} {pc:?}"));
            common::table_header();
            for (label, engine) in [
                ("Analytical (closed form)", Engine::BlackScholes),
                ("Binomial (1000 steps)", Engine::Binomial),
                ("Finite difference", Engine::FiniteDifference),
                ("Monte Carlo (Sobol, 100k)", Engine::MonteCarlo),
            ] {
                common::row(label, &base().binary(pc, binary_type, cash).engine(engine).build());
            }
        }
    }
    common::note("the tree oscillates on digitals: the strike falls between terminal nodes");

    common::section("Cash amount scales linearly");
    common::table_header();
    for cash in [1.0, 100.0, 1000.0] {
        common::row(
            &format!("cash-or-nothing call, cash={cash}"),
            &base()
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, cash)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    common::section("Identities");
    let cash_call = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    let cash_put = base()
        .binary(PutOrCall::Put, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "cash call + cash put = e^{-rT}",
        cash_call.npv() + cash_put.npv(),
        (-RATE * 1.0_f64).exp(),
        1e-12,
    );

    let asset_call = base()
        .binary(PutOrCall::Call, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    let asset_put = base()
        .binary(PutOrCall::Put, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "asset call + asset put = S e^{-qT}",
        asset_call.npv() + asset_put.npv(),
        SPOT * (-DIV * 1.0_f64).exp(),
        1e-10,
    );

    common::section("Replication: asset digital = vanilla call + K cash digitals");
    let vanilla = base().vanilla(PutOrCall::Call).engine(Engine::BlackScholes).build();
    let k_cash = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, STRIKE)
        .engine(Engine::BlackScholes)
        .build();
    common::check("npv", asset_call.npv(), vanilla.npv() + k_cash.npv(), 1e-10);
    common::check("delta", asset_call.delta(), vanilla.delta() + k_cash.delta(), 1e-10);
    common::check("gamma", asset_call.gamma(), vanilla.gamma() + k_cash.gamma(), 1e-10);
    common::check("vega", asset_call.vega(), vanilla.vega() + k_cash.vega(), 1e-10);
    common::check("theta", asset_call.theta(), vanilla.theta() + k_cash.theta(), 1e-10);
    common::check("rho", asset_call.rho(), vanilla.rho() + k_cash.rho(), 1e-10);
    common::note("both sides are implemented independently, so this is a real cross-check");

    common::section("Digital risk: delta and gamma explode near the strike at expiry");
    common::table_header();
    for years in [1.0, 0.25, 0.05, 0.01] {
        common::row(
            &format!("cash-or-nothing call, T={years}y"),
            &base()
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    digital_greek_surfaces();
    println!();
}

pub fn theta(&self) -> f64

Examples found in repository

examples/common/mod.rs (line 50)

pub fn row(label: &str, option: &EquityOption) {
    // keep the table readable: the caught panic is reported in the row
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = catch_unwind(AssertUnwindSafe(|| {
        let (pv, std_err) = if option.engine == Engine::MonteCarlo {
            let s = montecarlo::npv_with_stats(option);
            (s.pv, Some(s.std_err))
        } else {
            (option.npv(), None)
        };
        (pv, option.delta(), option.gamma(), option.vega(), option.theta(), option.rho(), std_err)
    }));
    std::panic::set_hook(hook);
    match result {
        Ok((pv, delta, gamma, vega, theta, rho, std_err)) => {
            let se = match std_err {
                Some(v) => format!("{v:.5}"),
                None => "-".to_string(),
            };
            println!(
                "{label:<34} {pv:>12.6} {delta:>10.5} {gamma:>10.5} {vega:>9.3} {theta:>9.3} {rho:>9.3} {se:>9}"
            );
        }
        Err(payload) => {
            let msg = payload
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
                .unwrap_or_else(|| "panicked".to_string());
            let short: String = msg.split(';').next().unwrap_or(&msg).chars().take(52).collect();
            println!("{label:<34} {:>12}  ({short})", "unsupported");
        }
    }
}

examples/vanilla_option.rs (line 200)

fn greek_surfaces() {
    use common::plot3d::{greek_surface, linspace, save_surface_html, Labels};

    common::section("Greek surfaces over (moneyness, maturity) -> runs/vanilla_option/*.html");

    // x = moneyness S/K (0.4 .. 1.6, i.e. spot 40..160 for K=100);
    // y = maturity 0.05..2.0y (short-dated ATM is where the structure lives)
    let moneyness = linspace(0.6, 1.4, 72);
    let mats = linspace(0.05, 1.0, 56);

    // a call priced analytically at (moneyness, maturity); spot = m * K
    let greek = |select: fn(&EquityOption) -> f64| {
        move |m: f64, years: f64| -> f64 {
            let option = EquityOptionBuilder::new()
                .spot(m * STRIKE)
                .strike(STRIKE)
                .flat_vol(VOL)
                .flat_rate(RATE)
                .dividend_yield(DIV)
                .valuation_date(asof())
                .years_to_maturity(years)
                .vanilla(PutOrCall::Call)
                .engine(Engine::BlackScholes)
                .build();
            select(&option)
        }
    };

    for (name, file, select) in [
        ("Delta", "delta", (|o: &EquityOption| o.delta()) as fn(&EquityOption) -> f64),
        ("Gamma", "gamma", |o: &EquityOption| o.gamma()),
        ("Vega", "vega", |o: &EquityOption| o.vega()),
        ("Theta", "theta", |o: &EquityOption| o.theta()),
    ] {
        let surface = greek_surface(&moneyness, &mats, greek(select));
        save_surface_html(
            &surface,
            &format!("runs/vanilla_option/{file}_surface.html"),
            &Labels {
                title: &format!("Vanilla call {name} (K=100, sigma=30%, r=5%, q=2%)"),
                x: "moneyness (S/K)",
                y: "maturity (y)",
                z: name,
            },
        );
    }
    common::note("open the HTML in a browser to rotate, zoom and hover the surfaces");
}

examples/binary_option.rs (line 108)

fn main() {
    common::title("BINARY OPTION — S=100 K=100 sigma=30% r=5% q=2% T=1y");

    for (name, binary_type, cash) in [
        ("cash-or-nothing (1 unit)", BinaryType::CashOrNothing, CASH),
        ("asset-or-nothing", BinaryType::AssetOrNothing, 0.0),
    ] {
        for pc in [PutOrCall::Call, PutOrCall::Put] {
            common::section(&format!("{name} {pc:?}"));
            common::table_header();
            for (label, engine) in [
                ("Analytical (closed form)", Engine::BlackScholes),
                ("Binomial (1000 steps)", Engine::Binomial),
                ("Finite difference", Engine::FiniteDifference),
                ("Monte Carlo (Sobol, 100k)", Engine::MonteCarlo),
            ] {
                common::row(label, &base().binary(pc, binary_type, cash).engine(engine).build());
            }
        }
    }
    common::note("the tree oscillates on digitals: the strike falls between terminal nodes");

    common::section("Cash amount scales linearly");
    common::table_header();
    for cash in [1.0, 100.0, 1000.0] {
        common::row(
            &format!("cash-or-nothing call, cash={cash}"),
            &base()
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, cash)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    common::section("Identities");
    let cash_call = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    let cash_put = base()
        .binary(PutOrCall::Put, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "cash call + cash put = e^{-rT}",
        cash_call.npv() + cash_put.npv(),
        (-RATE * 1.0_f64).exp(),
        1e-12,
    );

    let asset_call = base()
        .binary(PutOrCall::Call, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    let asset_put = base()
        .binary(PutOrCall::Put, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "asset call + asset put = S e^{-qT}",
        asset_call.npv() + asset_put.npv(),
        SPOT * (-DIV * 1.0_f64).exp(),
        1e-10,
    );

    common::section("Replication: asset digital = vanilla call + K cash digitals");
    let vanilla = base().vanilla(PutOrCall::Call).engine(Engine::BlackScholes).build();
    let k_cash = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, STRIKE)
        .engine(Engine::BlackScholes)
        .build();
    common::check("npv", asset_call.npv(), vanilla.npv() + k_cash.npv(), 1e-10);
    common::check("delta", asset_call.delta(), vanilla.delta() + k_cash.delta(), 1e-10);
    common::check("gamma", asset_call.gamma(), vanilla.gamma() + k_cash.gamma(), 1e-10);
    common::check("vega", asset_call.vega(), vanilla.vega() + k_cash.vega(), 1e-10);
    common::check("theta", asset_call.theta(), vanilla.theta() + k_cash.theta(), 1e-10);
    common::check("rho", asset_call.rho(), vanilla.rho() + k_cash.rho(), 1e-10);
    common::note("both sides are implemented independently, so this is a real cross-check");

    common::section("Digital risk: delta and gamma explode near the strike at expiry");
    common::table_header();
    for years in [1.0, 0.25, 0.05, 0.01] {
        common::row(
            &format!("cash-or-nothing call, T={years}y"),
            &base()
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    digital_greek_surfaces();
    println!();
}

pub fn rho(&self) -> f64

Examples found in repository

examples/common/mod.rs (line 50)

pub fn row(label: &str, option: &EquityOption) {
    // keep the table readable: the caught panic is reported in the row
    let hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(|_| {}));
    let result = catch_unwind(AssertUnwindSafe(|| {
        let (pv, std_err) = if option.engine == Engine::MonteCarlo {
            let s = montecarlo::npv_with_stats(option);
            (s.pv, Some(s.std_err))
        } else {
            (option.npv(), None)
        };
        (pv, option.delta(), option.gamma(), option.vega(), option.theta(), option.rho(), std_err)
    }));
    std::panic::set_hook(hook);
    match result {
        Ok((pv, delta, gamma, vega, theta, rho, std_err)) => {
            let se = match std_err {
                Some(v) => format!("{v:.5}"),
                None => "-".to_string(),
            };
            println!(
                "{label:<34} {pv:>12.6} {delta:>10.5} {gamma:>10.5} {vega:>9.3} {theta:>9.3} {rho:>9.3} {se:>9}"
            );
        }
        Err(payload) => {
            let msg = payload
                .downcast_ref::<String>()
                .cloned()
                .or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string()))
                .unwrap_or_else(|| "panicked".to_string());
            let short: String = msg.split(';').next().unwrap_or(&msg).chars().take(52).collect();
            println!("{label:<34} {:>12}  ({short})", "unsupported");
        }
    }
}

examples/futures_option.rs (line 72)

fn main() {
    common::title("OPTIONS ON FUTURES (Black-76) — F=100 K=100 sigma=30% r=5% T=1y");

    for (name, settlement) in [
        ("Discounted (standard Black-76)", FuturesSettlement::Discounted),
        ("Margined (futures-style)", FuturesSettlement::Margined),
    ] {
        common::section(name);
        common::table_header();
        common::row("call", &futures_option(PutOrCall::Call, settlement));
        common::row("put", &futures_option(PutOrCall::Put, settlement));
    }
    common::note("margined has zero rho (no discounting) and a larger vega/theta");

    common::section("Settlement effect: margined = discounted / e^{-rT}");
    let disc = futures_option(PutOrCall::Call, FuturesSettlement::Discounted).npv();
    let marg = futures_option(PutOrCall::Call, FuturesSettlement::Margined).npv();
    println!("  discounted call {disc:.6}   margined call {marg:.6}   ratio {:.6} (= e^rT {:.6})",
        marg / disc, (R * T).exp());

    common::section("Identities");
    let dc = futures_option(PutOrCall::Call, FuturesSettlement::Discounted);
    let dp = futures_option(PutOrCall::Put, FuturesSettlement::Discounted);
    common::check(
        "discounted parity C - P = e^{-rT}(F - K)",
        dc.npv() - dp.npv(),
        (-R * T).exp() * (F - K),
        1e-10,
    );
    let mc = futures_option(PutOrCall::Call, FuturesSettlement::Margined);
    let mp = futures_option(PutOrCall::Put, FuturesSettlement::Margined);
    common::check("margined parity C - P = F - K", mc.npv() - mp.npv(), F - K, 1e-10);
    common::check(
        "margined rho is exactly zero",
        futures_option(PutOrCall::Call, FuturesSettlement::Margined).rho(),
        0.0,
        1e-15,
    );

    common::section("Black-76 on the forward reproduces spot Black-Scholes");
    // an option on F = S e^{(r-q)T} equals the equivalent spot option
    let (s, q) = (100.0, 0.02);
    let fwd = s * ((R - q) * T).exp();
    let on_forward = price(fwd, K, R, VOL, T, PutOrCall::Call, FuturesSettlement::Discounted);
    let spot_bsm = bs_price(s, K, R, q, VOL, T, PutOrCall::Call);
    common::check("black76(F = S e^{(r-q)T}) = BSM(S, q)", on_forward, spot_bsm, 1e-10);

    common::section("Skew across strikes (discounted put)");
    common::table_header();
    for k in [80.0, 90.0, 100.0, 110.0, 120.0] {
        common::row(
            &format!("K = {k}"),
            &EquityOptionBuilder::new()
                .spot(F)
                .strike(k)
                .flat_vol(VOL)
                .flat_rate(R)
                .valuation_date(NaiveDate::from_ymd_opt(2026, 1, 1).unwrap())
                .maturity_date(NaiveDate::from_ymd_opt(2027, 1, 1).unwrap())
                .vanilla(PutOrCall::Put)
                .on_future(FuturesSettlement::Discounted)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }
    println!();
}

examples/binary_option.rs (line 109)

fn main() {
    common::title("BINARY OPTION — S=100 K=100 sigma=30% r=5% q=2% T=1y");

    for (name, binary_type, cash) in [
        ("cash-or-nothing (1 unit)", BinaryType::CashOrNothing, CASH),
        ("asset-or-nothing", BinaryType::AssetOrNothing, 0.0),
    ] {
        for pc in [PutOrCall::Call, PutOrCall::Put] {
            common::section(&format!("{name} {pc:?}"));
            common::table_header();
            for (label, engine) in [
                ("Analytical (closed form)", Engine::BlackScholes),
                ("Binomial (1000 steps)", Engine::Binomial),
                ("Finite difference", Engine::FiniteDifference),
                ("Monte Carlo (Sobol, 100k)", Engine::MonteCarlo),
            ] {
                common::row(label, &base().binary(pc, binary_type, cash).engine(engine).build());
            }
        }
    }
    common::note("the tree oscillates on digitals: the strike falls between terminal nodes");

    common::section("Cash amount scales linearly");
    common::table_header();
    for cash in [1.0, 100.0, 1000.0] {
        common::row(
            &format!("cash-or-nothing call, cash={cash}"),
            &base()
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, cash)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    common::section("Identities");
    let cash_call = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    let cash_put = base()
        .binary(PutOrCall::Put, BinaryType::CashOrNothing, CASH)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "cash call + cash put = e^{-rT}",
        cash_call.npv() + cash_put.npv(),
        (-RATE * 1.0_f64).exp(),
        1e-12,
    );

    let asset_call = base()
        .binary(PutOrCall::Call, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    let asset_put = base()
        .binary(PutOrCall::Put, BinaryType::AssetOrNothing, 0.0)
        .engine(Engine::BlackScholes)
        .build();
    common::check(
        "asset call + asset put = S e^{-qT}",
        asset_call.npv() + asset_put.npv(),
        SPOT * (-DIV * 1.0_f64).exp(),
        1e-10,
    );

    common::section("Replication: asset digital = vanilla call + K cash digitals");
    let vanilla = base().vanilla(PutOrCall::Call).engine(Engine::BlackScholes).build();
    let k_cash = base()
        .binary(PutOrCall::Call, BinaryType::CashOrNothing, STRIKE)
        .engine(Engine::BlackScholes)
        .build();
    common::check("npv", asset_call.npv(), vanilla.npv() + k_cash.npv(), 1e-10);
    common::check("delta", asset_call.delta(), vanilla.delta() + k_cash.delta(), 1e-10);
    common::check("gamma", asset_call.gamma(), vanilla.gamma() + k_cash.gamma(), 1e-10);
    common::check("vega", asset_call.vega(), vanilla.vega() + k_cash.vega(), 1e-10);
    common::check("theta", asset_call.theta(), vanilla.theta() + k_cash.theta(), 1e-10);
    common::check("rho", asset_call.rho(), vanilla.rho() + k_cash.rho(), 1e-10);
    common::note("both sides are implemented independently, so this is a real cross-check");

    common::section("Digital risk: delta and gamma explode near the strike at expiry");
    common::table_header();
    for years in [1.0, 0.25, 0.05, 0.01] {
        common::row(
            &format!("cash-or-nothing call, T={years}y"),
            &base()
                .years_to_maturity(years)
                .binary(PutOrCall::Call, BinaryType::CashOrNothing, CASH)
                .engine(Engine::BlackScholes)
                .build(),
        );
    }

    digital_greek_surfaces();
    println!();
}

Trait Implementations

impl Debug for EquityOption

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Instrument for EquityOption

fn npv(&self) -> f64