Enum PricingError 

pub enum PricingError {
    MethodError {
        method: String,
        reason: String,
    },
    SimulationError {
        reason: String,
    },
    InvalidEngine {
        reason: String,
    },
    Greeks(GreeksError),
    Options(OptionsError),
    Position(PositionError),
    Decimal(DecimalError),
    ExpirationDate(ExpirationDateError),
    DeltaAdjustmentNotApplicable {
        strategy: &'static str,
    },
    BinomialNodeMissing {
        node: &'static str,
    },
    SqrtFailure {
        value: Decimal,
    },
    Positive(PositiveError),
    UnsupportedOptionType {
        option_type: String,
        method: String,
    },
    NonFinite {
        context: &'static str,
        value: f64,
    },
    InvalidParameter {
        parameter: &'static str,
        value: Decimal,
        reason: &'static str,
    },
}

Error type for option pricing operations.

This enum represents the various errors that can occur during option pricing, providing domain-specific error handling for different pricing scenarios.

Variants

MethodError

Error from a specific pricing method (e.g., Black-Scholes, Binomial).

Fields

method: String

Name of the pricing method that failed

reason: String

Detailed reason for the failure

SimulationError

Error during Monte Carlo simulation.

Fields

reason: String

Detailed reason for the simulation failure

InvalidEngine

Error due to invalid pricing engine configuration.

Fields

reason: String

Detailed reason for the invalid engine

Greeks(GreeksError)

Error from Greeks calculations.

Options(OptionsError)

Error from Options operations.

Position(PositionError)

Error from Position operations.

Decimal(DecimalError)

Error from Decimal operations.

ExpirationDate(ExpirationDateError)

Expiration-date conversion error surfaced during pricing.

DeltaAdjustmentNotApplicable

A delta adjustment was requested on a strategy that does not support it.

Fields

strategy: &'static str

Name of the strategy, e.g. "LongCall", "ShortPut".

BinomialNodeMissing

A required intermediate value on a binomial lattice or pricing kernel was missing (typically a node that should have been populated by an earlier induction step).

Fields

node: &'static str

Identifier of the missing node, e.g. "S_k", "b".

SqrtFailure

A square-root computation inside a pricing kernel failed (the operand was negative or not representable — e.g. a negative discriminant in a closed-form solver).

Fields

value: Decimal

The value for which the square root could not be computed.

Stored as Decimal so negative operands are representable.

Positive(PositiveError)

Error from Positive operations.

UnsupportedOptionType

Error for unsupported option types.

Fields

option_type: String

The option type that is not supported

method: String

The pricing method that does not support this option type

NonFinite

A pricing kernel produced a non-finite f64 value (NaN / ±∞) at an f64 → Decimal boundary.

Emitted wherever a Black-Scholes style closed-form, a numerical integrator, or a Monte-Carlo payoff computes an intermediate f64 that would otherwise be wrapped in Decimal::from_f64(..) and silently become Decimal::ZERO or saturate. context is a static call-site tag following the same convention as optionstratlib_core::error::DecimalError::Overflow (for example "pricing::bs::call::d1" or "pricing::monte_carlo::payoff::cast"), so the failing kernel is identifiable without a stack trace.

Fields

context: &'static str

Static tag identifying the kernel and step that produced the non-finite value.

value: f64

The offending f64 value (NaN, +∞, or -∞).

InvalidParameter

A model parameter passed to a pricing kernel lies outside its admissible domain, for example a regime volatility that is not strictly positive or a negative transition rate of the telegraph pricer.

Fields

parameter: &'static str

Name of the offending parameter (for example "sigma_plus").

value: Decimal

The rejected value.

reason: &'static str

Why the value is rejected.

Implementations

impl PricingError

pub fn method_error(method: &str, reason: &str) -> Self

Creates a new MethodError variant.

Arguments

• method - Name of the pricing method that failed
• reason - Detailed reason for the failure

pub fn simulation_error(reason: &str) -> Self

Creates a new SimulationError variant.

Arguments

• reason - Detailed reason for the simulation failure

pub fn invalid_engine(reason: &str) -> Self

Creates a new InvalidEngine variant.

Arguments

• reason - Detailed reason for the invalid engine

pub fn other(reason: &str) -> Self

Creates a typed MethodError with method = "pricing" as a lightweight replacement for the former OtherError catch-all. Prefer PricingError::method_error with a specific method name when known.

pub fn unsupported_option_type(option_type: &str, method: &str) -> Self

Creates a new UnsupportedOptionType variant.

Arguments

• option_type - The option type that is not supported
• method - The pricing method that does not support this option type

pub fn non_finite(context: &'static str, value: f64) -> Self

Creates a PricingError::NonFinite from a static call-site tag and the offending f64 value.

Intended to be used at f64 → Decimal boundaries inside pricing kernels, as a thin constructor paired with an if !value.is_finite() { .. } guard.

pub fn invalid_parameter( parameter: &'static str, value: Decimal, reason: &'static str, ) -> Self

Creates a PricingError::InvalidParameter naming the rejected parameter, its value and the domain it violates.

Trait Implementations

impl Debug for PricingError

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

Formats the value using the given formatter.

impl Display for PricingError

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

Formats the value using the given formatter.

impl Error for PricingError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<DecimalError> for PricingError

fn from(source: DecimalError) -> Self

Converts to this type from the input type.

impl From<ExpirationDateError> for PricingError

fn from(source: ExpirationDateError) -> Self

Converts to this type from the input type.

impl From<GreeksError> for PricingError

fn from(source: GreeksError) -> Self

Converts to this type from the input type.

impl From<OptionsError> for PricingError

fn from(source: OptionsError) -> Self

Converts to this type from the input type.

impl From<PositionError> for PricingError

fn from(source: PositionError) -> Self

Converts to this type from the input type.

impl From<PositiveError> for PricingError

fn from(source: PositiveError) -> Self

Converts to this type from the input type.

impl From<PricingError> for GreeksError

fn from(err: PricingError) -> Self

Converts to this type from the input type.

impl From<PricingError> for OptionsError

fn from(value: PricingError) -> Self

Converts to this type from the input type.