Enum DayCount 

pub enum DayCount {
    Act360,
    Act365,
    Act365Fixed,
    Bd252,
    ActActISDA,
    ActActICMA,
    D30360Euro,
    Thirty360US,
    D30365,
}

Day count conventions used when computing time fractions between two dates.

Pass one of these values to algebra::day_count_fraction.

Examples

use findates::conventions::DayCount;

let dc = DayCount::Act365;
assert_eq!(dc.to_string(), "Act365");

let parsed: DayCount = "Act360".parse().unwrap();
assert_eq!(parsed, DayCount::Act360);

Variants

Act360

Actual days divided by 360.

QuantLib equivalent: Actual360

Act365

Actual days divided by 365.

QuantLib equivalent: Actual365Fixed (Standard variant)

Act365Fixed

Actual days divided by 365, always 365 regardless of leap year. The standard convention for GBP interest rate swaps, many money market instruments, and Asian markets.

Unlike Act365 which uses the actual year length, this convention always divides by exactly 365 even in a leap year.

QuantLib equivalent: Actual365Fixed

Bd252

Business days divided by 252 (Brazilian convention). Requires a Calendar.

QuantLib equivalent: Business252

ActActISDA

Actual/Actual ISDA: accounts for leap years by splitting the period at year boundaries.

QuantLib equivalent: ActualActual(ActualActual::ISDA)

ActActICMA

Actual/Actual ICMA (also known as Actual/Actual ISMA or Actual/Actual Bond): divides actual days by (frequency × actual days in the nominal coupon period). The standard convention for UK Gilts, German Bunds, and most Eurozone government bonds.

Unlike ActActISDA which splits at calendar year boundaries, this convention references the bond’s own coupon period and requires additional context (period boundaries and frequency) beyond just two dates. It cannot be used with algebra::day_count_fraction — doing so will return an error once the dedicated function is implemented in a follow-up change.

Currently supports regular coupon periods only. Irregular (stub) periods are not yet supported.

QuantLib equivalent: ActualActual(ActualActual::ISMA)

D30360Euro

30/360 European: if either date falls on the 31st of a month it is treated as the 30th. Year of 360 days.

QuantLib equivalent: Thirty360(Thirty360::European) / Thirty360(Thirty360::EurobondBasis)

Thirty360US

30/360 US: the standard for US corporate and municipal bonds. Also known as “30/360” or “360/360”.

Rules applied in order:

1. If the start date is the 31st, change it to the 30th.
2. If the start date is the last day of February, change it to the 30th.
3. If the end date is the 31st and the start date is the 30th or 31st, change the end date to the 30th.
4. If the end date is the last day of February and the start date is also the last day of February, change the end date to the 30th.

QuantLib equivalent: Thirty360(Thirty360::USA)

D30365

30/365: months of 30 days, year of 365 days.

QuantLib equivalent: no direct equivalent — closest is Thirty360 with custom year basis

Trait Implementations

impl Clone for DayCount

fn clone(&self) -> DayCount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DayCount

impl Debug for DayCount

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

Formats the value using the given formatter.

impl Display for DayCount

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

Formats the value using the given formatter.

impl Eq for DayCount

impl FromStr for DayCount

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a DayCount from its canonical string representation (case-sensitive).

Examples

use findates::conventions::DayCount;

assert_eq!("ActActISDA".parse::<DayCount>().unwrap(), DayCount::ActActISDA);
assert!("actactisda".parse::<DayCount>().is_err()); // case-sensitive

type Err = ParseDayCountError

The associated error which can be returned from parsing.

impl Hash for DayCount

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DayCount

fn eq(&self, other: &DayCount) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DayCount