Struct Dt 

pub struct Dt { /* private fields */ }

Dt, and the library, is in the process of being switched from the sec and subsec fields being related to the scale, TO the sec and subsec fields always being TAI Epoch 2000-01-01 noon. Much of the documentation is outdated and should be ignored.

Implementations

impl Dt

pub const fn to_model_as_epoch(self, drift: Drift) -> ClockModel

Creates a new custom time model using this exact instant as the reference epoch.

• The supplied Drift defines the relativistic model for the timescale.
• The returned ClockModel can be used to convert to or from the custom timescale.

impl Dt

pub const fn to_drift_as_constant(self, rate: Dt, accel: Dt) -> Drift

pub const fn to_drift_as_rate(self, constant: Dt, accel: Dt) -> Drift

pub const fn to_drift_as_accel(self, constant: Dt, rate: Dt) -> Drift

impl Dt

pub const fn add(self, span: Dt) -> Self

pub const fn sub(self, span: Dt) -> Self

pub const fn to_sec_f(&self) -> Real

Converts this Dt to a floating-point number of seconds since the reference epoch of its associated scale.

The conversion is lossy by design, as Real provides approximately 15.95 decimal digits of precision. For full exactness, use the integer components sec and attos directly or higher-precision arithmetic when available.

pub const fn adjusted_advance(&mut self, elapsed: &Dt, spacetime: &Spacetime)

Advances this Dt by the given elapsed duration while applying the relativistic proper-time correction derived from the supplied Spacetime model.

This method is intended for simulation of remote clocks (e.g., Earth time as observed from a spacecraft). For the spacecraft’s own hardware proper-time clock, use the plain add method instead.

pub const fn adjusted_advance_using_drift( &mut self, elapsed: &Dt, drift: &Drift, )

Advances this Dt by the given elapsed duration while applying the relativistic proper-time correction from a pre-computed Drift value.

This is an optimized variant of adjusted_advance for callers that already hold a Drift instance. It is intended for simulation of remote clocks; the spacecraft’s own hardware clock should use the plain add method.

pub const fn to_diff_raw(&self, other: Self) -> Dt

Computes the signed duration between this Dt and another Dt.

pub const fn to_diff_raw_f(&self, other: Self) -> Real

Computes the signed duration between this Dt and another Dt as a float.

pub const fn add_1sec(&mut self)

Adds exactly 1 second to this time value using saturating arithmetic.

pub const fn add_1min(&mut self)

Adds exactly 1 minute (60 seconds) to this time value using saturating arithmetic.

pub const fn add_1hr(&mut self)

Adds exactly 1 hour (3600 seconds) to this time value using saturating arithmetic.

pub const fn add_1ms(&mut self)

Adds exactly 1 millisecond to this time value.

This affects the subsecond component and may cause a carry into the seconds field.

pub const fn add_1us(&mut self)

Adds exactly 1 microsecond to this time value.

This affects the subsecond component and may cause a carry into the seconds field.

pub const fn add_1ns(&mut self)

Adds exactly 1 nanosecond to this time value.

This affects the subsecond component and may cause a carry into the seconds field.

pub const fn add_sec(&mut self, n: i64)

Adds the specified number of seconds to this time value using saturating arithmetic.

pub const fn add_min(&mut self, n: i64)

Adds the specified number of minutes to this time value using saturating arithmetic.

pub const fn add_hr(&mut self, n: i64)

Adds the specified number of hours to this time value using saturating arithmetic.

pub const fn add_ms(&mut self, n: i64)

Adds the specified number of milliseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn add_us(&mut self, n: i64)

Adds the specified number of microseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn add_ns(&mut self, n: i64)

Adds the specified number of nanoseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn add_ps(&mut self, n: i64)

Adds the specified number of picoseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn add_fs(&mut self, n: i64)

Adds the specified number of femtoseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn add_attos(&mut self, n: i64)

Adds the specified number of attoseconds to this time value.

Handles carry into the seconds field using saturating logic.

pub const fn sub_1hr(&mut self)

Subtracts exactly 1 hour (3600 seconds) from this time value using saturating arithmetic.

pub const fn sub_1min(&mut self)

Subtracts exactly 1 minute (60 seconds) from this time value using saturating arithmetic.

pub const fn sub_1sec(&mut self)

Subtracts exactly 1 second from this time value using saturating arithmetic.

pub const fn sub_1ms(&mut self)

Subtracts exactly 1 millisecond from this time value.

This affects the subsecond component and may cause a borrow from the seconds field.

pub const fn sub_1us(&mut self)

Subtracts exactly 1 microsecond from this time value.

This affects the subsecond component and may cause a borrow from the seconds field.

pub const fn sub_1ns(&mut self)

Subtracts exactly 1 nanosecond from this time value.

This affects the subsecond component and may cause a borrow from the seconds field.

pub const fn sub_sec(&mut self, n: i64)

Subtracts the specified number of seconds from this time value using saturating arithmetic.

pub const fn sub_min(&mut self, n: i64)

Subtracts the specified number of minutes from this time value using saturating arithmetic.

pub const fn sub_hr(&mut self, n: i64)

Subtracts the specified number of hours from this time value using saturating arithmetic.

pub const fn sub_ms(&mut self, n: i64)

Subtracts the specified number of milliseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn sub_us(&mut self, n: i64)

Subtracts the specified number of microseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn sub_ns(&mut self, n: i64)

Subtracts the specified number of nanoseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn sub_ps(&mut self, n: i64)

Subtracts the specified number of picoseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn sub_fs(&mut self, n: i64)

Subtracts the specified number of femtoseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn sub_attos(&mut self, n: i64)

Subtracts the specified number of attoseconds from this time value.

Handles borrow from the seconds field using saturating logic.

pub const fn to_attos(&self) -> i128

Total attoseconds (exact i128 representation within the representable range).

pub const fn to_ms(&self) -> i128

Returns the total time in milliseconds.

pub const fn to_us(&self) -> i128

Returns the total time in microseconds.

pub const fn to_ns(&self) -> i128

Returns the total time in nanoseconds.

pub const fn to_ps(&self) -> i128

Returns the total time in picoseconds.

pub const fn to_fs(&self) -> i128

Returns the total time in femtoseconds.

pub const fn is_zero(&self) -> bool

Returns true if this time is exactly zero.

pub const fn is_positive(&self) -> bool

Returns true if this time is strictly positive (> 0).

pub const fn mul(self, rhs: i64) -> Self

Multiplies this time by an integer scalar (exact).

Uses 128-bit arithmetic internally.

pub const fn div(self, rhs: i64) -> Self

Divides this time by an integer scalar (exact floor division).

Returns ZERO if rhs == 0. Uses floor division (toward negative infinity) for consistency with the existing floor method.

pub const fn floor(&self, unit: Self) -> Self

Returns the largest multiple of unit that is ≤ self. If unit is zero, returns self unchanged (exact, full precision).

pub const fn ceil(&self, unit: Self) -> Self

Returns the smallest multiple of unit that is ≥ self. If unit is zero, returns self unchanged (exact, full precision).

pub const fn round(&self, unit: Self) -> Self

Returns the nearest multiple of unit. Halfway cases round away from zero (matches old f64::round). If unit is zero, returns self unchanged (exact, full precision).

pub const fn abs_div_floor(&self, unit: Self) -> usize

Returns floor(|self| / |unit|) as usize, saturating at usize::MAX.

Fully exact integer arithmetic using 128-bit intermediaries. Used by TimeRange::len.

pub const fn mul_by_f(&self, rhs: Real) -> Self

• Integer part of rhs is multiplied exactly (pure i128 arithmetic).
• Fractional part (|frac| < 1) uses the 10¹⁵ scaling.

pub const fn div_by_f(&self, rhs: Real) -> Self

Divides by a real number (routes through the high-precision mul_by_f).

pub const fn div_by_2(&self) -> Self

Divides this Dt by 2 (convenience wrapper).

pub const fn to_sec(&mut self) -> i64

Returns the total time in seconds.

impl Dt

pub const ZERO: Self

The library’s internal reference epoch: exactly 2000-01-01 12:00:00 TAI.

[Dt::new(0, 0)].

pub const UNIX_EPOCH: Self

UNIX epoch.

• 1970-01-01 midnight TAI.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• -946_728_000 sec
• 0 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const TAI_1977_EPOCH: Self

TT/TCG/TCB/TDB epoch.

• 1977-01-01 midnight TAI.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• -725_803_200 sec
• 0 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const TCL_1977_EPOCH: Self

TT/TCG/TCB/TDB/TCL epoch.

• 1977-01-01 midnight TAI.
• Stored here on the TCL timescale as an offset from Self::ZERO.
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const CXC_EPOCH: Self

Chandra X-ray Center (CXC) Time epoch.

• 1998-01-01 midnight TT.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• -63_115_233 sec
• 816000000000000000 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const GPS_EPOCH: Self

GPS/Galileo Experiment (GALEX) Time epoch.

• 1980-01-06 00:00:00 UTC.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• -630_763_200 + 19 sec
• 0 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const GALILEO_EPOCH: Self

Galileo System Time (GST) epoch.

• 1999-08-22 00:00:00 GST.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• -11_448_000 + 19 sec
• 0 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const BDT_EPOCH: Self

BeiDou Time (BDT) epoch.

• 2006-01-01 00:00:00 UTC.
• Stored here on the TAI timescale as an offset from Self::ZERO.
• 189_345_600 + 33 sec
• 0 attos
• The library’s epoch for time scales during conversions is 2000-01-01 noon. This const is provided as a convenience.

pub const MAX: Self

Maximum representable duration (i64::MAX seconds + 999… attoseconds).

pub const MIN: Self

Minimum (most negative) representable duration (i64::MIN seconds).

pub const SEC_19: Self

pub const SEC_33: Self

pub const SEC_37: Self

pub const ONE_DAY: Self

pub const fn new(sec: i64, attos: u64) -> Self

Creates a new Dt from whole seconds, a subsecond part in attoseconds, and a scale, automatically normalizing the representation.

pub const fn from_attos(attos: i128, scale: Scale) -> Self

pub const fn from_sec(sec: i64, scale: Scale) -> Self

pub const fn from_ms(ms: i128, scale: Scale) -> Self

pub const fn from_us(us: i128, scale: Scale) -> Self

pub const fn from_ns(ns: i128, scale: Scale) -> Self

pub const fn from_ps(ps: i128, scale: Scale) -> Self

pub const fn from_fs(fs: i128, scale: Scale) -> Self

pub const fn from_min(m: i64, scale: Scale) -> Self

pub const fn from_hr(h: i64, scale: Scale) -> Self

pub const fn from_hms( hr: i64, min: i64, sec: i64, ms: i128, us: i128, ns: i128, scale: Scale, ) -> Self

Creates a Dt from hours, minutes, seconds, milliseconds, microseconds, and nanoseconds on the supplied scale.

pub const fn from_days(d: i64, scale: Scale) -> Dt

pub const fn wk(wk: i64, scale: Scale) -> Dt

pub const fn yr(yr: i64, scale: Scale) -> Dt

pub const fn ago(self, scale: Scale) -> Dt

Returns a Dt that is this duration ago from the given scale.

pub const fn from_now(self, scale: Scale) -> Dt

Returns a Dt that is this duration from now in the given scale.

pub const fn neg(self) -> Self

Returns the negation of this duration.

pub const fn abs(self) -> Self

Returns the positive of this duration.

pub const fn from_sec_f(sec_f: Real) -> Self

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

pub const fn from_sec_f_on(sec_f: Real, s: Scale) -> Self

impl Dt

pub const fn from_dt(dt: Dt, scale: Scale) -> Dt

pub const fn from_attos_since(attos: i128, reference: Dt) -> Self

pub const fn to_scale_and_then_diff(&self, scale: Scale, epoch: Dt) -> Dt

pub const fn from_diff_and_scale(diff: Dt, epoch: Dt, current: Scale) -> Self

pub const fn from(sec: i64, attos: u64, scale: Scale) -> Dt

Creates a TAI Dt, converting from another scale.

pub const fn to_tai(&self, current: Scale) -> Dt

pub const fn to(&self, current: Scale, target: Scale) -> Dt

pub const fn convert_using_drift(self, reference: Self, drift: Drift) -> Self

Converts this instant to any other Scale while applying an exact quadratic relativistic or clock-drift correction defined by a Drift model relative to a reference instant.

pub const fn convert_back_using_drift( self, reference: Self, drift: Drift, ) -> Self

Performs the inverse conversion of Self::convert_using_drift, recovering the original proper time on the source clock scale.

A fixed-point iteration (at most 16 steps) is used to solve the implicit equation. For the common case of a pure constant offset the function returns immediately without iteration.

pub const fn convert_using_model(self, model: ClockModel) -> Self

Converts this instant using a self-describing ClockModel.

pub const fn convert_back_using_model(self, model: ClockModel) -> Self

Performs the inverse conversion of Self::convert_using_model.

pub const fn tai_to_tdb(tai: Self) -> Self

pub const fn tdb_to_tai(tdb: Self) -> Self

impl Dt

pub const fn to_msd_exact(&self, current: Scale) -> (i64, u128)

Returns the exact Mars Sol Date (MSD) as a tuple of integer sols and the fractional part of a sol.

The computation follows the canonical NASA GISS / AM2000 formulation and works for any input Scale. Leap seconds are automatically accounted for when converting from UTC.

pub const fn to_mtc(&self, current: Scale) -> Dt

Returns Mars Coordinated Time (MTC) as a Dt representing seconds into the current sol (range [0, one Martian sol)).

pub const fn from_msd_exact(whole_sols: i64, frac_attos: u128) -> Self

Creates a Dt (in TT) from an exact Mars Sol Date using full library precision.

pub const fn from_msd(msd: Real) -> Self

Creates a Dt (in TT) from a floating-point Mars Sol Date. Non-exact Real.

pub const fn to_msd(&self, current: Scale) -> Real

Returns the Mars Sol Date (MSD) as a floating-point value (matches NASA Mars24 output). Non-exact Real.

impl Dt

pub const fn to_jyear(&self) -> Real

Returns the Julian epoch year.

pub const fn from_jyear(jyear: Real, scale: Scale) -> Self

Inverse of Self::to_jyear.

pub const fn to_byear(&self) -> Real

Returns the Besselian epoch year.

pub const fn from_byear(byear: Real, scale: Scale) -> Self

Inverse of Self::to_byear.

pub const fn to_decimalyear(&self, current: Scale) -> Real

Returns the decimal year (Gregorian calendar year + fraction of the year).

This is the direct equivalent of Astropy’s Time.decimalyear:

• Uses the actual length of the specific Gregorian year (365 or 366 days, plus any leap seconds on UTC/UTCSpice/etc.).
• Fully scale-aware (TAI, TT, UTC, TDB, custom clocks, …).
• Exact integer arithmetic for the year boundaries, then a high-precision to_sec_f division (lossy only at the final Real step, same as Astropy).

impl Dt

pub fn from_ccsds_str(input: &str) -> Result<Self, DtErr>

Generalized CCSDS ASCII Time Code parser (A or B variant). Handles both calendar (%Y-%m-%d) and day-of-year (%Y-%j) formats. All time components after the date portion are optional.

pub fn from_ccsds_ccs(input: &[u8]) -> Result<Dt, DtErr>

Parses a CCSDS CCS (Calendar Segmented Time Code) binary time code directly into TimeParts.

Implements CCSDS 301.0-B-4 §3.4 (Level 1 only).

P-field (exactly 1 byte)

• Bit 7: Extension flag → must be 0 (we reject extensions)
• Bits 6-4: Code ID = 101
• Bit 3: Calendar type (0 = Month/Day, 1 = Day-of-Year)
• Bits 2-0: Number of subsecond BCD octets (0–6)

T-field (BCD, big-endian)

• 2 bytes: Year (0001–9999)
• 2 bytes: Month+Day (01-12,01-31) or Day-of-Year (001–366)
• 3 bytes: Hour (00-23), Minute (00-59), Second (00-60)
• 0–6 bytes: Fractional seconds (exactly 2 decimal digits per byte)

Epoch: 1958-01-01 00:00:00 UTC (identical to CDS).

pub fn from_ccsds_c(input: &[u8]) -> Result<Dt, DtErr>

Parses a CCSDS C (CUC – Unsegmented Time Code) binary time code directly into Dt.

This function implements CCSDS 301.0-B-4 §3.2 (Level 1 only) with full support for the extended P-field (second octet) as defined in the standard.

Supported formats (Level 1 only)

• 1-byte or 2-byte P-field (further extension beyond 2 bytes is rejected).
• Code ID must be 001 (1958-01-01 TAI epoch).
• Coarse time: 1–7 octets (base 1–4 from Octet 1 + up to 3 additional from Octet 2).
• Fractional time: 0–10 octets (base 0–3 from Octet 1 + up to 7 additional from Octet 2).

P-field decoding (when Bit 0 of Octet 1 = 1)

• Octet 2:
  • Bit 0: Further-extension flag (must be 0; we reject 3+-byte P-fields).
  • Bits 1-2: Additional coarse octets (0–3).
  • Bits 3-5: Additional fractional octets (0–7).
  • Bits 6-7: Reserved for mission definition (ignored).

Precision

Fractional seconds are converted to attoseconds with exact integer scaling (value / 2^(8·n_frac)). Larger n_frac gives higher resolution (down to ~2⁻⁸⁰ s with 10 fractional bytes).

Returns

A Dt with scale = TAI and tz = Utc.

Errors

• [DtErrKind::CCSDSBinEmpty] if the input is empty.
• [DtErrKind::CCSDSBinTooShort] if the input is too short for the declared P-field / T-field sizes or otherwise malformed.
• [DtErrKind::CCSDSBinInvalidCodeId] if the Code ID is not 001.
• [DtErrKind::CCSDSBinInvalidPFieldExtension] if the further-extension flag is set (3+ byte P-field, unsupported).

pub fn from_ccsds_d(input: &[u8]) -> Result<Dt, DtErr>

Parses a CCSDS D (CDS – Day Segmented Time Code) binary time code directly into Dt.

This function implements CCSDS 301.0-B-4 §3.3 (Level 1 only).

Supported formats

• 1-byte or 2-byte P-field.
• Code ID must be 100 and Epoch bit must be 0 (1958-01-01 UTC epoch).
• n_day: 2 or 3 bytes for the day count.
• Middle field is always 4 bytes of milliseconds since midnight.
• Sub-millisecond field (bits 6-7 of P-field):
  • 00: no fractional field
  • 01: 2 bytes (microseconds of the millisecond, 0–65535)
  • 10: 4 bytes (2⁻³² of the millisecond)

Precision

• The millisecond field is rounded to the nearest millisecond (in the encoder).
• With 2-byte sub-ms: maximum quantization error ≈ ±7.63 ns.
• With 4-byte sub-ms: maximum quantization error ≈ ±0.116 ps.

Returns

A Dt with timescale = Utc and tz = Utc.

Errors

• [DtErrKind::CCSDSBinEmpty] if the input is empty.
• [DtErrKind::CCSDSBinTooShort] if the input is too short for the declared field sizes.
• [DtErrKind::CCSDSBinInvalidCodeId] if the Code ID is not 100.
• [DtErrKind::CCSDSBinInvalidEpoch] if the Epoch bit is set (non-Level-1 / non-1958 epoch).
• [DtErrKind::CCSDSBinInvalidSubMillisecondCode] if bits 6-7 encode an unsupported value (0b11).

pub fn from_ccsds_bin(input: &[u8]) -> Result<Dt, DtErr>

Auto-detects and parses a CCSDS binary time code (CUC, CDS, or CCS) based on the Code ID in the first P-field byte.

Convenience wrapper around TimeParts::from_ccsds_bin.

Supported formats

• Code ID 001 → CUC (Unsegmented)
• Code ID 100 → CDS (Day Segmented)
• Code ID 101 → CCS (Calendar Segmented)

Errors

• [DtErrKind::CCSDSBinEmpty] if the input is empty.
• [DtErrKind::CCSDSBinInvalidCodeId] for any other Code ID.

impl Dt

pub const fn from_gps_wk_and_tow(wk: i64, tow: Dt) -> Self

Creates a Dt in GPS Time (GPS) from a GPS week number and Time of Week (TOW).

This is the exact inverse of [Self::to_gps_week_and_tow].

• week: Full GPS week number (can be negative for dates before 1980).
• tow: Time of Week as a Dt. Values ≥ 604800 seconds are automatically carried into the week number.

The resulting Dt is always in Scale::GPS.

pub const fn from_gps_wk_and_tow_f(week: i64, tow: Real) -> Self

Creates a Dt in GPS Time from a GPS week number and floating-point Time of Week.

This is the floating-point counterpart to Self::from_gps_wk_and_tow.

pub const fn from_gps(elapsed: Dt) -> Self

Inverse of Self::to_gps.

pub const fn from_gps_f(elapsed_sec: Real) -> Self

Floating-point version of Self::from_gps.

pub const fn from_cxcsec(elapsed: Dt) -> Self

Inverse of Self::to_cxcsec.

pub const fn from_cxcsec_f(elapsed_sec: Real) -> Self

Floating-point counterpart of Self::from_cxcsec.

pub const fn from_galexsec(elapsed: Dt) -> Self

Inverse of Self::to_galexsec.

pub const fn from_galexsec_f(elapsed_sec: Real) -> Self

Floating-point counterpart of Self::from_galexsec.

impl Dt

pub fn from_str( s: &str, fmt: &str, inp_can_end_before_fmt: bool, fmt_can_end_before_inp: bool, allow_partial_date: bool, ) -> Result<Dt, DtErr>

pub fn parse_fmt(strptime_fmt: &str) -> Result<StrPTimeFmt, DtErr>

pub fn from_iso(s: &str) -> Result<Dt, DtErr>

pub fn looks_like_iso(s: &str) -> bool

Accepts: P1Y, -P2W, PT1.5H, P1DT2H30M, +P3D, p1y, P1,5S, PT0S, etc. Rejects: anything with whitespace, lone “P”/“-P”/“PT”, “P123”, “Please wait 5m”, “1.5h”, “P1Yabc”, “P1Y!”, or any string longer than 128 bytes.

impl Dt

pub const fn to_unix(&self, current: Scale, target: Scale) -> Dt

Returns this Dt but as a unix timestamp where the:

• .sec field is seconds since the UNIX epoch (1970-01-01 00:00:00).
• .attos field is remaining fractional seconds.

Notes:

• Assumes this Dt is from the 2000-01-01 noon epoch.

pub const fn unix_sec_to_ymd(unix_sec: i64) -> (i64, u8, u8)

Converts a Unix timestamp (seconds since 1970-01-01 00:00:00 UTC) to a proleptic Gregorian date (year, month, day).

pub const fn to_gregorian_time(&self, current: Scale) -> GregorianTime

pub const fn to_ymdhms(&self, current: Scale) -> YmdHms

Returns the Gregorian date and wall time for this instant.

• For Scale::UTC: Uses a direct Unix-timestamp-based path (fast and clean).
• For all other scales: Uses the standard TT-based JD path.

pub const fn ymdhms_to_unix_sec( yr: i64, mo: u8, day: u8, hr: u8, min: u8, sec: u8, ) -> i64

Converts a proleptic Gregorian calendar date+time to a Unix timestamp (seconds since 1970-01-01 00:00:00 UTC).

This version is correct for the full i64 range, including negative years.

pub const fn jdn_to_ymd(jdn: i64) -> (i64, u8, u8)

Converts a Julian Day Number (JDN) to a proleptic Gregorian calendar date.

Returns (year, month, day) where month ∈ [1, 12] and day ∈ [1, 31] (standard 1-based Gregorian values).

This is the inverse of Self::ymd_to_jdn. Supports the full i64 range, including negative years and year zero.

pub const fn ymd_to_jdn(year: i64, month: u8, day: u8) -> i64

Computes the Julian Day Number (JDN) for a proleptic Gregorian calendar date at noon UT.

The algorithm matches the standard astronomical convention used throughout the library (ymd_to_jdn(2000, 1, 1) == 2451545).

pub const fn is_leap_year(year: i64) -> bool

Returns true if the given year is a Gregorian leap year under proleptic rules.

pub const fn from_ymdhms( yr: i64, mo: u8, day: u8, hr: u8, min: u8, sec: u8, attos: u64, ) -> Self

Creates a Dt at the specified civil UTC instant with full attosecond precision on the proleptic Gregorian calendar, then converts it to the requested Scale.

All input components are clamped to their valid ranges:

• mo → 0..=12
• day → 0..=31
• hr → 0..=23
• min → 0..=59
• sec → 0..=60 (permits leap seconds)
• attos → values ≥ 10¹⁸ are carried into the seconds field

pub const fn from_ymdhms_on( yr: i64, mo: u8, day: u8, hr: u8, min: u8, sec: u8, attos: u64, scale: Scale, ) -> Self

pub const fn from_ymd(yr: i64, mo: u8, day: u8) -> Self

Creates a Dt representing midnight 00:00:00 UTC on the given proleptic Gregorian date.

pub const fn from_ymd_on(yr: i64, mo: u8, day: u8, scale: Scale) -> Self

Creates a Dt representing midnight 00:00:00 on the given Scale on the given proleptic Gregorian date.

pub const fn ydoy_to_jdn(year: i64, day_of_year: u16) -> i64

Computes the Julian Day Number from a Gregorian year and ordinal day-of-year.

pub const fn jdn_to_weekday(jdn: i64) -> u8

Converts a Julian Day Number to the corresponding weekday number (0 = Sunday … 6 = Saturday).

pub const fn ymd_to_jdn_from_iso_week( iso_year: i64, iso_week: u8, weekday: Weekday, ) -> i64

Computes the Julian Day Number from an ISO week date (Monday-based week).

pub const fn ymd_to_jdn_from_week_sun( year: i64, week: u8, weekday: Weekday, ) -> i64

Computes the Julian Day Number from a Sunday-based week-of-year (%U).

pub const fn ymd_to_jdn_from_week_mon( year: i64, week: u8, weekday: Weekday, ) -> i64

Computes the Julian Day Number from a Monday-based week-of-year (%W).

pub const fn is_valid_ymd(year: i64, month: u8, day: u8) -> bool

Returns true if the supplied values form a valid proleptic Gregorian calendar date.

pub const fn has_iso_week_53(year: i64) -> bool

Returns true if the given Gregorian year contains an ISO week 53.

pub const fn day_of_year( &self, current: Scale, ymd: Option<(i64, u8, u8)>, ) -> u16

Returns the ordinal day of the year (1-based).

January 1 is day 1; December 31 is day 365 or 366 (in leap years). Uses the proleptic Gregorian calendar.

pub const fn wk_sun( &self, current: Scale, ymd: Option<(i64, u8, u8)>, doy: Option<u16>, ) -> u8

Sunday-based week number (%U in strftime).

Range: 0..=53.

• Week 0 contains the days before the first Sunday of the year.
• Week 1 begins on the first Sunday of the year.

The optional ymd and doy arguments are performance optimisations (same pattern used throughout the file for day_of_year, to_iso_week_date, etc.). Pass whichever you already have; the function will use the fastest path.

pub const fn wk_mon( &self, current: Scale, ymd: Option<(i64, u8, u8)>, doy: Option<u16>, ) -> u8

Monday-based week number (%W in strftime).

Range: 0..=53.

• Week 0 contains the days before the first Monday of the year.
• Week 1 begins on the first Monday of the year.

The optional ymd and doy arguments are performance optimisations (same pattern as wk_sun, day_of_year, to_iso_week_date, etc.).

pub const fn to_iso_week_date( &self, current: Scale, ymd: Option<(i64, u8, u8)>, ) -> (i64, u8, Weekday)

Returns the ISO 8601 week date for this Dt.

Returns (iso_year, iso_week, weekday) where:

• iso_year is the ISO week year (may differ from the Gregorian year near year boundaries),
• iso_week is the week number in the range 1..=53,
• weekday is a Weekday value (Monday-based week).

Follows the ISO 8601 standard: weeks start on Monday and week 1 is the week containing January 4.

The optional ymd argument is a performance optimization. If provided, it is used directly; otherwise to_gregorian_ymd is called internally.

impl Dt

pub const fn to_jd(&self) -> (i64, u128)

Returns the exact Julian Date of this instant as (integer_days, fractional_attoseconds).

The returned JD is expressed in the time scale of this Dt. The fractional part is always in [0, ATTOS_PER_DAY).

For a float value use Self::to_jd_f.

pub const fn to_jd_f(&self) -> Real

Returns the Julian Date of this instant as a floating-point Real.

This is the lossy counterpart to Self::to_jd.

pub const fn to_mjd(&self) -> (i64, u128)

Returns the exact Modified Julian Date of this instant as (integer_days, fractional_attoseconds).

The returned MJD is expressed in the time scale of this Dt. The fractional part is always in [0, ATTOS_PER_DAY).

For a float value use Self::to_mjd_f.

pub const fn to_mjd_f(&self) -> Real

Returns the Modified Julian Date of this instant as a floating-point Real.

This is the lossy counterpart to Self::to_mjd.

pub const fn from_jd(jd_days: i64, frac_attos: u128, on: Scale) -> Self

Creates a Dt from an exact Julian Date.

This is the inverse of Self::to_jd. For correct round-tripping you must pass the same on: Scale that matches the scale of the original Dt.

pub const fn from_mjd(mjd_days: i64, frac_attos: u128, on: Scale) -> Self

Creates a Dt from an exact Modified Julian Date.

This is the inverse of Self::to_mjd. For correct round-tripping you must pass the same on: Scale that matches the scale of the original Dt.

pub const fn from_jd_f(jd: Real, on: Scale) -> Self

Creates a Dt from a float Julian Date.

This is the inverse of Self::to_jd_f. For correct round-tripping you must pass the same on: Scale that matches the scale of the original Dt.

pub const fn from_mjd_f(mjd: Real, on: Scale) -> Self

Creates a Dt from a float Modified Julian Date.

This is the inverse of Self::to_mjd_f. For correct round-tripping you must pass the same on: Scale that matches the scale of the original Dt.

impl Dt

pub const fn cmp(&self, other: &Self) -> Ordering

Compares this Dt with another by converting both to the TAI timescale (the library’s canonical physical-time reference) and then comparing their (sec, attos) pairs.

This is a const fn so it can be used in const contexts and is allocation-free. It provides the total order used by <, >, <=, >=, cmp, etc.

Two Dts that represent the exact same physical instant (after all leap-second, relativistic, and scale conversions) compare as Equal, even if they were constructed with different [Scale]s.

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

Returns the smaller of two Dts according to the total physical-time order defined by Self::cmp.

Both instants are converted to TAI internally, so the result is the physically earlier instant even when the two Dts belong to different [Scale]s (leap seconds, relativistic offsets, etc. are all taken into account).

This is a const fn and can be used in const contexts.

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

Returns the larger of two Dts according to the total physical-time order defined by Self::cmp.

See Self::min for more details.

pub const fn eq(&self, other: &Self) -> bool

pub const fn lt(&self, other: &Self) -> bool

Returns true if this Dt is less than the other.

This is a const fn so it can be used in const contexts.

pub const fn gt(&self, other: &Self) -> bool

Returns true if this Dt is greater than the other.

This is a const fn so it can be used in const contexts.

pub const fn le(&self, other: &Self) -> bool

Returns true if this Dt is less than or equal to the other.

This is a const fn so it can be used in const contexts.

pub const fn ge(&self, other: &Self) -> bool

Returns true if this Dt is greater than or equal to the other.

This is a const fn so it can be used in const contexts.

impl Dt

pub const CCSDS_C_AND_D_MAX_SIZE: usize = 32

Maximum size needed for a CCSDS C & D (CUC) binary packet (with extended P-field).

pub const CCSDS_CCS_MAX_SIZE: usize = 14

Maximum size needed for a CCSDS CCS binary packet (P-field + T-field).

pub fn to_ccsds_c( &self, current: Scale, n_coarse: u8, n_frac: u8, extension: bool, ) -> Result<([u8; 32], usize), DtErr>

Formats this Dt as a CCSDS C (CUC) binary time code.

Fully configurable for round-tripping with [from_ccsds_c]. Conforms to CCSDS 301.0-B-4 §3.2 (Level 1), including full support for the extended P-field (second octet) when n_coarse > 4 or n_frac > 3.

Parameters

• n_coarse: 1–7 (number of coarse-time octets)
• n_frac: 0–10 (number of fractional octets)
• extension: advisory flag (ignored when larger sizes force the second octet)

pub fn to_ccsds_d( &self, current: Scale, n_day: u8, sub_ms_code: u8, extension: bool, ) -> Result<([u8; 32], usize), DtErr>

Formats this Dt as a CCSDS D (CDS) binary time code.

Fully configurable for round-tripping with [from_ccsds_d]. Conforms to CCSDS 301.0-B-4 §3.3 (Level 1): UTC day count + ms-of-day since 1958-01-01 UTC.

pub fn to_ccsds_ccs( &self, current: Scale, use_doy: bool, n_subsec: u8, ) -> Result<([u8; 14], usize), DtErr>

Formats this Dt as a CCSDS CCS (Calendar Segmented Time Code).

Implements CCSDS 301.0-B-4 §3.4 (Level 1 only).

Parameters

• use_doy: false = Month/Day variant (most common), true = Day-of-Year variant
• n_subsec: Number of subsecond BCD octets (0–6). Each octet holds 2 decimal digits.

Returns

(buffer, written_len) — the P-field + T-field (big-endian BCD).

Precision & Rounding

Fractional seconds are rounded to the nearest representable value at the chosen precision (exactly as to_ccsds_d does for milliseconds).

pub fn to_ccsds_bin(&self, current: Scale) -> Result<([u8; 32], usize), DtErr>

Convenience method that automatically selects the most appropriate CCSDS binary time code based on current Scale.

• If the current Scale uses leap seconds then ccsds_d is chosen.
• Otherwise ccsds_c is chosen.

impl Dt

pub const fn to_gps_wk_and_tow(&self, current: Scale) -> (i64, Dt)

Returns the GPS week number and exact Time of Week (TOW) for this instant when expressed in GPS Time.

pub const fn to_gps_day_of_wk(&self, current: Scale) -> u8

Returns the day of the GPS week (0 = Sunday, 1 = Monday, …, 6 = Saturday).

This is computed directly from GPS Time and is independent of the Gregorian calendar.

pub const fn to_gps_tow_f(&self, current: Scale) -> Real

Returns the Time of Week (TOW) as a floating-point value in seconds.

This is a convenience method for code that prefers f64 / Real. For full attosecond precision use Self::to_gps_wk_and_tow.

pub const fn to_gps_wk(&self, current: Scale) -> i64

Returns only the GPS week number.

pub const fn to_galexsec(&self, current: Scale) -> Dt

pub const fn to_gps(&self, current: Scale) -> Dt

pub const fn to_cxcsec(&self, current: Scale) -> Dt

impl Dt

pub fn to_str_bin( &self, current: Scale, fmt: &str, ) -> Result<AsciiStr<STRFTIME_SIZE>, DtErr>

No-alloc label-only formatting.

pub fn to_str_bin_with_offset( &self, current: Scale, fmt: &str, secs: i32, ) -> Result<AsciiStr<STRFTIME_SIZE>, DtErr>

No-alloc label-only formatting.

pub fn to_str_bin_with_tz( &self, current: Scale, fmt: &str, tz_name: &str, ) -> Result<AsciiStr<STRFTIME_SIZE>, DtErr>

No-alloc full IANA adjusted formatting (civil time is adjusted to local wall time).

pub const fn sec_as_hhmm(seconds: i32) -> (bool, u8, u8)

Returns (is_negative, hours, minutes).

pub fn to_u8_with_offset( &self, current: Scale, fmt: &str, dest: &mut [u8], secs: i32, ) -> Result<usize, DtErr>

Helper for to_str.

pub fn to_u8_with_tz( &self, current: Scale, fmt: &str, dest: &mut [u8], tz_name: &str, ) -> Result<usize, DtErr>

Helper for to_str.

impl Dt

pub fn proper_time_from_states<I>( samples: I, characteristic_length_scale: Real, ) -> Result<Self, DtErr>

where I: IntoIterator<Item = (Self, Velocity, Real)>,

Computes the relativistic clock drift (proper time minus coordinate time) over an interval.

This returns how much a physical clock has gained or lost time compared with coordinate time between start and end.

• A positive result means the onboard clock ran fast.
• A negative result means the onboard clock ran slow.

Parameters

• start: Starting coordinate time of the interval.
• end: Ending coordinate time of the interval.
• states: Iterator of physical states. Coordinate times must be monotonically non-decreasing. It is the caller’s responsibility to ensure the provided states cover the time range from start to end. The function integrates proper time over whatever states are supplied and subtracts the requested coordinate interval (end - start). Exact matching of the first and last state times to start and end is not validated.
• characteristic_length_scale: See [proper_time_from_states].

Returns

Ok(drift) — the accumulated drift (Δτ − Δt) as a Dt.

Err(DtErr) — if the states are not monotonically increasing in time.

pub fn proper_time_drift_from_states<I>( start: Dt, end: Dt, states: I, characteristic_length_scale: Real, ) -> Result<Dt, DtErr>

where I: IntoIterator<Item = (Self, Velocity, Real)>,

Computes the relativistic clock drift (proper time minus coordinate time) over an interval.

This returns how much a physical clock has gained or lost time compared with coordinate time between start and end.

• A positive result means the onboard clock ran fast.
• A negative result means the onboard clock ran slow.

Parameters

• start: Starting coordinate time.
• end: Ending coordinate time.
• states: Iterator of physical states covering the interval. Coordinate times must be monotonically non-decreasing. It is the caller’s responsibility to ensure the states span the requested interval (exact first/last time matching is not checked).
• characteristic_length_scale: See [proper_time_from_states].

Returns

Ok(drift) — the accumulated drift (Δτ − Δt) as a Dt.

Err(DtErr) — if the states are not monotonically increasing in time.

pub fn proper_time_from_path<I>(path: I) -> Result<Self, DtErr>

where I: IntoIterator<Item = (Self, Spacetime)>,

Computes accumulated proper time along an arbitrary trajectory.

This is the core integration function of the library. It walks the supplied path segment by segment and applies the trapezoidal rule to the instantaneous proper-time rate at each step.

This approach is commonly used when integrating clock rates along sampled trajectories in astrodynamics and high-precision timing work.

The function enforces that coordinate times are monotonically non-decreasing. It performs a single pass with no heap allocation.

Parameters

• path: An iterator of (coordinate_time, Spacetime) pairs. Coordinate times must be monotonically non-decreasing.

Returns

Ok(total_proper_time) — the accumulated proper time as a Dt.

Err(DtErr) — if the path is empty or contains any decrease in coordinate time.

pub const fn proper_time_between_constant_rate( self, end: Dt, dtau_dt: Real, ) -> Dt

Computes proper time advance over an interval when the rate is constant.

Use this for segments where conditions do not change, such as a ground station, a circular orbit, or a deep-space cruise phase with constant velocity and gravitational potential.

This is mathematically equivalent to integrating a constant rate but is more efficient and expresses intent clearly.

Parameters

• end: Ending coordinate time.
• dtau_dt: Constant proper-time rate (dimensionless, usually between 0 and 1).

Returns

The accumulated proper time advance as a Dt.

impl Dt

pub const fn sec(&self) -> i64

Seconds field getter.

pub const fn attos(&self) -> u64

Subseconds field getter (attoseconds).

pub const fn carry_over(&mut self) -> &mut Self

Normalizes the representation so that the attosecond part lies in the range [0, ATTOS_PER_SEC).

impl Dt

pub const SHAPIRO_SOLAR: Self

Shapiro gravitational time scale for the Sun (2 G M_☉ / c³).

This is the recommended value to pass as the shapiro parameter to ObserverState::one_way_relativistic_delay (and ObserverState::shapiro_delay_to) for all normal solar-system work.

It corresponds to the one-way Shapiro coefficient for the Sun.

pub const fn shapiro_from_grav_param(gm: Real) -> Self

Creates the Shapiro delay scale for an arbitrary central body from its standard gravitational parameter GM (μ) in m³ s⁻².

This produces the coefficient used in the Shapiro gravitational time delay formula. It is the recommended way to create a custom Shapiro scale for planets, stars, or other massive bodies.

Pass the resulting value to ObserverState::one_way_relativistic_delay or ObserverState::shapiro_delay_to.

pub const fn to_observer_state( self, position: Position, velocity: Velocity, grav_potential_m2_s2: Real, characteristic_length_scale: Real, ) -> ObserverState

Creates an ObserverState using this time value along with the provided position, velocity, and gravitational information.

An ObserverState represents a complete snapshot of an observer (spacecraft, ground station, planet, etc.) at a specific moment. It bundles together the time, position, velocity, and local gravitational environment so that relativistic calculations (light time, clock rates, Shapiro delay, etc.) can be performed.

This method is a convenience constructor. It is useful when you already have a Dt (a time value) and want to build an ObserverState directly from it, rather than calling ObserverState::new or ObserverState::new_strong_field.

Parameters

• position: The observer’s position in meters (typically expressed in a barycentric or heliocentric frame).
• velocity: The observer’s velocity in meters per second.
• grav_potential_m2_s2: The total Newtonian gravitational potential (Φ) at the observer’s location, in m²/s². This is usually negative for bound orbits and is the sum of contributions from the Sun and planets.
• characteristic_length_scale: A length scale (in meters) over which gravity varies significantly at this location. Use 0.0 for normal solar-system and weak-field cases. Only provide a non-zero value when working in strong gravitational fields.

When to use this method

Use this method when you already have a time value as a Dt and want to construct an ObserverState in one step. It is especially convenient when working with time values that were previously computed or converted.

For most normal use, ObserverState::new is simpler. Use ObserverState::new_strong_field instead if you need to specify a non-zero characteristic_length_scale.

Example

let t = Dt::from_sec(1234.5);

let state = t.to_observer_state(
    position,
    velocity,
    grav_potential,
    0.0, // normal solar-system use
);

impl Dt

pub const fn every(self, step: Dt) -> Every

Starts building an evenly-spaced time range.

This method returns an Every builder that can be chained with .until(end) or .up_to(end) to create a TimeRange iterator.

Example

let start = Dt::from_gregorian(2025, 1, 1, 0, 0, 0, 0, Scale::TAI);
let step = Dt::from_hours(1);

// Inclusive range: yields 25 points (including both start and end)
for t in start.every(step).until(end) { ... }

// Exclusive range: yields 24 points
for t in start.every(step).up_to(end) { ... }

pub const fn range_to(self, end: Dt, step: Dt) -> TimeRange

Creates an inclusive evenly-spaced range from self to end.

Equivalent to self.every(step).until(end).

pub const fn range_until(self, end: Dt, step: Dt) -> TimeRange

Creates an exclusive evenly-spaced range from self to end.

Equivalent to self.every(step).up_to(end).

pub const fn every_second(self) -> Every

Creates a range stepping by whole seconds.

pub const fn every_minute(self) -> Every

Creates a range stepping by whole minutes.

pub const fn every_hour(self) -> Every

Creates a range stepping by whole hours.

pub const fn every_day(self) -> Every

Creates a range stepping by whole days.

pub fn next_n(self, n: usize, step: Dt) -> impl Iterator<Item = Dt>

Returns the next n points after self (exclusive of self) at the given step.

This is a convenient way to get future points without including the start.

pub fn for_n_steps(self, n: usize, step: Dt) -> impl Iterator<Item = Dt>

Returns an iterator yielding exactly n evenly spaced points starting from self.

This is a convenient one-liner for the common “next N steps” pattern.

impl Dt

pub const fn leap_seconds(&self, from_civil: bool) -> LeapInfo

pub const fn leap_seconds_using( &self, from_civil: bool, table: &[LeapSecond], ) -> LeapInfo

Trait Implementations

impl Add for Dt

type Output = Dt

The resulting type after applying the + operator.

fn add(self, rhs: Dt) -> Self

Performs the + operation.

impl AddAssign for Dt

fn add_assign(&mut self, rhs: Dt)

Performs the += operation.

impl Clone for Dt

fn clone(&self) -> Dt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dt

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

Formats the value using the given formatter.

impl Default for Dt

fn default() -> Self

Returns the “default value” for a type.

impl Display for Dt

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

Formats the value using the given formatter.

impl Div<i64> for Dt

fn div(self, rhs: i64) -> Self

Divides this Dt by an integer scalar.

type Output = Dt

The resulting type after applying the / operator.

impl DivAssign<i64> for Dt

fn div_assign(&mut self, rhs: i64)

Divides this Dt by an integer scalar in place.

impl Hash for Dt

fn hash<H: Hasher>(&self, state: &mut H)

Hashes the canonical TAI representation so that two Dts that are physically equal (after conversion) produce the same hash, regardless of the original [Scale].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul<i64> for Dt

fn mul(self, rhs: i64) -> Self

Multiplies this Dt by an integer scalar.

type Output = Dt

The resulting type after applying the * operator.

impl MulAssign<i64> for Dt

fn mul_assign(&mut self, rhs: i64)

Multiplies this Dt by an integer scalar in place.

impl Neg for Dt

fn neg(self) -> Self

Negates this Dt (returns the additive inverse).

type Output = Dt

The resulting type after applying the - operator.

impl Ord for Dt

fn cmp(&self, other: &Self) -> 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 Dt

fn eq(&self, other: &Self) -> 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 Dt

fn partial_cmp(&self, other: &Self) -> 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 Sub for Dt

type Output = Dt

The resulting type after applying the - operator.

fn sub(self, rhs: Dt) -> Self

Performs the - operation.

impl SubAssign for Dt

fn sub_assign(&mut self, rhs: Dt)

Performs the -= operation.

impl Copy for Dt

impl Eq for Dt