Enum Frequency

pub enum Frequency {
    BusDays {
        number: i32,
        calendar: Calendar,
    },
    CalDays {
        number: i32,
    },
    Months {
        number: i32,
        roll: Option<RollDay>,
    },
    Zero {},
}

A frequency for generating unadjusted scheduling periods.

Variants

BusDays

A set number of business days, defined by a Calendar, which can only align with a business day as defined by that Calendar.

Fields

number: i32

calendar: Calendar

CalDays

A set number of calendar days, which can align with any unadjusted date. To achieve a Weeks variant use an appropriate number of days.

Fields

number: i32

Months

A set number of calendar months, with a potential RollDay. To achieve a Years variant use an appropriate number of months.

Fields

number: i32

roll: Option<RollDay>

Zero

Only ever defining one single period, and which can align with any unadjusted date.

Implementations

impl Frequency

pub fn try_vec_from( &self, udates: &Vec<NaiveDateTime>, ) -> Result<Vec<Frequency>, PyErr>

Get a vector of possible, fully specified Frequency variants for a series of unadjusted dates.

Notes

This method exists primarily to resolve cases when the RollDay on a Frequency::Months variant is None, and there are multiple possibilities. In this case the method RollDay::vec_from is called internally.

If the Frequency variant does not align with any of the provided unadjusted dates this will return an error.

Examples

// The RollDay is unspecified here
let f = Frequency::Months{number: 3, roll: None};
let result = f.try_vec_from(&vec![ndt(2024, 2, 29)]);
assert_eq!(result.unwrap(), vec![
    Frequency::Months{number: 3, roll: Some(RollDay::Day(29))},
    Frequency::Months{number: 3, roll: Some(RollDay::Day(30))},
    Frequency::Months{number: 3, roll: Some(RollDay::Day(31))},
]);

Trait Implementations

impl Clone for Frequency

fn clone(&self) -> Frequency

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Frequency

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Frequency

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'py> IntoPyObject<'py> for Frequency

type Target = Frequency

The Python output type

type Output = Bound<'py, <Frequency as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for Frequency

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

type Frozen = True

Whether the pyclass is frozen.

impl PyClassBaseType for Frequency

type LayoutAsBase = PyClassObject<Frequency>

type BaseNativeType = <Frequency as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<Frequency>

type PyClassMutability = <Frequency as PyClassImpl>::PyClassMutability

impl PyClassImpl for Frequency

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Frequency>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<Frequency> for PyClassImplCollector<Frequency>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a Frequency

type Holder = Option<PyRef<'py, Frequency>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<Frequency> for PyClassImplCollector<Frequency>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Frequency

const NAME: &'static str = "Frequency"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Scheduling for Frequency

fn try_udate(&self, udate: &NaiveDateTime) -> Result<NaiveDateTime, PyErr>

Validate if an unadjusted date aligns with the specified Frequency variant.

Notes

This method will return error in one of two cases:

• The udate does not align with the fully defined variant.
• The variant is not fully defined (e.g. a Months variant is missing a RollDay) and cannot make the determination.

Therefore,

• For a CalDays variant or Zero variant, any udate is valid.
• For a BusDays variant, udate must be a business day.
• For a Months variant, udate must align with the RollDay. If no RollDay is specified an error will always be returned.

Examples

let result = Frequency::Months{number: 1, roll: Some(RollDay::IMM{})}.try_udate(&ndt(2025, 7, 16));
assert!(result.is_ok());

let result = Frequency::Months{number: 1, roll: None}.try_udate(&ndt(2025, 7, 16));
assert!(result.is_err());

fn next(&self, date: &NaiveDateTime) -> NaiveDateTime

Calculate the next unadjusted scheduling period date from a given date.

fn previous(&self, date: &NaiveDateTime) -> NaiveDateTime

Calculate the previous unadjusted scheduling period date from a given date.

fn try_uregular( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> Result<Vec<NaiveDateTime>, PyErr>

Return a vector of unadjusted regular scheduling dates if it exists.

fn try_unext(&self, udate: &NaiveDateTime) -> Result<NaiveDateTime, PyErr>

Calculate the next unadjusted scheduling period date from an unadjusted base date.

fn try_uprevious(&self, udate: &NaiveDateTime) -> Result<NaiveDateTime, PyErr>

Calculate the previous unadjusted scheduling period date from an unadjusted base date.

fn try_uregular_from_unext( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> Result<Vec<NaiveDateTime>, PyErr>

Return a vector of unadjusted regular scheduling dates if it exists.

fn is_regular_period( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define a regular period under a scheduling object.

fn is_short_front_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define a short front stub period under a scheduling object.

fn is_long_front_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define a long front stub period under a scheduling object.

fn is_short_back_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define a short back stub period under a scheduling object.

fn is_long_back_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define a long back stub period under a scheduling object.

fn is_front_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define any front stub under a scheduling object.

fn is_back_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, ) -> bool

Check if two given unadjusted dates define any back stub under a scheduling object.

fn try_infer_ufront_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, short: bool, ) -> Result<Option<NaiveDateTime>, PyErr>

Infer an unadjusted front stub date from unadjusted irregular schedule dates.

fn try_infer_uback_stub( &self, ueffective: &NaiveDateTime, utermination: &NaiveDateTime, short: bool, ) -> Result<Option<NaiveDateTime>, PyErr>

Infer an unadjusted back stub date from unadjusted irregular schedule dates.

fn periods_per_annum(&self) -> f64

Get the approximate number of coupons per annum.

impl Serialize for Frequency

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Frequency