Struct EuropeanSwaption 

pub struct EuropeanSwaption {
    pub underlying: SwaptionUnderlying,
    pub expiry: NaiveDate,
    pub strike: f64,
    pub kind: SwaptionKind,
    pub engine: SwaptionEngine,
    pub settlement: SwaptionSettlement,
}

A European swaption.

Fields

underlying: SwaptionUnderlying

The forward-starting swap the option confers.

expiry: NaiveDate

The option’s expiry.

strike: f64

The fixed rate the option confers.

kind: SwaptionKind

Payer or receiver.

engine: SwaptionEngine

The model the option prices under.

settlement: SwaptionSettlement

How it settles on exercise; physical unless said otherwise.

Implementations

impl EuropeanSwaption

pub fn new( underlying: SwaptionUnderlying, expiry: NaiveDate, strike: f64, kind: SwaptionKind, ) -> Result<Self, SwaptionError>

A European swaption priced off the surface.

Errors

SwaptionError for an empty fixed leg, a non-finite strike, or an expiry on or after the underlying’s last fixed payment.

pub fn with_settlement(self, settlement: SwaptionSettlement) -> Self

This swaption settling as settlement says.

pub fn with_engine(self, engine: SwaptionEngine) -> Self

This swaption priced under engine.

pub fn is_payer(&self) -> bool

Whether the holder pays fixed on exercise.

impl EuropeanSwaption

pub fn npv_at_vol( &self, view: &PricingView<'_, f64>, vol: f64, ) -> Result<f64, PricingError>

The option’s passive value at a stated flat volatility under the resolved surface’s convention — Bachelier for a normal surface, Black-76 for a lognormal one — with the surface’s own vol replaced. Surface engine only: a Hull-White swaption states no flat vol.

Errors

As Priceable::npv, and UnsupportedForProduct under the Hull-White engine.

Trait Implementations

impl Clone for EuropeanSwaption

fn clone(&self) -> EuropeanSwaption

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EuropeanSwaption

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

Formats the value using the given formatter.

impl PartialEq for EuropeanSwaption

fn eq(&self, other: &EuropeanSwaption) -> 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<R: Scalar> Priceable<R> for EuropeanSwaption

fn npv(&self, view: &PricingView<'_, R>) -> Result<R, PricingError>

Under the surface engine, annuity · Black-or-Bachelier(F, K, σ, T) with the formula chosen by the surface’s convention and σ read at (T, tenor) in the mode, so vega per node flows. Under Hull-White, the Jamshidian kernel on the underlying’s fixed payments after expiry. An expired option is worth nothing.

fn par_rate(&self, view: &PricingView<'_, R>) -> Result<R, PricingError>

The underlying’s forward swap rate — the level the strike is measured against.

fn par_spread(&self, _view: &PricingView<'_, R>) -> Result<R, PricingError>

The par (breakeven) floating-leg spread. Zero for a product with no floating leg.

impl PricingRiskFactors for EuropeanSwaption

fn risk_factors(&self) -> Result<RiskFactors<'_>, PricingError>

Discounts on the underlying’s collateral and projects its index; the surface engine declares the currency’s swaption vols, the Hull-White engine the currency’s model parameters — each only what it will read.

impl Product for EuropeanSwaption

fn currency(&self) -> Currency

The currency the product pays in. An FX product values in its quote currency; a book converts.

fn contract_dates(&self) -> Vec<(&'static str, NaiveDate)>

The contract dates the product resolved to, as (name, date) pairs — exactly the dates its stated constructor takes, so a product built through a derived form can be read back and rebuilt through the stated one. Empty for a product with no stated form. No default: every product states which it is — see AnyInstrument::contract_dates.

fn legs(&self) -> Option<Vec<&Leg>>

The legs the product itself holds, in a declared order, or None for a product that holds none — see AnyInstrument::legs. No default: every product states which it is.

fn final_payment_date(&self) -> Option<NaiveDate>

The date of the product’s final payment, where a calibration rung can be built on it; None for a product no ladder is built from.

fn restruck_at_rate(&self, _rate: f64) -> Option<AnyInstrument>

This product re-struck at the par rate rate — the scalar a par calibration rung on it is quoted in — or None for a product that carries no such scalar. What a quote scenario moves a rung to.

fn restruck_at_spread(&self, _spread: f64) -> Option<AnyInstrument>

This product re-struck at the basis spread spread on its spread leg, or None for a product that quotes none.

impl StructuralPartialEq for EuropeanSwaption