Day counts

This page lists everything you need to turn an accrual period into a year fraction: the twelve conventions, the three readings (two dates alone, a coupon in its schedule, or a stated calendar), their arguments, and the cases where two conventions or two readings part.

Quick example

This measures one period, 15 February to 31 August 2026, under all twelve conventions.

Rust

use chrono::{Duration, NaiveDate};
use helixrs::DayCountFraction;

fn date(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let start = date(2026, 2, 15);
    let end = date(2026, 8, 31);
    let actual_days = (end - start).num_days();

    // One period, twelve conventions. The convention and its code string name the
    // same convention, so either may be passed wherever a day count is taken.
    let members = [
        DayCountFraction::Act360,
        DayCountFraction::Act365Fixed,
        DayCountFraction::Nl365,
        DayCountFraction::Thirty360,
        DayCountFraction::Thirty360Us,
        DayCountFraction::ThirtyE360,
        DayCountFraction::ThirtyE360Isda,
        DayCountFraction::ActActIsda,
        DayCountFraction::ActActIcma,
        DayCountFraction::ActActAfb,
        DayCountFraction::Bus252,
        DayCountFraction::One,
    ];
    println!("{start} to {end}: {actual_days} actual days");
    println!("{:<14} year fraction", "code");
    for member in members {
        let fraction = member.year_fraction(start, end);
        println!("{:<14} {fraction:.10}", member.code());
    }

    // The two fixed-denominator counts are actual days over their denominator.

    Ok(())
}

Python

import datetime as dt

import helixio as hlx

DayCountFraction = hlx.dates.DayCountFraction
START = dt.date(2026, 2, 15)
END = dt.date(2026, 8, 31)
ACTUAL_DAYS = (END - START).days

# One period, twelve conventions. The typed member and its code string name the
# same convention, so either may be passed wherever a day count is taken.
members = [
    DayCountFraction.Act360,
    DayCountFraction.Act365Fixed,
    DayCountFraction.Nl365,
    DayCountFraction.Thirty360,
    DayCountFraction.Thirty360Us,
    DayCountFraction.ThirtyE360,
    DayCountFraction.ThirtyE360Isda,
    DayCountFraction.ActActIsda,
    DayCountFraction.ActActIcma,
    DayCountFraction.ActActAfb,
    DayCountFraction.Bus252,
    DayCountFraction.One,
]
print(f"{START} to {END}: {ACTUAL_DAYS} actual days")
print(f"{'code':<14} year fraction")
fractions = {}
for member in members:
    fraction = member.year_fraction(START, END)
    fractions[member.code()] = fraction
    print(f"{member.code():<14} {fraction:.10f}")

# The two fixed-denominator counts are actual days over their denominator.

2026-02-15 to 2026-08-31: 197 actual days
code           year fraction
ACT/360        0.5472222222
ACT/365.FIXED  0.5397260274
NL/365         0.5397260274
30/360         0.5444444444
30U/360        0.5444444444
30E/360        0.5416666667
30E/360.ISDA   0.5416666667
ACT/ACT.ISDA   0.5397260274
ACT/ACT.ICMA   0.5000000000
ACT/ACT.AFB    0.5397260274
BUS/252        0.5317460317
1/1            1.0000000000

The same period comes out a few days' interest apart from one convention to the next, which is why a coupon on the wrong convention is wrong.

How it's priced

With $D$ the actual days from $t_0$ to $t_1$ , the actual conventions are

\tau_{\text{ACT/360}} = \frac{D}{360}, \qquad \tau_{\text{ACT/365.FIXED}} = \frac{D}{365}.

ACT/ACT.ISDA splits the period at each year boundary and divides each part by its own year's length; NL/365 is ACT/365.FIXED without 29 February. The 30/360 family writes each date as $(y, m, d)$ with adjusted days $d_0', d_1'$ :

\tau = \frac{360\,(y_1 - y_0) + 30\,(m_1 - m_0) + (d_1' - d_0')}{360}.

A coupon $t_0, t_1)$ inside a regular period $[s_0, s_1)$ of a schedule paying $f$ times a year accrues, under ACT/ACT.ICMA,

\tau = \frac{t_1 - t_0}{f\,(s_1 - s_0)},

BUS/252 is $\tau = N_b / 252$ , with $N_b$ the business days in $[t_0, t_1)$ , and 1/1 is $\tau = 1$ for any period, so a zero-coupon period accrues its whole rate once. Which market uses which convention is covered in [how dates and conventions work.

API

Symbol	Meaning	Rust	Python
$\tau(t_0, t_1)$	the reading from two dates alone	`DayCountFraction::year_fraction`	`DayCountFraction.year_fraction`
$\tau$ with $[s_0, s_1)$ , $f$	the schedule-aware reading	`DayCountFraction::year_fraction_with_context` with a `PeriodContext`	`DayCountFraction.year_fraction_with_context`
$N_b / 252$	on a stated calendar	`DayCountFraction::year_fraction_with_calendar`	`DayCountFraction.year_fraction_with_calendar`
$D$ , $d_0'$ , $d_1'$ , $y$ , $m$	the dates' parts	the two dates you pass	the two dates you pass
a convention	one of twelve, by member or code	`DayCountFraction`, parsed from its code	`dates.DayCountFraction`

Argument	Type	Default	Meaning
`DayCountFraction(code)`	`str`	required	`"ACT/360"`, `"ACT/365.FIXED"`, `"NL/365"`, `"30/360"`, `"30U/360"`, `"30E/360"`, `"30E/360.ISDA"`, `"ACT/ACT.ISDA"`, `"ACT/ACT.ICMA"`, `"ACT/ACT.AFB"`, `"BUS/252"`, `"1/1"`; case is ignored
`year_fraction(start, end)`	`date`, `date`	required	the context-free reading
`year_fraction_with_context(start, end, period_end, frequency, schedule_end, ...)`	`date`, `date`, `date`, `Frequency` or `str`, `date`	required	the reading inside a schedule: the coupon's period end, the schedule's frequency and its last date
`year_fraction_with_context(..., end_of_month=)`	`bool`	`False`	whether the schedule rolls on month end, which turns on the 30U/360 February rule
`year_fraction_with_context(..., reference_days=)`	`int` or `None`	`None`	states the regular period's length in days instead of deriving it
`year_fraction_with_calendar(start, end, calendar)`	`date`, `date`, `Calendar`	required	BUS/252 counts this calendar; every other convention ignores it

Defaults and limits

Leap years. Across 29 February, ACT/ACT.ISDA divides each year's part by its own length, ACT/365.FIXED divides the whole by 365, and NL/365 doesn't count 29 February at all.
ACT/ACT.ICMA needs its schedule. A full regular period accrues exactly $1/f$ . From two dates alone, the convention takes the dates as their own reference period, so a short first coupon reads as a whole number of months, not its accrual. Use year_fraction_with_context.
The 30U/360 February rule applies only in a schedule that rolls on month end: the last day of February then counts as the 30th. From two dates alone, 30U/360 agrees with 30/360.
BUS/252 defaults to Brazil. With no calendar it counts BRBD, Brazil's national calendar; a city calendar such as BRSP can only make the count smaller. São Paulo closes on 24 and 31 December, so a period across the year end counts two fewer days there.
Codes are matched ignoring case, and a spelling that isn't a code is refused with the list of codes that are. ACT/365 is not ACT/365.FIXED.

!!! warning "A member is not equal to its string" DayCountFraction.Act360 != "ACT/360". Compare member.code() with the string, or parse the string first.

More examples

The three readings in one program: a leap year, the ICMA reference period of a short first coupon, 30U/360 and February, BUS/252 on two calendars, and naming a day count. The example reads no shared data.