Struct BlackInputs 

#[non_exhaustive]
pub struct BlackInputs {
    pub f: f64,
    pub k: f64,
    pub t: f64,
    pub sigma: f64,
    pub r: f64,
}

Named inputs for Black-76 pricing and Greeks: forward f, strike k, time-to-expiry t (in years), volatility sigma, and rate r.

A typo-resistant alternative to the positional free functions: every field is named, so f/k and t/r cannot be silently swapped.

use black_76::{BlackInputs, call_price};
let inputs = BlackInputs::new(100.0, 100.0, 1.0, 0.20, 0.0);
let c = inputs.call_price();
assert!((c - call_price(100.0, 100.0, 1.0, 0.20, 0.0)).abs() < 1e-12);
let g = inputs.greeks(true);
assert!(g.delta > 0.0 && g.gamma > 0.0);

New fields may be added in future minor versions; construct via new (the type is #[non_exhaustive], so struct-literal construction is unavailable to downstream crates). The public fields remain readable and serde-serializable.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

f: f64

Forward / futures price.

k: f64

Strike.

t: f64

Time to expiry, in years.

sigma: f64

Volatility (annualized).

r: f64

Risk-free rate (annualized, continuously compounded).

Implementations

impl BlackInputs

pub const fn new(f: f64, k: f64, t: f64, sigma: f64, r: f64) -> Self

Construct inputs from forward, strike, time (years), volatility, rate.

pub fn d1_d2(&self) -> (f64, f64)

(d1, d2) for these inputs (independent of r).

pub fn call_price(&self) -> f64

Black-76 call price.

pub fn put_price(&self) -> f64

Black-76 put price.

pub fn price(&self, is_call: bool) -> f64

Call or put price, selected by is_call.

pub fn vega(&self) -> f64

Vega (price change per 1.0 absolute change in volatility).

pub fn greeks(&self, is_call: bool) -> InstrumentGreeks

First-order Greeks (delta, gamma, vega-per-1%, theta-per-day, rho-per-1%).

pub fn intrinsic_value(&self, is_call: bool) -> f64

Intrinsic value: max(F - K, 0) (call) or max(K - F, 0) (put).

Trait Implementations

impl Clone for BlackInputs

fn clone(&self) -> BlackInputs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlackInputs

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlackInputs

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BlackInputs

fn eq(&self, other: &BlackInputs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BlackInputs

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BlackInputs

impl StructuralPartialEq for BlackInputs