Enum Accumulation 

#[non_exhaustive]
pub enum Accumulation {
    PerCoupon,
    CompoundedStrip {
        pays: NaiveDate,
    },
    AccruedRate {
        pays: NaiveDate,
        compounding: AccrualCompounding,
    },
}

How a leg’s coupons combine into what the leg is worth.

A leg is not always a sum. Almost every leg pays each coupon on its own date and is worth the total of those payments discounted to their own dates. A zero-coupon swap’s two sides are not: each accrues over the whole life and pays once, so summing their coupons gives a number close enough to the right one to be mistaken for it — on a five-year swap of ten million, close by about a pound. Which rule a leg follows therefore belongs to the leg, where one implementation can serve every reader, rather than to whichever pricer happens to know.

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.

PerCoupon

Each coupon pays on its own date, and the leg is worth their sum. Every leg but a zero-coupon swap’s two.

CompoundedStrip

A strip of rates compounding period by period into one payment at pays: N · (∏(1 + rᵢ·τᵢ) − 1).

A zero-coupon swap’s floating side. There is no telescoping to a discount-factor ratio here — the index windows do not tile the accruals — so this is genuinely a product over the strip.

Fields

pays: NaiveDate

The single date the accumulated amount is paid on.

AccruedRate

One rate accruing over its own period into one payment at pays: N · (growth − 1) under compounding.

A zero-coupon swap’s fixed side. Not CompoundedStrip over a single coupon: the rate is quoted as an annual one accruing over the whole life, so the growth is (1 + K)^τ where a strip of one would give 1 + K·τ. The two are different numbers and the market means this one.

Fields

pays: NaiveDate

The single date the accumulated amount is paid on.

compounding: AccrualCompounding

How the rate accrues over the period.

Implementations

impl Accumulation

pub fn code(&self) -> &'static str

The rule’s name, as the leg surface reports it.

impl Accumulation

pub fn pays(self) -> Option<NaiveDate>

The date a non-summing leg pays on, or None for a per-coupon leg.

Trait Implementations

impl Clone for Accumulation

fn clone(&self) -> Accumulation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Accumulation

impl Debug for Accumulation

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

Formats the value using the given formatter.

impl Default for Accumulation

fn default() -> Accumulation

Returns the “default value” for a type.

impl PartialEq for Accumulation

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