Enum TimeDelta 

pub enum TimeDelta {
    Valid {
        seconds: i64,
        attoseconds: i64,
    },
    NaN,
    PosInf,
    NegInf,
}

A signed time delta with attosecond precision.

TimeDelta represents a duration as whole seconds plus a fractional attosecond component. It also supports sentinel values for NaN and positive/negative infinity.

Variants

Valid

A finite time delta with whole seconds and an attosecond remainder in [0, 10¹⁸).

Fields

seconds: i64

Whole seconds component.

attoseconds: i64

Attosecond remainder in [0, 10¹⁸).

NaN

Not-a-number sentinel.

PosInf

Positive infinity sentinel.

NegInf

Negative infinity sentinel.

Implementations

impl TimeDelta

pub const ZERO: TimeDelta

A zero-length time delta.

pub const fn new(seconds: i64, attoseconds: i64) -> TimeDelta

Creates a new TimeDelta from seconds and attoseconds.

The attoseconds value is automatically normalized to [0, 10¹⁸), with overflow/underflow carried into the seconds component.

Examples

use lox_core::time::deltas::TimeDelta;

let dt = TimeDelta::new(1, 500_000_000_000_000_000);
assert_eq!(dt.seconds(), Some(1));
assert_eq!(dt.attoseconds(), Some(500_000_000_000_000_000));

pub const fn builder() -> TimeDeltaBuilder

Returns a TimeDeltaBuilder for constructing a TimeDelta from individual components.

pub const fn from_seconds_f64(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of seconds.

Returns NaN, PosInf, or NegInf for the corresponding special float values.

pub const fn from_seconds(seconds: i64) -> TimeDelta

Creates a TimeDelta from a whole number of seconds.

pub const fn from_minutes(minutes: i64) -> TimeDelta

Creates a TimeDelta from a whole number of minutes.

pub const fn from_minutes_f64(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of minutes.

pub const fn from_hours(hours: i64) -> TimeDelta

Creates a TimeDelta from a whole number of hours.

pub const fn from_hours_f64(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of hours.

pub const fn from_days(days: i64) -> TimeDelta

Creates a TimeDelta from a whole number of days.

pub const fn from_days_f64(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of days.

pub const fn from_milliseconds(ms: i64) -> TimeDelta

Creates a TimeDelta from a number of milliseconds.

pub const fn from_microseconds(us: i64) -> TimeDelta

Creates a TimeDelta from a number of microseconds.

pub const fn from_nanoseconds(ns: i64) -> TimeDelta

Creates a TimeDelta from a number of nanoseconds.

pub const fn from_picoseconds(ps: i64) -> TimeDelta

Creates a TimeDelta from a number of picoseconds.

pub const fn from_femtoseconds(fs: i64) -> TimeDelta

Creates a TimeDelta from a number of femtoseconds.

pub const fn from_attoseconds(atto: i64) -> TimeDelta

Creates a TimeDelta from a number of attoseconds.

pub const fn from_julian_years(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of Julian years (365.25 days each).

pub const fn from_julian_centuries(value: f64) -> TimeDelta

Creates a TimeDelta from a floating-point number of Julian centuries (36525 days each).

pub const fn from_seconds_and_subsecond( seconds: i64, subsecond: Subsecond, ) -> TimeDelta

Creates a TimeDelta from whole seconds and a Subsecond fractional part.

pub const fn from_seconds_and_subsecond_f64( seconds: f64, subsecond: f64, ) -> TimeDelta

Creates a TimeDelta from floating-point seconds and a subsecond fraction.

pub const fn from_julian_date(julian_date: f64, epoch: Epoch) -> TimeDelta

Creates a TimeDelta from a Julian date relative to the given epoch.

pub const fn from_two_part_julian_date(jd1: f64, jd2: f64) -> TimeDelta

Creates a TimeDelta from a two-part Julian date (jd1 + jd2).

pub const fn as_seconds_and_subsecond(&self) -> Option<(i64, Subsecond)>

Returns the whole seconds and Subsecond components, or None for non-finite values.

pub const fn to_seconds(&self) -> Seconds

Returns the time delta as a high-precision Seconds representation.

The result is a Seconds where hi contains the whole seconds and lo contains the subsecond fraction. This preserves full precision even for large time values.

For a lossy single f64, use .to_seconds().to_f64().

pub const fn is_negative(&self) -> bool

Returns true if the time delta is negative.

pub const fn is_zero(&self) -> bool

Returns true if the time delta is exactly zero.

pub const fn is_positive(&self) -> bool

Returns true if the time delta is positive.

pub const fn is_finite(&self) -> bool

Returns true if the time delta is a finite value (not NaN or infinite).

pub const fn is_nan(&self) -> bool

Returns true if the time delta is NaN.

pub const fn is_infinite(&self) -> bool

Returns true if the time delta is positive or negative infinity.

pub const fn seconds(&self) -> Option<i64>

Returns the whole seconds component, or None for non-finite values.

pub const fn subsecond(&self) -> Option<f64>

Returns the subsecond fraction as an f64, or None for non-finite values.

pub const fn attoseconds(&self) -> Option<i64>

Returns the attosecond component, or None for non-finite values.

pub const fn add_const(self, rhs: TimeDelta) -> TimeDelta

Adds two TimeDelta values in a const context.

pub const fn sub_const(self, rhs: TimeDelta) -> TimeDelta

Subtracts rhs from self in a const context.

pub const fn mul_const(self, rhs: f64) -> TimeDelta

Multiplies the time delta by an f64 scalar in a const context.

Trait Implementations

impl<T: TimeScale> Add<TimeDelta> for Time<T>

type Output = Time<T>

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> Self::Output

Performs the + operation.

impl Add for TimeDelta

type Output = TimeDelta

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> <TimeDelta as Add>::Output

Performs the + operation.

impl AddAssign for TimeDelta

fn add_assign(&mut self, rhs: TimeDelta)

Performs the += operation.

impl ApproxEq for TimeDelta

fn approx_eq(&self, rhs: &TimeDelta, atol: f64, rtol: f64) -> ApproxEqResults

Compares self with rhs for approximate equality.

impl Clone for TimeDelta

fn clone(&self) -> TimeDelta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimeDelta

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

Formats the value using the given formatter.

impl Default for TimeDelta

fn default() -> TimeDelta

Returns the “default value” for a type.

impl Display for TimeDelta

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

Formats the value using the given formatter.

impl From<f64> for TimeDelta

fn from(value: f64) -> TimeDelta

Converts to this type from the input type.

impl From<i32> for TimeDelta

fn from(value: i32) -> TimeDelta

Converts to this type from the input type.

impl From<i64> for TimeDelta

fn from(value: i64) -> TimeDelta

Converts to this type from the input type.

impl JulianDate for TimeDelta

fn julian_date(&self, epoch: Epoch, unit: Unit) -> f64

Expresses self as a Julian date in the specified Unit, relative to the given Epoch.

fn two_part_julian_date(&self) -> (f64, f64)

Expresses self as a two-part Julian date in the specified Unit, relative to the given Epoch.

fn seconds_since_julian_epoch(&self) -> f64

Returns the number of seconds since the Julian epoch as an f64.

fn seconds_since_modified_julian_epoch(&self) -> f64

Returns the number of seconds since the Modified Julian epoch as an f64.

fn seconds_since_j1950(&self) -> f64

Returns the number of seconds since J1950 as an f64.

fn seconds_since_j2000(&self) -> f64

Returns the number of seconds since J2000 as an f64.

fn days_since_julian_epoch(&self) -> f64

Returns the number of days since the Julian epoch as an f64.

fn days_since_modified_julian_epoch(&self) -> f64

Returns the number of days since the Modified Julian epoch as an f64.

fn days_since_j1950(&self) -> f64

Returns the number of days since J1950 as an f64.

fn days_since_j2000(&self) -> f64

Returns the number of days since J2000 as an f64.

fn years_since_julian_epoch(&self) -> f64

Returns the number of years since the Julian epoch as an f64.

fn years_since_modified_julian_epoch(&self) -> f64

Returns the number of years since the Modified Julian epoch as an f64.

fn years_since_j1950(&self) -> f64

Returns the number of years since J1950 as an f64.

fn years_since_j2000(&self) -> f64

Returns the number of years since J2000 as an f64.

fn centuries_since_julian_epoch(&self) -> f64

Returns the number of centuries since the Julian epoch as an f64.

fn centuries_since_modified_julian_epoch(&self) -> f64

Returns the number of centuries since the Modified Julian epoch as an f64.

fn centuries_since_j1950(&self) -> f64

Returns the number of centuries since J1950 as an f64.

fn centuries_since_j2000(&self) -> f64

Returns the number of centuries since J2000 as an f64.

impl Neg for TimeDelta

type Output = TimeDelta

The resulting type after applying the - operator.

fn neg(self) -> <TimeDelta as Neg>::Output

Performs the unary - operation.

impl Ord for TimeDelta

fn cmp(&self, other: &TimeDelta) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TimeDelta

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

fn partial_cmp(&self, other: &TimeDelta) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: TimeScale> Sub<TimeDelta> for Time<T>

type Output = Time<T>

The resulting type after applying the - operator.

fn sub(self, rhs: TimeDelta) -> Self::Output

Performs the - operation.

impl Sub for TimeDelta

type Output = TimeDelta

The resulting type after applying the - operator.

fn sub(self, rhs: TimeDelta) -> <TimeDelta as Sub>::Output

Performs the - operation.

impl SubAssign for TimeDelta

fn sub_assign(&mut self, rhs: TimeDelta)

Performs the -= operation.

impl Copy for TimeDelta

impl Eq for TimeDelta

impl StructuralPartialEq for TimeDelta