Enum Survival 

#[non_exhaustive]
pub enum Survival {
    FlatHazard(FlatHazard),
    Isda(IsdaSurvival),
    Piecewise(PiecewiseSurvival),
    Shocked(ShockedSurvival),
    Scaled(ScaledSurvival),
    Density(DensitySurvival),
}

A stored credit term structure. Passive parameters, no AD state.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

FlatHazard(FlatHazard)

One hazard, all maturities.

Isda(IsdaSurvival)

Piecewise-flat segment hazards — the ISDA bootstrap’s output.

Piecewise(PiecewiseSurvival)

Dated log-survival pillars.

Shocked(ShockedSurvival)

A base under a named parallel hazard shock.

Scaled(ScaledSurvival)

A base under a term structure of hazard multipliers.

Density(DensitySurvival)

A piecewise-linear default density.

Implementations

impl Survival

pub fn view<R: Scalar>(&self) -> SurvivalView<'_, R>

This curve lifted into mode R.

Recursive for a family that reads other curves: lifting one lifts its parts, borrowing throughout. For the passive mode nothing is allocated for the parameters at any depth.

pub(crate) fn view_with_slice<'a, R: Scalar>( &'a self, rest: &mut &'a [R], ) -> SurvivalView<'a, R>

One step of a substituted walk: each member takes its own parameters off the front of rest, in parameter_owners order.

pub(crate) fn view_seeding<R: Scalar + Seedable>( &self, seed: &mut Option<usize>, ) -> SurvivalView<'_, R>

One step of a seeded walk: each member consumes the seed if it falls among its own parameters, and passes it on otherwise.

impl Survival

pub fn parameters(&self) -> &[f64]

See Family::parameters.

pub fn parts(&self) -> Vec<&Survival>

See Family::parts.

pub fn view_with<'a, R: Scalar>( &'a self, params: &'a [R], ) -> Result<SurvivalView<'a, R>, CurveError>

See Family::view_with.

Errors

As the trait method.

pub fn view_seeded<R: Scalar + Seedable>( &self, index: usize, ) -> Result<SurvivalView<'_, R>, CurveError>

See Family::view_seeded.

Errors

As the trait method.

pub fn parameter_count(&self) -> usize

See Family::parameter_count.

pub fn for_each_owner<'a>(&'a self, f: &mut dyn FnMut(&'a Survival))

See Family::for_each_owner.

pub fn parameter_owners(&self) -> Vec<&Survival>

See Family::parameter_owners.

pub fn parameter_labels(&self) -> Vec<ParameterLabel>

See Family::parameter_labels.

pub fn adjoint_refusal(&self) -> Option<&'static str>

See Family::adjoint_refusal.

impl Survival

pub fn pillar_dates(&self) -> &[NaiveDate]

The dates the hazard changes at — the pillars a CDS’s protection integral must break its intervals on so that each carries a flat hazard. Empty for a flat hazard.

pub fn day_count(&self) -> DayCountFraction

The day count this curve measures time under — for a shock, its base’s.

Trait Implementations

impl Clone for Survival

fn clone(&self) -> Survival

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Survival

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

Formats the value using the given formatter.

impl Family for Survival

fn parts(&self) -> Vec<&Survival>

A leaf reads none, and a shock’s shift is stated data rather than a curve.

fn own_refusal(&self) -> Option<&'static str>

Every credit family implemented so far is linear in its stored hazards or log-survivals, so this is None throughout. The method exists because a risk pass must ask, not assume: when a family arrives that cannot record exact adjoints, the read-back refuses here rather than each caller remembering to check.

fn parameters(&self) -> &[f64]

The free parameters this family owns directly.

fn own_labels(&self) -> Vec<ParameterLabel>

The labels for the parameters this family owns directly, in the order parameters reports them.

fn view_with<'a, R: Scalar>( &'a self, params: &'a [R], ) -> Result<Self::View<'a, R>, CurveError>

This family lifted into mode R over params, in place of its stored ones — the whole of what arming used to be.

fn view_seeded<R: Scalar + Seedable>( &self, index: usize, ) -> Result<Self::View<'_, R>, CurveError>

This family lifted into forward mode with parameter index carrying a unit tangent and every other a zero tangent.

fn parameter_count(&self) -> usize

Every free parameter reachable from this family, counted once.

fn for_each_owner<'a>(&'a self, f: &mut dyn FnMut(&'a Self))

Visits every parameter-owning family reachable from this one, in parameter_owners order, without collecting them. The lift flattens parameters through this so a market of leaves allocates one vector, not one per curve.

fn parameter_owners(&self) -> Vec<&Self>

Every parameter-owning family reachable from this one, depth first, including this one.

fn parameter_labels(&self) -> Vec<ParameterLabel>

What each free parameter reachable from this family is, in the same order view_with consumes them.

fn adjoint_refusal(&self) -> Option<&'static str>

Why this family cannot report correct parameter sensitivities, if it cannot.

impl From<Survival> for PinnedSurvival

fn from(curve: Survival) -> Self

Converts to this type from the input type.

impl Lift for Survival

type View<'a, R: Scalar> = SurvivalView<'a, R> where Self: 'a

This family lifted into mode R, borrowing the storage for 'a.

fn view<R: Scalar>(&self) -> SurvivalView<'_, R>

This family lifted into mode R.

fn view_with_slice<'a, R: Scalar>( &'a self, rest: &mut &'a [R], ) -> SurvivalView<'a, R>

One step of a substituted walk: this family takes its own parameters off the front of rest, then its parts take theirs, in parameter_owners order.

fn view_seeding<R: Scalar + Seedable>( &self, seed: &mut Option<usize>, ) -> SurvivalView<'_, R>

One step of a seeded walk: this family consumes the seed if it falls among its own parameters, and passes it on to its parts otherwise.

impl PartialEq for Survival

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