Enum SigmaTerm 

pub enum SigmaTerm<R: Scalar> {
    Flat(R),
    Pieces {
        ends: Vec<f64>,
        values: Vec<R>,
    },
}

A Hull-White volatility: one flat value, or a piecewise-constant term.

Piece k covers (ends[k−1], ends[k]] in years from the valuation date (Act/365F, the metric the affine bond and the lattice share), with ends[−1] = 0; the last value extends flat beyond the last end. A flat volatility is kept as its own arm so the constant model’s formulas run unchanged — bit for bit — and resolving it allocates nothing.

Variants

Flat(R)

One volatility for all time.

Pieces

Strictly increasing positive interval ends, one value per interval.

Fields

ends: Vec<f64>

Interval ends in years, strictly increasing and positive.

values: Vec<R>

The volatility on each interval, non-negative.

Implementations

impl<R: Scalar> SigmaTerm<R>

pub fn pieces(ends: Vec<f64>, values: Vec<R>) -> Result<Self, CurveError>

A piecewise term over ends (years) with one value each.

Errors

CurveError::Malformed for no pieces, mismatched lengths, ends that are not finite, positive and strictly increasing, or a value that is not finite and non-negative.

pub fn value_at(&self, t: f64) -> R

The volatility in force at time t (years): the piece whose interval holds t, the last beyond the last end.

pub(crate) fn overlapping(&self, s: f64, t: f64) -> Vec<(f64, f64, R)>

The pieces overlapping [s, t], as (from, to, σ) with s ≤ from < to ≤ t — a flat term one piece spanning it all.

pub fn passive(&self) -> SigmaTerm<f64>

The derivative-free projection of the term.

impl SigmaTerm<f64>

pub fn lift<R: Scalar>(&self) -> SigmaTerm<R>

The term in mode R — a passive lift, carrying no derivatives.

Trait Implementations

impl<R: Clone + Scalar> Clone for SigmaTerm<R>

fn clone(&self) -> SigmaTerm<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Scalar> Debug for SigmaTerm<R>

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

Formats the value using the given formatter.

impl<R: PartialEq + Scalar> PartialEq for SigmaTerm<R>

fn eq(&self, other: &SigmaTerm<R>) -> 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: PartialEq + Scalar> StructuralPartialEq for SigmaTerm<R>