Struct SolverConfig 

#[non_exhaustive]
pub struct SolverConfig {
    pub nr_max_iterations: u32,
    pub price_tolerance: f64,
    pub iv_tolerance: f64,
    pub vega_floor: f64,
    pub iv_min: f64,
    pub iv_max: f64,
    pub brent_max_iterations: u32,
    pub near_expiry_cutoff_hours: f64,
}

Configuration for the implied-volatility solver.

Construct via SolverConfig::default for sensible defaults, or via SolverConfig::builder for selective overrides:

use black_76::SolverConfig;

let cfg = SolverConfig::builder()
    .iv_min(0.001)
    .iv_max(10.0)
    .price_tolerance(1e-10)
    .build();
assert_eq!(cfg.iv_max, 10.0);

New fields may be added in future minor versions.

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.

nr_max_iterations: u32

Maximum Newton-Raphson iterations before switching to Brent.

price_tolerance: f64

Price residual reported by the solver, and the secondary price sanity threshold for the bracket-collapse path. Convergence itself is decided in volatility space (see iv_tolerance).

iv_tolerance: f64

Volatility-space convergence tolerance. The solver converges when the Newton step (or the Brent bracket width) in sigma falls below this value. Deciding convergence in sigma-space behaves the same whether the forward is 1.0 or 100_000.0, unlike an absolute price tolerance.

vega_floor: f64

Minimum vega to continue Newton-Raphson iterations. Below this, the solver falls back to Brent’s method to avoid the explosive Newton step (price - target) / vega as vega -> 0 (deep OTM, near expiry).

iv_min: f64

Minimum allowed IV (annualized). The solver clamps every NR step to [iv_min, iv_max]. Default 0.01 (1%).

iv_max: f64

Maximum allowed IV (annualized). Default 5.0 (500%).

brent_max_iterations: u32

Maximum Brent’s-method iterations.

near_expiry_cutoff_hours: f64

Near-expiry cutoff in hours. Below this, the solver bypasses NR/Brent and returns iv = NaN, converged = false, status = SolverStatus::NearExpiryIntrinsic; price the option intrinsically yourself rather than implying a volatility.

Implementations

impl SolverConfig

pub fn builder() -> SolverConfigBuilder

Returns a fresh builder seeded with the default config.

Trait Implementations

impl Clone for SolverConfig

fn clone(&self) -> SolverConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SolverConfig

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

Formats the value using the given formatter.

impl Default for SolverConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SolverConfig

where SolverConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SolverConfig

fn eq(&self, other: &SolverConfig) -> 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 SolverConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SolverConfig