Schedules

This page lists everything you need to generate the dates a leg accrues between: the schedule call and every argument it takes, how stubs, stated dates, month ends and the termination are treated, and the cases where a generated grid disagrees with a term sheet.

Quick example

This generates two years of quarterly periods on New York's calendar under modified following, and prints each period's dates and length.

Rust

use chrono::{Datelike, NaiveDate};
use helixrs::{
    BusinessDayConvention, Calendar, Frequency, Period,
    RollConvention, Schedule, StubPeriodType, add_period, calendar,
};

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

fn tenor(spelling: &str) -> Period {
    spelling.parse().expect("a tenor spelling")
}

/// The generator with the arguments most regions leave at their defaults.
fn generate(
    effective: NaiveDate,
    termination: NaiveDate,
    frequency: Period,
    calendar: &dyn Calendar,
    convention: BusinessDayConvention,
    roll: RollConvention,
    stub: StubPeriodType,
    end_of_month: bool,
) -> Schedule {
    Schedule::generate(
        effective, termination, frequency, calendar, convention, roll, stub, end_of_month, None,
        None,
    )
    .expect("a termination after the effective date")
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let new_york = calendar("USNY").expect("a registered business centre");
    let ny = new_york.as_ref();
    let modfollowing = BusinessDayConvention::ModifiedFollowing;
    let no_roll = RollConvention::None;

    // Two years of quarterly periods. Every boundary is the termination date
    // stepped back a whole number of quarters, then rolled under modified
    // following.
    let effective = date(2026, 1, 15);
    let termination = date(2028, 1, 15);
    let quarterly = Frequency::Quarterly.to_period();
    let grid = generate(
        effective, termination, quarterly, ny, modfollowing, no_roll,
        StubPeriodType::ShortInitial, false,
    );
    // Two years of quarters is eight periods.
    let periods = grid.periods().len() as i32;
    println!("{} boundaries, {periods} periods", grid.dates.len());
    for (start, end) in grid.periods() {
        println!("  {start} to {end}  {:>3} days", (end - start).num_days());
    }

    Ok(())
}

Python

import datetime as dt

import helixio as hlx

dates = hlx.dates
BusinessDayConvention = dates.BusinessDayConvention
Frequency = dates.Frequency
NEW_YORK = hlx.Calendar("USNY")

def show(label: str, boundaries: list[dt.date]) -> None:
    print(f"{label:<14} " + " ".join(d.strftime("%y-%m-%d") for d in boundaries))

# Two years of quarterly periods. Every boundary is the termination date stepped
# back a whole number of quarters, then rolled under modified following.
EFFECTIVE = dt.date(2026, 1, 15)
TERMINATION = dt.date(2028, 1, 15)
grid = dates.schedule(
    EFFECTIVE, TERMINATION, Frequency.Quarterly, NEW_YORK, BusinessDayConvention.ModifiedFollowing
)
boundaries = grid.dates()
# Two years of quarters is eight periods.
periods = len(grid.periods())
print(f"{len(grid)} boundaries, {periods} periods")
for start, end in grid.periods():
    print(f"  {start} to {end}  {(end - start).days:>3} days")

9 boundaries, 8 periods
  2026-01-15 to 2026-04-15   90 days
  2026-04-15 to 2026-07-15   91 days
  2026-07-15 to 2026-10-15   92 days
  2026-10-15 to 2027-01-15   92 days
  2027-01-15 to 2027-04-15   90 days
  2027-04-15 to 2027-07-15   91 days
  2027-07-15 to 2027-10-15   92 days
  2027-10-15 to 2028-01-18   95 days

Every boundary is the termination stepped back a whole number of quarters, then rolled: two years of quarters is eight periods. Their lengths follow the calendar quarters (90 to 92 days), and the last runs to 95 because 15 January 2028 falls on a weekend and rolls to the 18th.

How it's priced

Boundaries are stepped from one anchor in whole multiples of the frequency: backwards from the termination for an initial stub, forwards from the effective date for a final one. With anchor $a$ and frequency $p$ , the unadjusted boundaries are

b_k = a + k\,p, \qquad k = 0, \pm 1, \pm 2, \dots,

in month arithmetic with clamping, and each is then adjusted on the calendar. Stepping from one anchor keeps the day of the month that repeated steps would lose. How term sheets state schedules is covered in how dates and conventions work.

API

Symbol	Meaning	Rust	Python
$b_k$	boundaries from one anchor, adjusted	`Schedule::generate`	`dates.schedule`
$a$ , $p$	the anchor and the frequency	the effective or termination date, and the frequency you pass	`effective` or `termination`, and `frequency`
stated stubs	first and last regular dates	`Schedule::generate_with_stubs`	`dates.schedule` with `first_regular_start`, `last_regular_end`
the result	boundaries and periods	`Schedule`	`dates.Schedule`

Argument	Type	Default	Meaning
`effective`	`date`	required	the first boundary, rolled like every other
`termination`	`date`	required	the last boundary, rolled by `terminal_business_day_convention`
`frequency`	`Frequency`, `Period` or `str`	required	the step, such as `"3M"` or `Frequency.Quarterly`
`calendar`	`Calendar`	required	the calendar each interior boundary is adjusted on
`business_day_convention`	`BusinessDayConvention` or `str`	`"ModFollowing"`	the roll for interior boundaries
`roll_convention`	`RollConvention` or `str`	`"None"`	snaps each boundary inside its month first, such as `"IMM"` or `"IMM20"`
`stub`	`str`	`"ShortInitial"`	`"ShortInitial"`, `"LongInitial"`, `"ShortFinal"` or `"LongFinal"`: where the remainder goes and whether it merges
`end_of_month`	`bool`	`False`	from a month-end seed, roll every interior boundary to its month's end
`terminal_business_day_convention`	`BusinessDayConvention`, `str` or `None`	`None`	a separate roll for the termination; `None` means the same as `business_day_convention`, and `"Unadjusted"` or `"None"` keep it as stated
`date_generation`	`str` or `None`	`None`	`"Cds"` for the CDS rule set, dated on the twentieth of IMM months
`first_regular_start`	`date` or `None`	`None`	states where the regular periods start; a front stub runs from `effective`
`last_regular_end`	`date` or `None`	`None`	states where the regular periods end; a back stub runs to `termination`

Defaults and limits

Every boundary is rolled, endpoints included. The termination takes terminal_business_day_convention when you pass one; "Unadjusted" keeps it as stated.
Boundaries are strictly ascending. Generated forwards, a boundary that rolls onto or past the termination merges into it, so the last period runs to the termination.
A long stub absorbs the short one, so it has one period fewer.
Month ends. With end_of_month=True and a seed on or after its month's last business day, each interior boundary moves to its calendar month's last day, then the convention adjusts it. Without the flag, the day of the month is kept and the grid can drift, for example to the 29th.
Stated dates are checked. first_regular_start or last_regular_end outside the term, or out of order, raises ValueError; neither combines with date_generation="Cds".
Templates generate forwards. A swap template's schedule runs forward from the effective date, the stub at the back. Template.with_date_generation("Backward") rolls back from the termination, the stub at the front.

!!! warning "Write a 27-month swap as 27M" A swap builder's with_maturity reads "2Y3M" as a forward tenor: three months starting in two years. A 27-month swap is spelled "27M".

More examples

Every case above in one program: stubs, stated stub dates, month ends, the merge at the end, an interior roll, payment lags, the terminal date, a CDS schedule, stated dates, a bond on month end, an irregular first coupon, and a template's generation direction. The example reads no shared data.