Indices

This page lists everything you need to work with the rates floating coupons read: resolving an index from the registry, its conventions, building one the registry doesn't carry, dating a term fixing, projecting a rate, and the rule every product applies when it decides to read a print or project one.

Quick example

This resolves five registered indices, prints the conventions each carries, and shows that an overnight index refuses to invent a tenor.

Rust

use helixrs::{AnyIndex, DayCountFraction, index};

fn code_of(index: &AnyIndex) -> String {
    match index {
        AnyIndex::Overnight(i) => i.code(),
        AnyIndex::Ibor(i) => i.code(),
        AnyIndex::Price(i) => i.code(),
        other => other.name().to_owned(),
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A registry code resolves to an index carrying its conventions. Matching
    // ignores case; the code written back is the registered one.
    println!("{:<15} {:<10} {:<14} {:<16} {:>3}", "code", "kind", "day count", "fixing calendar", "lag");
    for spelling in ["usd-sofr", "EUR-ESTR", "GBP-SONIA", "EUR-EURIBOR-3M", "EUR-EURIBOR-6M"] {
        let index = index(spelling).expect("a registered index");
        let (day_count, calendar_name, lag) = match &index {
            AnyIndex::Overnight(i) => (i.day_count, i.fixing_calendar.name().to_owned(), i.publication_lag_days),
            AnyIndex::Ibor(i) => (i.day_count, i.fixing_calendar.name().to_owned(), i.fixing_lag_days),
            _ => unreachable!("rate indices only"),
        };
        println!(
            "{:<15} {:<10} {:<14} {calendar_name:<16} {lag:>3}",
            code_of(&index),
            index.kind(),
            day_count.code()
        );
    }

    // A term index has a tenor; an overnight index has no tenor field at all.
    let Some(AnyIndex::Ibor(euribor)) = index("EUR-EURIBOR-3M") else {
        panic!("a term index")
    };
    let refused = if matches!(index("USD-SOFR"), Some(AnyIndex::Overnight(_))) { "refused" } else { "" };
    println!("tenor of USD-SOFR: {refused}");

    Ok(())
}

Python

import helixio as hlx

# A registry code resolves to an index carrying its conventions. Matching
# ignores case; the code written back is the registered one.
print(f"{'code':<15} {'kind':<10} {'day count':<14} {'fixing calendar':<16} {'lag':>3}")
for spelling in ("usd-sofr", "EUR-ESTR", "GBP-SONIA", "EUR-EURIBOR-3M", "EUR-EURIBOR-6M"):
    index = hlx.Index(spelling)
    print(
        f"{index.code():<15} {index.kind():<10} {index.day_count():<14} "
        f"{index.fixing_calendar().name():<16} {index.fixing_lag_days():>3}"
    )

# A term index has a tenor; an overnight index refuses to invent one.
refused = ""
try:
    hlx.Index("USD-SOFR").tenor()
except ValueError:
    refused = "refused"
print(f"tenor of USD-SOFR: {refused}")

code            kind       day count      fixing calendar  lag
USD-SOFR        Overnight  ACT/360        USNY.SOFR          1
EUR-ESTR        Overnight  ACT/360        EUTA               1
GBP-SONIA       Overnight  ACT/365.FIXED  GBLO               0
EUR-EURIBOR-3M  Ibor       ACT/360        EUTA               2
EUR-EURIBOR-6M  Ibor       ACT/360        EUTA               2
tenor of USD-SOFR: refused

Matching ignores case, and the code written back is the registered one. Every registered index, with its code and conventions, is listed in the rates conventions catalog.

How it's priced

A term index of tenor $p$ applied to an accrual starting $s$ fixes at

t_f = s - L \text{ business days}, \qquad [v, e] = [s,\ \operatorname{adj}(s + p)],

with $L$ the index's fixing lag on its calendar and $e$ the value date advanced by the tenor under the index's convention and end-of-month rule. Off a discount curve $D$ , a term index projects simple interest over its own window on its own day count:

F(v, e) = \frac{1}{\tau(v, e)}\left(\frac{D(v)}{D(e)} - 1\right),

which is not the curve's continuously compounded forward over the same dates. When indices publish, and why a desk at a close holds every print before it, is covered in how dates and conventions work.

API

Symbol	Meaning	Rust	Python
index	resolved by code	`index(code)`	`Index`
$t_f$	the fixing date	`IborIndex::fixing_date`	`Index.fixing_date`
$s$ , $p$ , $L$	the accrual start, the tenor, the fixing lag	the date you pass, `IborIndex::tenor`, `IborIndex::fixing_lag_days`	the date you pass, `Index.tenor`, `Index.fixing_lag_days`
$v$ , $e$	the window's value date and end	`IborIndex::maturity_date`	`Index.maturity_date`
$\tau$	the index's day count	`IborIndex::day_count`	`Index.day_count`
$D$	the discount curve projected off	`DiscountCurve`	`curves.DiscountCurve`
$F(v, e)$	the projected rate	`AnyIndex::forecast`	`Index.forecast`
prints	what the index published	`FixingStore`, `MarketContext::with_fixings`	`MarketContext.with_fixings`, `MarketContext.fixings`
resets needed	every reset before the valuation date	`AnyInstrument::fixings_needed`	`Instrument.fixings_needed`

Argument	Type	Default	Meaning
`Index(code)`	`str`	required	a registry code or display name, such as `"USD-SOFR"` or `"EUR-EURIBOR-3M"`; case is ignored
`Index.codes()`	none	none	every registered index as `(kind, name, code)`
`Index.ibor(name, currency, tenor, day_count, fixing_calendar, fixing_lag_days, ...)`	`str`, `str`, `str`, day count, `Calendar`, `int`	required	a term index the registry doesn't carry
`Index.ibor(..., business_day_convention=, end_of_month=)`	convention or `None`, `bool`	`None`, `True`	the window's roll and end-of-month rule
`Index.overnight(name, currency, day_count, fixing_calendar, ...)`	`str`, `str`, day count, `Calendar`	required	an overnight index the registry doesn't carry
`Index.overnight(..., publication_lag_days=, business_day_convention=, end_of_month=)`	`int`, convention or `None`, `bool`	`0`, `None`, `False`	when a print is published, and the roll
`fixing_date(accrual_start)`	`date`	required	the term fixing for an accrual starting on that date
`maturity_date(value_date)`	`date`	required	the end of the index's window
`forecast(curve, value_date)`	`DiscountCurve`, `date`	required	the projected rate over the index's window

Defaults and limits

Building registers nothing. An index built with Index.ibor or Index.overnight is a value you pass around; its code still doesn't resolve, and an unknown code is refused with the list of registered ones.
Accessors a kind doesn't carry raise. An overnight index has no tenor and a price index has none either; asking raises ValueError naming the kind rather than returning None.
The fixing rule. For a valuation at $t$ , a reset on $t_f$ is read if $t_f < t$ and must have been published; read if $t_f = t$ and a print exists, projected otherwise; and projected if $t_f > t$ .
A print is known from the date the market learnt it. A print dated after the market's date isn't read until the market moves past it.
A typed code the registry doesn't carry is refused when it is published into a market.

!!! warning "A seasoned trade needs its past prints" Valuing a trade whose resets fell before the valuation date raises MissingMarketInputError, naming the first missing date. fixings_needed lists every reset the valuation will read.

More examples

Every case above in one program: the registry, a term index's window, your own index, a forecast, prints, and the fixing rule on a seasoned swap. The example reads its curve quotes and prints from the desk sheets.