feat(greeks): add Black-76 Greeks (delta/gamma/vega/theta/rho) for #400 (#402)

Closed-form Greeks for the Black-76 (Black 1976) model, complementing the
pricing kernel landed in #398. Black-76 prices options on futures, forwards,
swaptions, caps/floors, and commodity futures — anywhere the underlying is a
forward price `F` with the cost of carry already baked in. The Greeks share
the same `e^(-rT)` discount factor across both legs and ignore
`dividend_yield` (since `F` is carry-adjusted).

Public surface (`src/greeks/black_76.rs`):
- `delta_b76`, `gamma_b76`, `vega_b76`, `theta_b76`, `rho_b76`
- `Black76Greeks` trait mirroring the `Black76` pricing trait — implementors
  provide `get_option(&self)` and inherit default delegations to the free
  functions above.

Units mirror the BSM module: vega per 1 % vol, theta per calendar day
(annual ÷ 365), rho per 1 % rate (annual ÷ 100). Quantity scales linearly;
`Side::Short` flips the delta sign only (consistent with `greeks::delta`).

Promoted `calculate_d_values_black_76` from `pub(crate)` to `pub` so external
crates and the new module can share the helper.

Formulas use the complete Hull (10th ed., Ch. 18) expressions. Note that the
issue's formula for theta and rho omitted the `r·F·e^(-rT)·N(d1)` and
F-leg discount terms; this implementation follows Hull rigorously and the
relationship `ρ = -T · price` is verified analytically and by test.

Tests (21, all passing):
- Delta range: call ∈ (0,1), put ∈ (-1,0)
- Identity `Δ_call − Δ_put = e^(-rT)` to 1e-9
- Gamma > 0, Vega > 0 across multiple strikes
- Gamma and Vega are call/put symmetric
- Theta < 0 for long ATM call/put (decay)
- `ρ = -T · price / 100` analytic identity
- BSM cross-check via `S = F·e^(-rT)`, `q = 0`:
  - `Δ_b76 = e^(-rT) · Δ_bsm` to 1e-9
  - `ν_b76 = ν_bsm` to 1e-9
  - `Γ_b76 = e^(-2rT) · Γ_bsm` to 1e-9
- Hull ATM-call reference (F=K=20, r=0.09, T≈1/3, σ=0.25) → Δ ≈ 0.5132
- Zero volatility → error
- American / Bermuda / exotic → `GreeksError::Pricing(UnsupportedOptionType)`
- Trait impl, side negation, quantity scaling

Example: `examples/examples_pricing/src/bin/black_76_greeks.rs` walks ATM /
ITM / OTM calls and puts on a 6-month CL futures contract, prints all
Greeks, demonstrates the call-minus-put identity and trait usage.

Closes #400.

Author: joaquinbejar

examples/examples_pricing/Cargo.toml

@@ -16,6 +16,10 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] }
 name = "black_76"
 path = "src/bin/black_76.rs"
 
+[[bin]]
+name = "black_76_greeks"
+path = "src/bin/black_76_greeks.rs"
+
 [[bin]]
 name = "garman_kohlhagen"
 path = "src/bin/garman_kohlhagen.rs"

examples/examples_pricing/src/bin/black_76_greeks.rs

@@ -0,0 +1,115 @@
+/******************************************************************************
+   Author: Joaquín Béjar García
+   Email: jb@taunais.com
+   Date: 2026-04-27
+******************************************************************************/
+
+//! Black-76 Greeks example — commodity futures scenario.
+//!
+//! Computes delta, gamma, vega, theta, and rho for ATM, ITM, and OTM calls and
+//! puts on a 6-month crude-oil futures contract. Prints the values together
+//! with the Hull-style sanity identity `Δ_call − Δ_put = e^(-rT)` and shows
+//! both free-function and trait-based usage.
+
+use optionstratlib::error::greeks::GreeksError;
+use optionstratlib::greeks::{Black76Greeks, delta_b76, gamma_b76, rho_b76, theta_b76, vega_b76};
+use optionstratlib::model::types::{OptionStyle, OptionType, Side};
+use optionstratlib::pricing::black_76;
+use optionstratlib::{ExpirationDate, Options};
+use positive::{Positive, pos_or_panic};
+use rust_decimal::{Decimal, MathematicalOps};
+use rust_decimal_macros::dec;
+use tracing::info;
+
+fn build_option(f: f64, k: f64, style: OptionStyle) -> Options {
+    Options::new(
+        OptionType::European,
+        Side::Long,
+        "CL".to_string(),
+        pos_or_panic!(k),
+        ExpirationDate::Days(pos_or_panic!(180.0)),
+        pos_or_panic!(0.30),
+        Positive::ONE,
+        pos_or_panic!(f),
+        dec!(0.045),
+        style,
+        pos_or_panic!(0.0),
+        None,
+    )
+}
+
+fn print_greeks(label: &str, opt: &Options) -> Result<(), Box<dyn std::error::Error>> {
+    let price = black_76(opt)?;
+    let delta = delta_b76(opt)?;
+    let gamma = gamma_b76(opt)?;
+    let vega = vega_b76(opt)?;
+    let theta = theta_b76(opt)?;
+    let rho = rho_b76(opt)?;
+    info!(
+        "{label:<6} F={F:>6} K={K:>6} | price={price:>9.4} Δ={delta:>8.4} Γ={gamma:>9.6} ν={vega:>8.4} Θ={theta:>9.4} ρ={rho:>9.4}",
+        label = label,
+        F = opt.underlying_price.to_dec(),
+        K = opt.strike_price.to_dec(),
+        price = price,
+        delta = delta,
+        gamma = gamma,
+        vega = vega,
+        theta = theta,
+        rho = rho,
+    );
+    Ok(())
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt()
+        .with_env_filter("info")
+        .without_time()
+        .init();
+
+    info!("=== Black-76 Greeks (6-month CL futures, σ=30%, r=4.5%) ===");
+    info!("");
+    info!("Calls");
+    print_greeks("OTM", &build_option(70.0, 80.0, OptionStyle::Call))?;
+    print_greeks("ATM", &build_option(75.0, 75.0, OptionStyle::Call))?;
+    print_greeks("ITM", &build_option(80.0, 70.0, OptionStyle::Call))?;
+    info!("");
+    info!("Puts");
+    print_greeks("ITM", &build_option(70.0, 80.0, OptionStyle::Put))?;
+    print_greeks("ATM", &build_option(75.0, 75.0, OptionStyle::Put))?;
+    print_greeks("OTM", &build_option(80.0, 70.0, OptionStyle::Put))?;
+
+    // ---- Identity: Δ_call − Δ_put = e^(-rT) at any strike --------------
+    info!("");
+    let call = build_option(75.0, 75.0, OptionStyle::Call);
+    let put = build_option(75.0, 75.0, OptionStyle::Put);
+    let dc = delta_b76(&call)?;
+    let dp = delta_b76(&put)?;
+    let years = call.expiration_date.get_years()?.to_dec();
+    let df = (-call.risk_free_rate * years).exp();
+    let diff = dc - dp;
+    info!(
+        "Identity check: Δ_call − Δ_put = {diff:.10}, e^(-rT) = {df:.10}, |err| = {err:.2e}",
+        diff = diff,
+        df = df,
+        err = (diff - df).abs(),
+    );
+
+    // ---- Trait usage ----------------------------------------------------
+    struct FutureContract(Options);
+    impl Black76Greeks for FutureContract {
+        fn get_option(&self) -> Result<&Options, GreeksError> {
+            Ok(&self.0)
+        }
+    }
+    let contract = FutureContract(build_option(75.0, 75.0, OptionStyle::Call));
+    info!("");
+    info!(
+        "Trait usage on wrapper type: Δ={delta} Γ={gamma}",
+        delta = contract.delta_b76()?,
+        gamma = contract.gamma_b76()?,
+    );
+
+    // Suppress unused-import warning on Decimal in case formatting changes.
+    let _: Decimal = df;
+    Ok(())
+}