#[repr(C)]pub struct Epoch {
pub duration_since_j1900_tai: Duration,
pub time_scale: TimeScale,
}
Expand description
Defines a nanosecond-precision Epoch.
Refer to the appropriate functions for initializing this Epoch from different time scales or representations.
Fields§
§duration_since_j1900_tai: Duration
An Epoch is always stored as the duration of since J1900 in the TAI time scale.
time_scale: TimeScale
Time scale used during the initialization of this Epoch.
Implementations§
source§impl Epoch
impl Epoch
sourcepub fn leap_seconds_with<L: LeapSecondProvider>(
&self,
iers_only: bool,
provider: L
) -> Option<f64>
pub fn leap_seconds_with<L: LeapSecondProvider>( &self, iers_only: bool, provider: L ) -> Option<f64>
Get the accumulated number of leap seconds up to this Epoch from the provided LeapSecondProvider. Returns None if the epoch is before 1960, year at which UTC was defined.
Why does this function return an Option
when the other returns a value
This is to match the iauDat
function of SOFA (src/dat.c). That function will return a warning and give up if the start date is before 1960.
sourcepub fn from_duration(new_duration: Duration, time_scale: TimeScale) -> Self
pub fn from_duration(new_duration: Duration, time_scale: TimeScale) -> Self
Makes a copy of self and sets the duration and time scale appropriately given the new duration
sourcepub const fn from_tai_duration(duration: Duration) -> Self
pub const fn from_tai_duration(duration: Duration) -> Self
Creates a new Epoch from a Duration as the time difference between this epoch and TAI reference epoch.
sourcepub fn from_tai_parts(centuries: i16, nanoseconds: u64) -> Self
pub fn from_tai_parts(centuries: i16, nanoseconds: u64) -> Self
Creates a new Epoch from its centuries and nanosecond since the TAI reference epoch.
sourcepub fn from_tai_seconds(seconds: f64) -> Self
pub fn from_tai_seconds(seconds: f64) -> Self
Initialize an Epoch from the provided TAI seconds since 1900 January 01 at midnight
sourcepub fn from_tai_days(days: f64) -> Self
pub fn from_tai_days(days: f64) -> Self
Initialize an Epoch from the provided TAI days since 1900 January 01 at midnight
sourcepub fn from_utc_duration(duration: Duration) -> Self
pub fn from_utc_duration(duration: Duration) -> Self
Initialize an Epoch from the provided UTC seconds since 1900 January 01 at midnight
sourcepub fn from_utc_seconds(seconds: f64) -> Self
pub fn from_utc_seconds(seconds: f64) -> Self
Initialize an Epoch from the provided UTC seconds since 1900 January 01 at midnight
sourcepub fn from_utc_days(days: f64) -> Self
pub fn from_utc_days(days: f64) -> Self
Initialize an Epoch from the provided UTC days since 1900 January 01 at midnight
sourcepub fn from_gpst_duration(duration: Duration) -> Self
pub fn from_gpst_duration(duration: Duration) -> Self
Initialize an Epoch from the provided duration since 1980 January 6 at midnight
sourcepub fn from_gst_duration(duration: Duration) -> Self
pub fn from_gst_duration(duration: Duration) -> Self
Initialize an Epoch from the provided duration since August 21st 1999 midnight
sourcepub fn from_bdt_duration(duration: Duration) -> Self
pub fn from_bdt_duration(duration: Duration) -> Self
Initialize an Epoch from the provided duration since January 1st midnight
pub fn from_mjd_tai(days: f64) -> Self
pub fn from_mjd_utc(days: f64) -> Self
pub fn from_mjd_gpst(days: f64) -> Self
pub fn from_mjd_gst(days: f64) -> Self
pub fn from_mjd_bdt(days: f64) -> Self
pub fn from_jde_tai(days: f64) -> Self
pub fn from_jde_utc(days: f64) -> Self
pub fn from_jde_gpst(days: f64) -> Self
pub fn from_jde_gst(days: f64) -> Self
pub fn from_jde_bdt(days: f64) -> Self
sourcepub fn from_tt_seconds(seconds: f64) -> Self
pub fn from_tt_seconds(seconds: f64) -> Self
Initialize an Epoch from the provided TT seconds (approximated to 32.184s delta from TAI)
sourcepub fn from_tt_duration(duration: Duration) -> Self
pub fn from_tt_duration(duration: Duration) -> Self
Initialize an Epoch from the provided TT seconds (approximated to 32.184s delta from TAI)
sourcepub fn from_et_seconds(seconds_since_j2000: f64) -> Epoch
pub fn from_et_seconds(seconds_since_j2000: f64) -> Epoch
Initialize an Epoch from the Ephemeris Time seconds past 2000 JAN 01 (J2000 reference)
sourcepub fn from_et_duration(duration_since_j2000: Duration) -> Self
pub fn from_et_duration(duration_since_j2000: Duration) -> Self
Initializes an Epoch from the duration between J2000 and the current epoch as per NAIF SPICE.
Limitation
This method uses a Newton Raphson iteration to find the appropriate TAI duration. This method is only accuracy to a few nanoseconds.
Hence, when calling as_et_duration()
and re-initializing it with from_et_duration
you may have a few nanoseconds of difference (expect less than 10 ns).
Warning
The et2utc function of NAIF SPICE will assume that there are 9 leap seconds before 01 JAN 1972, as this date introduces 10 leap seconds. At the time of writing, this does not seem to be in line with IERS and the documentation in the leap seconds list.
In order to match SPICE, the as_et_duration() function will manually get rid of that difference.
sourcepub fn from_tdb_seconds(seconds_j2000: f64) -> Epoch
pub fn from_tdb_seconds(seconds_j2000: f64) -> Epoch
Initialize an Epoch from Dynamic Barycentric Time (TDB) seconds past 2000 JAN 01 midnight (difference than SPICE) NOTE: This uses the ESA algorithm, which is a notch more complicated than the SPICE algorithm, but more precise. In fact, SPICE algorithm is precise +/- 30 microseconds for a century whereas ESA algorithm should be exactly correct.
sourcepub fn from_tdb_duration(duration_since_j2000: Duration) -> Epoch
pub fn from_tdb_duration(duration_since_j2000: Duration) -> Epoch
Initialize from Dynamic Barycentric Time (TDB) (same as SPICE ephemeris time) whose epoch is 2000 JAN 01 noon TAI.
sourcepub fn from_jde_et(days: f64) -> Self
pub fn from_jde_et(days: f64) -> Self
Initialize from the JDE days
sourcepub fn from_jde_tdb(days: f64) -> Self
pub fn from_jde_tdb(days: f64) -> Self
Initialize from Dynamic Barycentric Time (TDB) (same as SPICE ephemeris time) in JD days
sourcepub fn from_gpst_seconds(seconds: f64) -> Self
pub fn from_gpst_seconds(seconds: f64) -> Self
Initialize an Epoch from the number of seconds since the GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29).
sourcepub fn from_gpst_days(days: f64) -> Self
pub fn from_gpst_days(days: f64) -> Self
Initialize an Epoch from the number of days since the GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29).
sourcepub fn from_gpst_nanoseconds(nanoseconds: u64) -> Self
pub fn from_gpst_nanoseconds(nanoseconds: u64) -> Self
Initialize an Epoch from the number of nanoseconds since the GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29). This may be useful for time keeping devices that use GPS as a time source.
sourcepub fn from_gst_seconds(seconds: f64) -> Self
pub fn from_gst_seconds(seconds: f64) -> Self
Initialize an Epoch from the number of seconds since the GST Time Epoch, starting August 21st 1999 midnight (UTC) (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS).
sourcepub fn from_gst_days(days: f64) -> Self
pub fn from_gst_days(days: f64) -> Self
Initialize an Epoch from the number of days since the GST Time Epoch, starting August 21st 1999 midnight (UTC) (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS)
sourcepub fn from_gst_nanoseconds(nanoseconds: u64) -> Self
pub fn from_gst_nanoseconds(nanoseconds: u64) -> Self
Initialize an Epoch from the number of nanoseconds since the GPS Time Epoch, starting August 21st 1999 midnight (UTC) (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS)
sourcepub fn from_bdt_seconds(seconds: f64) -> Self
pub fn from_bdt_seconds(seconds: f64) -> Self
Initialize an Epoch from the number of seconds since the BDT Time Epoch, starting on January 1st 2006 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS)
sourcepub fn from_bdt_days(days: f64) -> Self
pub fn from_bdt_days(days: f64) -> Self
Initialize an Epoch from the number of days since the BDT Time Epoch, starting on January 1st 2006 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS)
sourcepub fn from_bdt_nanoseconds(nanoseconds: u64) -> Self
pub fn from_bdt_nanoseconds(nanoseconds: u64) -> Self
Initialize an Epoch from the number of nanoseconds since the BDT Time Epoch, starting on January 1st 2006 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS). This may be useful for time keeping devices that use BDT as a time source.
sourcepub fn from_unix_duration(duration: Duration) -> Self
pub fn from_unix_duration(duration: Duration) -> Self
Initialize an Epoch from the provided duration since UTC midnight 1970 January 01.
sourcepub fn from_unix_seconds(seconds: f64) -> Self
pub fn from_unix_seconds(seconds: f64) -> Self
Initialize an Epoch from the provided UNIX second timestamp since UTC midnight 1970 January 01.
sourcepub fn from_unix_milliseconds(millisecond: f64) -> Self
pub fn from_unix_milliseconds(millisecond: f64) -> Self
Initialize an Epoch from the provided UNIX millisecond timestamp since UTC midnight 1970 January 01.
sourcepub fn maybe_from_gregorian_tai(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32
) -> Result<Self, Errors>
pub fn maybe_from_gregorian_tai( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32 ) -> Result<Self, Errors>
Attempts to build an Epoch from the provided Gregorian date and time in TAI.
sourcepub fn maybe_from_gregorian(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32,
time_scale: TimeScale
) -> Result<Self, Errors>
pub fn maybe_from_gregorian( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32, time_scale: TimeScale ) -> Result<Self, Errors>
Attempts to build an Epoch from the provided Gregorian date and time in the provided time scale. NOTE: If the time scale is TDB, this function assumes that the SPICE format is used
sourcepub fn from_gregorian_tai(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32
) -> Self
pub fn from_gregorian_tai( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32 ) -> Self
Builds an Epoch from the provided Gregorian date and time in TAI. If invalid date is provided, this function will panic. Use maybe_from_gregorian_tai if unsure.
sourcepub fn from_gregorian_tai_at_midnight(year: i32, month: u8, day: u8) -> Self
pub fn from_gregorian_tai_at_midnight(year: i32, month: u8, day: u8) -> Self
Initialize from the Gregorian date at midnight in TAI.
sourcepub fn from_gregorian_tai_at_noon(year: i32, month: u8, day: u8) -> Self
pub fn from_gregorian_tai_at_noon(year: i32, month: u8, day: u8) -> Self
Initialize from the Gregorian date at noon in TAI
sourcepub fn from_gregorian_tai_hms(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8
) -> Self
pub fn from_gregorian_tai_hms( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8 ) -> Self
Initialize from the Gregorian date and time (without the nanoseconds) in TAI
sourcepub fn maybe_from_gregorian_utc(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32
) -> Result<Self, Errors>
pub fn maybe_from_gregorian_utc( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32 ) -> Result<Self, Errors>
Attempts to build an Epoch from the provided Gregorian date and time in UTC.
sourcepub fn from_gregorian_utc(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32
) -> Self
pub fn from_gregorian_utc( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32 ) -> Self
Builds an Epoch from the provided Gregorian date and time in UTC. If invalid date is provided, this function will panic. Use maybe_from_gregorian_utc if unsure.
sourcepub fn from_gregorian_utc_at_midnight(year: i32, month: u8, day: u8) -> Self
pub fn from_gregorian_utc_at_midnight(year: i32, month: u8, day: u8) -> Self
Initialize from Gregorian date in UTC at midnight
sourcepub fn from_gregorian_utc_at_noon(year: i32, month: u8, day: u8) -> Self
pub fn from_gregorian_utc_at_noon(year: i32, month: u8, day: u8) -> Self
Initialize from Gregorian date in UTC at noon
sourcepub fn from_gregorian_utc_hms(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8
) -> Self
pub fn from_gregorian_utc_hms( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8 ) -> Self
Initialize from the Gregorian date and time (without the nanoseconds) in UTC
sourcepub fn from_gregorian(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
nanos: u32,
time_scale: TimeScale
) -> Self
pub fn from_gregorian( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, nanos: u32, time_scale: TimeScale ) -> Self
Builds an Epoch from the provided Gregorian date and time in the provided time scale. If invalid date is provided, this function will panic. Use maybe_from_gregorian if unsure.
sourcepub fn from_gregorian_at_midnight(
year: i32,
month: u8,
day: u8,
time_scale: TimeScale
) -> Self
pub fn from_gregorian_at_midnight( year: i32, month: u8, day: u8, time_scale: TimeScale ) -> Self
Initialize from Gregorian date in UTC at midnight
sourcepub fn from_gregorian_at_noon(
year: i32,
month: u8,
day: u8,
time_scale: TimeScale
) -> Self
pub fn from_gregorian_at_noon( year: i32, month: u8, day: u8, time_scale: TimeScale ) -> Self
Initialize from Gregorian date in UTC at noon
sourcepub fn from_gregorian_hms(
year: i32,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
time_scale: TimeScale
) -> Self
pub fn from_gregorian_hms( year: i32, month: u8, day: u8, hour: u8, minute: u8, second: u8, time_scale: TimeScale ) -> Self
Initialize from the Gregorian date and time (without the nanoseconds) in UTC
sourcepub fn from_gregorian_str(s_in: &str) -> Result<Self, Errors>
pub fn from_gregorian_str(s_in: &str) -> Result<Self, Errors>
Converts a Gregorian date time in ISO8601 or RFC3339 format into an Epoch, accounting for the time zone designator and the time scale.
Definition
- Time Zone Designator: this is either a
Z
(lower or upper case) to specify UTC, or an offset in hours and minutes off of UTC, such as+01:00
for UTC plus one hour and zero minutes. - Time system (or time “scale”): UTC, TT, TAI, TDB, ET, etc.
Converts an ISO8601 or RFC3339 datetime representation to an Epoch.
If no time scale is specified, then UTC is assumed.
A time scale may be specified in addition to the format unless
The T
which separates the date from the time can be replaced with a single whitespace character (\W
).
The offset is also optional, cf. the examples below.
Example
use hifitime::Epoch;
let dt = Epoch::from_gregorian_utc(2017, 1, 14, 0, 31, 55, 0);
assert_eq!(
dt,
Epoch::from_gregorian_str("2017-01-14T00:31:55 UTC").unwrap()
);
assert_eq!(
dt,
Epoch::from_gregorian_str("2017-01-14T00:31:55.0000 UTC").unwrap()
);
assert_eq!(
dt,
Epoch::from_gregorian_str("2017-01-14T00:31:55").unwrap()
);
assert_eq!(
dt,
Epoch::from_gregorian_str("2017-01-14 00:31:55").unwrap()
);
// Regression test for #90
assert_eq!(
Epoch::from_gregorian_utc(2017, 1, 14, 0, 31, 55, 811000000),
Epoch::from_gregorian_str("2017-01-14 00:31:55.811 UTC").unwrap()
);
assert_eq!(
Epoch::from_gregorian_utc(2017, 1, 14, 0, 31, 55, 811200000),
Epoch::from_gregorian_str("2017-01-14 00:31:55.8112 UTC").unwrap()
);
// Example from https://www.w3.org/TR/NOTE-datetime
assert_eq!(
Epoch::from_gregorian_utc_hms(1994, 11, 5, 13, 15, 30),
Epoch::from_gregorian_str("1994-11-05T13:15:30Z").unwrap()
);
assert_eq!(
Epoch::from_gregorian_utc_hms(1994, 11, 5, 13, 15, 30),
Epoch::from_gregorian_str("1994-11-05T08:15:30-05:00").unwrap()
);
sourcepub fn from_str_with_format(s_in: &str, format: Format) -> Result<Self, Errors>
pub fn from_str_with_format(s_in: &str, format: Format) -> Result<Self, Errors>
Initializes an Epoch from the provided Format.
sourcepub fn from_format_str(s_in: &str, format_str: &str) -> Result<Self, Errors>
pub fn from_format_str(s_in: &str, format_str: &str) -> Result<Self, Errors>
Initializes an Epoch from the Format as a string.
sourcepub fn from_time_of_week(
week: u32,
nanoseconds: u64,
time_scale: TimeScale
) -> Self
pub fn from_time_of_week( week: u32, nanoseconds: u64, time_scale: TimeScale ) -> Self
Builds an Epoch from given week
: elapsed weeks counter into the desired Time scale, and the amount of nanoseconds within that week.
For example, this is how GPS vehicles describe a GPST epoch.
Note that this constructor relies on 128 bit integer math and may be slow on embedded devices.
sourcepub fn from_time_of_week_utc(week: u32, nanoseconds: u64) -> Self
pub fn from_time_of_week_utc(week: u32, nanoseconds: u64) -> Self
Builds a UTC Epoch from given week
: elapsed weeks counter and “ns” amount of nanoseconds since closest Sunday Midnight.
sourcepub fn from_day_of_year(year: i32, days: f64, time_scale: TimeScale) -> Self
pub fn from_day_of_year(year: i32, days: f64, time_scale: TimeScale) -> Self
Builds an Epoch from the provided year, days in the year, and a time scale.
Limitations
In the TDB or ET time scales, there may be an error of up to 750 nanoseconds when initializing an Epoch this way. This is because we first initialize the epoch in Gregorian scale and then apply the TDB/ET offset, but that offset actually depends on the precise time.
Day couting behavior
The day counter starts at 01, in other words, 01 January is day 1 of the counter, as per the GPS specificiations.
source§impl Epoch
impl Epoch
sourcepub fn leap_seconds_iers(&self) -> i32
pub fn leap_seconds_iers(&self) -> i32
Get the accumulated number of leap seconds up to this Epoch accounting only for the IERS leap seconds.
sourcepub fn leap_seconds(&self, iers_only: bool) -> Option<f64>
pub fn leap_seconds(&self, iers_only: bool) -> Option<f64>
Get the accumulated number of leap seconds up to this Epoch accounting only for the IERS leap seconds and the SOFA scaling from 1960 to 1972, depending on flag. Returns None if the epoch is before 1960, year at which UTC was defined.
Why does this function return an Option
when the other returns a value
This is to match the iauDat
function of SOFA (src/dat.c). That function will return a warning and give up if the start date is before 1960.
sourcepub fn to_isoformat(&self) -> String
pub fn to_isoformat(&self) -> String
The standard ISO format of this epoch (six digits of subseconds), refer to https://docs.rs/hifitime/latest/hifitime/efmt/format/struct.Format.html for format options
sourcepub fn to_duration(&self) -> Duration
pub fn to_duration(&self) -> Duration
Returns this epoch with respect to the time scale this epoch was created in. This is needed to correctly perform duration conversions in dynamical time scales (e.g. TDB).
Examples
- If an epoch was initialized as Epoch::from_…_utc(…) then the duration will be the UTC duration from J1900.
- If an epoch was initialized as Epoch::from_…_tdb(…) then the duration will be the UTC duration from J2000 because the TDB reference epoch is J2000.
sourcepub fn to_duration_in_time_scale(&self, time_scale: TimeScale) -> Duration
pub fn to_duration_in_time_scale(&self, time_scale: TimeScale) -> Duration
Returns this epoch with respect to the provided time scale. This is needed to correctly perform duration conversions in dynamical time scales (e.g. TDB).
sourcepub fn to_duration_since_j1900(&self) -> Duration
pub fn to_duration_since_j1900(&self) -> Duration
Returns this epoch in duration since J1900 in the time scale this epoch was created in.
sourcepub fn to_duration_since_j1900_in_time_scale(
&self,
time_scale: TimeScale
) -> Duration
pub fn to_duration_since_j1900_in_time_scale( &self, time_scale: TimeScale ) -> Duration
Returns this epoch in duration since J1900 with respect to the provided time scale.
sourcepub fn set(&self, new_duration: Duration) -> Self
pub fn set(&self, new_duration: Duration) -> Self
Makes a copy of self and sets the duration and time scale appropriately given the new duration
sourcepub fn to_tai_seconds(&self) -> f64
pub fn to_tai_seconds(&self) -> f64
Returns the number of TAI seconds since J1900
sourcepub const fn to_tai_duration(&self) -> Duration
pub const fn to_tai_duration(&self) -> Duration
Returns this time in a Duration past J1900 counted in TAI
sourcepub fn to_tai(&self, unit: Unit) -> f64
pub fn to_tai(&self, unit: Unit) -> f64
Returns the epoch as a floating point value in the provided unit
sourcepub const fn to_tai_parts(&self) -> (i16, u64)
pub const fn to_tai_parts(&self) -> (i16, u64)
Returns the TAI parts of this duration
sourcepub fn to_tai_days(&self) -> f64
pub fn to_tai_days(&self) -> f64
Returns the number of days since J1900 in TAI
sourcepub fn to_utc_seconds(&self) -> f64
pub fn to_utc_seconds(&self) -> f64
Returns the number of UTC seconds since the TAI epoch
sourcepub fn to_utc_duration(&self) -> Duration
pub fn to_utc_duration(&self) -> Duration
Returns this time in a Duration past J1900 counted in UTC
sourcepub fn to_utc_days(&self) -> f64
pub fn to_utc_days(&self) -> f64
Returns the number of UTC days since the TAI epoch
sourcepub fn to_mjd_tai_days(&self) -> f64
pub fn to_mjd_tai_days(&self) -> f64
as_mjd_days
creates an Epoch from the provided Modified Julian Date in days as explained
here. MJD epoch is Modified Julian Day at 17 November 1858 at midnight.
sourcepub fn to_mjd_tai_seconds(&self) -> f64
pub fn to_mjd_tai_seconds(&self) -> f64
Returns the Modified Julian Date in seconds TAI.
sourcepub fn to_mjd_tai(&self, unit: Unit) -> f64
pub fn to_mjd_tai(&self, unit: Unit) -> f64
Returns this epoch as a duration in the requested units in MJD TAI
sourcepub fn to_mjd_utc_days(&self) -> f64
pub fn to_mjd_utc_days(&self) -> f64
Returns the Modified Julian Date in days UTC.
sourcepub fn to_mjd_utc(&self, unit: Unit) -> f64
pub fn to_mjd_utc(&self, unit: Unit) -> f64
Returns the Modified Julian Date in the provided unit in UTC.
sourcepub fn to_mjd_utc_seconds(&self) -> f64
pub fn to_mjd_utc_seconds(&self) -> f64
Returns the Modified Julian Date in seconds UTC.
sourcepub fn to_jde_tai_days(&self) -> f64
pub fn to_jde_tai_days(&self) -> f64
Returns the Julian days from epoch 01 Jan -4713, 12:00 (noon) as explained in “Fundamentals of astrodynamics and applications”, Vallado et al. 4th edition, page 182, and on Wikipedia.
sourcepub fn to_jde_tai(&self, unit: Unit) -> f64
pub fn to_jde_tai(&self, unit: Unit) -> f64
Returns the Julian Days from epoch 01 Jan -4713 12:00 (noon) in desired Duration::Unit
sourcepub fn to_jde_tai_duration(&self) -> Duration
pub fn to_jde_tai_duration(&self) -> Duration
Returns the Julian Days from epoch 01 Jan -4713 12:00 (noon) as a Duration
sourcepub fn to_jde_tai_seconds(&self) -> f64
pub fn to_jde_tai_seconds(&self) -> f64
Returns the Julian seconds in TAI.
sourcepub fn to_jde_utc_days(&self) -> f64
pub fn to_jde_utc_days(&self) -> f64
Returns the Julian days in UTC.
sourcepub fn to_jde_utc_duration(&self) -> Duration
pub fn to_jde_utc_duration(&self) -> Duration
Returns the Julian days in UTC as a Duration
sourcepub fn to_jde_utc_seconds(&self) -> f64
pub fn to_jde_utc_seconds(&self) -> f64
Returns the Julian Days in UTC seconds.
sourcepub fn to_tt_seconds(&self) -> f64
pub fn to_tt_seconds(&self) -> f64
Returns seconds past TAI epoch in Terrestrial Time (TT) (previously called Terrestrial Dynamical Time (TDT))
sourcepub fn to_tt_duration(&self) -> Duration
pub fn to_tt_duration(&self) -> Duration
Returns Duration
past TAI epoch in Terrestrial Time (TT).
sourcepub fn to_tt_days(&self) -> f64
pub fn to_tt_days(&self) -> f64
Returns days past TAI epoch in Terrestrial Time (TT) (previously called Terrestrial Dynamical Time (TDT))
sourcepub fn to_tt_centuries_j2k(&self) -> f64
pub fn to_tt_centuries_j2k(&self) -> f64
Returns the centuries passed J2000 TT
sourcepub fn to_tt_since_j2k(&self) -> Duration
pub fn to_tt_since_j2k(&self) -> Duration
Returns the duration past J2000 TT
sourcepub fn to_jde_tt_days(&self) -> f64
pub fn to_jde_tt_days(&self) -> f64
Returns days past Julian epoch in Terrestrial Time (TT) (previously called Terrestrial Dynamical Time (TDT))
pub fn to_jde_tt_duration(&self) -> Duration
sourcepub fn to_mjd_tt_days(&self) -> f64
pub fn to_mjd_tt_days(&self) -> f64
Returns days past Modified Julian epoch in Terrestrial Time (TT) (previously called Terrestrial Dynamical Time (TDT))
pub fn to_mjd_tt_duration(&self) -> Duration
sourcepub fn to_gpst_seconds(&self) -> f64
pub fn to_gpst_seconds(&self) -> f64
Returns seconds past GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29).
sourcepub fn to_gpst_duration(&self) -> Duration
pub fn to_gpst_duration(&self) -> Duration
Returns Duration
past GPS time Epoch.
sourcepub fn to_gpst_nanoseconds(&self) -> Result<u64, Errors>
pub fn to_gpst_nanoseconds(&self) -> Result<u64, Errors>
Returns nanoseconds past GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29). NOTE: This function will return an error if the centuries past GPST time are not zero.
sourcepub fn to_gpst_days(&self) -> f64
pub fn to_gpst_days(&self) -> f64
Returns days past GPS Time Epoch, defined as UTC midnight of January 5th to 6th 1980 (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS#GPS_Time_.28GPST.29).
sourcepub fn to_gst_seconds(&self) -> f64
pub fn to_gst_seconds(&self) -> f64
Returns seconds past GST (Galileo) Time Epoch
sourcepub fn to_gst_duration(&self) -> Duration
pub fn to_gst_duration(&self) -> Duration
Returns Duration
past GST (Galileo) time Epoch.
sourcepub fn to_gst_days(&self) -> f64
pub fn to_gst_days(&self) -> f64
Returns days past GST (Galileo) Time Epoch, starting on August 21st 1999 Midnight UT (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS).
sourcepub fn to_gst_nanoseconds(&self) -> Result<u64, Errors>
pub fn to_gst_nanoseconds(&self) -> Result<u64, Errors>
Returns nanoseconds past GST (Galileo) Time Epoch, starting on August 21st 1999 Midnight UT (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS). NOTE: This function will return an error if the centuries past GST time are not zero.
sourcepub fn to_bdt_seconds(&self) -> f64
pub fn to_bdt_seconds(&self) -> f64
Returns seconds past BDT (BeiDou) Time Epoch
sourcepub fn to_bdt_duration(&self) -> Duration
pub fn to_bdt_duration(&self) -> Duration
Returns Duration
past BDT (BeiDou) time Epoch.
sourcepub fn to_bdt_days(&self) -> f64
pub fn to_bdt_days(&self) -> f64
Returns days past BDT (BeiDou) Time Epoch, defined as Jan 01 2006 UTC (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS).
sourcepub fn to_bdt_nanoseconds(&self) -> Result<u64, Errors>
pub fn to_bdt_nanoseconds(&self) -> Result<u64, Errors>
Returns nanoseconds past BDT (BeiDou) Time Epoch, defined as Jan 01 2006 UTC (cf. https://gssc.esa.int/navipedia/index.php/Time_References_in_GNSS). NOTE: This function will return an error if the centuries past GST time are not zero.
sourcepub fn to_unix(&self, unit: Unit) -> f64
pub fn to_unix(&self, unit: Unit) -> f64
Returns the duration since the UNIX epoch in the provided unit.
sourcepub fn to_unix_seconds(&self) -> f64
pub fn to_unix_seconds(&self) -> f64
Returns the number seconds since the UNIX epoch defined 01 Jan 1970 midnight UTC.
sourcepub fn to_unix_milliseconds(&self) -> f64
pub fn to_unix_milliseconds(&self) -> f64
Returns the number milliseconds since the UNIX epoch defined 01 Jan 1970 midnight UTC.
sourcepub fn to_unix_days(&self) -> f64
pub fn to_unix_days(&self) -> f64
Returns the number days since the UNIX epoch defined 01 Jan 1970 midnight UTC.
sourcepub fn to_et_seconds(&self) -> f64
pub fn to_et_seconds(&self) -> f64
Returns the Ephemeris Time seconds past 2000 JAN 01 midnight, matches NASA/NAIF SPICE.
sourcepub fn to_et_duration_since_j1900(&self) -> Duration
pub fn to_et_duration_since_j1900(&self) -> Duration
Returns the Ephemeris Time in duration past 1900 JAN 01 at noon. Only use this if the subsequent computation expect J1900 seconds.
sourcepub fn to_et_duration(&self) -> Duration
pub fn to_et_duration(&self) -> Duration
Returns the duration between J2000 and the current epoch as per NAIF SPICE.
Warning
The et2utc function of NAIF SPICE will assume that there are 9 leap seconds before 01 JAN 1972, as this date introduces 10 leap seconds. At the time of writing, this does not seem to be in line with IERS and the documentation in the leap seconds list.
In order to match SPICE, the as_et_duration() function will manually get rid of that difference.
sourcepub fn to_tdb_duration(&self) -> Duration
pub fn to_tdb_duration(&self) -> Duration
Returns the Dynamics Barycentric Time (TDB) as a high precision Duration since J2000
Algorithm
Given the embedded sine functions in the equation to compute the difference between TDB and TAI from the number of TDB seconds past J2000, one cannot solve the revert the operation analytically. Instead, we iterate until the value no longer changes.
- Assume that the TAI duration is in fact the TDB seconds from J2000.
- Offset to J2000 because
Epoch
stores everything in the J1900 but the TDB duration is in J2000. - Compute the offset
g
due to the TDB computation with the current value of the TDB seconds (defined in step 1). - Subtract that offset to the latest TDB seconds and store this as a new candidate for the true TDB seconds value.
- Compute the difference between this candidate and the previous one. If the difference is less than one nanosecond, stop iteration.
- Set the new candidate as the TDB seconds since J2000 and loop until step 5 breaks the loop, or we’ve done five iterations.
- At this stage, we have a good approximation of the TDB seconds since J2000.
- Reverse the algorithm given that approximation: compute the
g
offset, compute the difference between TDB and TAI, add the TT offset (32.184 s), and offset by the difference between J1900 and J2000.
sourcepub fn to_tdb_seconds(&self) -> f64
pub fn to_tdb_seconds(&self) -> f64
Returns the Dynamic Barycentric Time (TDB) (higher fidelity SPICE ephemeris time) whose epoch is 2000 JAN 01 noon TAI (cf. https://gssc.esa.int/navipedia/index.php/Transformations_between_Time_Systems#TDT_-_TDB.2C_TCB)
sourcepub fn to_tdb_duration_since_j1900(&self) -> Duration
pub fn to_tdb_duration_since_j1900(&self) -> Duration
Returns the Dynamics Barycentric Time (TDB) as a high precision Duration with reference epoch of 1900 JAN 01 at noon. Only use this if the subsequent computation expect J1900 seconds.
sourcepub fn to_jde_et_days(&self) -> f64
pub fn to_jde_et_days(&self) -> f64
Returns the Ephemeris Time JDE past epoch
pub fn to_jde_et_duration(&self) -> Duration
pub fn to_jde_et(&self, unit: Unit) -> f64
pub fn to_jde_tdb_duration(&self) -> Duration
sourcepub fn to_jde_tdb_days(&self) -> f64
pub fn to_jde_tdb_days(&self) -> f64
Returns the Dynamic Barycentric Time (TDB) (higher fidelity SPICE ephemeris time) whose epoch is 2000 JAN 01 noon TAI (cf. https://gssc.esa.int/navipedia/index.php/Transformations_between_Time_Systems#TDT_-_TDB.2C_TCB)
sourcepub fn to_tdb_days_since_j2000(&self) -> f64
pub fn to_tdb_days_since_j2000(&self) -> f64
Returns the number of days since Dynamic Barycentric Time (TDB) J2000 (used for Archinal et al. rotations)
sourcepub fn to_tdb_centuries_since_j2000(&self) -> f64
pub fn to_tdb_centuries_since_j2000(&self) -> f64
Returns the number of centuries since Dynamic Barycentric Time (TDB) J2000 (used for Archinal et al. rotations)
sourcepub fn to_et_days_since_j2000(&self) -> f64
pub fn to_et_days_since_j2000(&self) -> f64
Returns the number of days since Ephemeris Time (ET) J2000 (used for Archinal et al. rotations)
sourcepub fn to_et_centuries_since_j2000(&self) -> f64
pub fn to_et_centuries_since_j2000(&self) -> f64
Returns the number of centuries since Ephemeris Time (ET) J2000 (used for Archinal et al. rotations)
sourcepub fn to_gregorian_utc(&self) -> (i32, u8, u8, u8, u8, u8, u32)
pub fn to_gregorian_utc(&self) -> (i32, u8, u8, u8, u8, u8, u32)
Converts the Epoch to the Gregorian UTC equivalent as (year, month, day, hour, minute, second). WARNING: Nanoseconds are lost in this conversion!
Example
use hifitime::Epoch;
let dt = Epoch::from_tai_parts(1, 537582752000000000);
// With the std feature, you may use FromStr as such
// let dt_str = "2017-01-14T00:31:55 UTC";
// let dt = Epoch::from_gregorian_str(dt_str).unwrap()
let (y, m, d, h, min, s, _) = dt.as_gregorian_utc();
assert_eq!(y, 2017);
assert_eq!(m, 1);
assert_eq!(d, 14);
assert_eq!(h, 0);
assert_eq!(min, 31);
assert_eq!(s, 55);
#[cfg(feature = "std")]
assert_eq!("2017-01-14T00:31:55 UTC", dt.as_gregorian_utc_str().to_owned());
sourcepub fn to_gregorian_tai(&self) -> (i32, u8, u8, u8, u8, u8, u32)
pub fn to_gregorian_tai(&self) -> (i32, u8, u8, u8, u8, u8, u32)
Converts the Epoch to the Gregorian TAI equivalent as (year, month, day, hour, minute, second). WARNING: Nanoseconds are lost in this conversion!
Example
use hifitime::Epoch;
let dt = Epoch::from_gregorian_tai_at_midnight(1972, 1, 1);
let (y, m, d, h, min, s, _) = dt.to_gregorian_tai();
assert_eq!(y, 1972);
assert_eq!(m, 1);
assert_eq!(d, 1);
assert_eq!(h, 0);
assert_eq!(min, 0);
assert_eq!(s, 0);
sourcepub fn floor(&self, duration: Duration) -> Self
pub fn floor(&self, duration: Duration) -> Self
Floors this epoch to the closest provided duration
Example
use hifitime::{Epoch, TimeUnits};
let e = Epoch::from_gregorian_tai_hms(2022, 5, 20, 17, 57, 43);
assert_eq!(
e.floor(1.hours()),
Epoch::from_gregorian_tai_hms(2022, 5, 20, 17, 0, 0)
);
let e = Epoch::from_gregorian_tai(2022, 10, 3, 17, 44, 29, 898032665);
assert_eq!(
e.floor(3.minutes()),
Epoch::from_gregorian_tai_hms(2022, 10, 3, 17, 42, 0)
);
sourcepub fn ceil(&self, duration: Duration) -> Self
pub fn ceil(&self, duration: Duration) -> Self
Ceils this epoch to the closest provided duration in the TAI time scale
Example
use hifitime::{Epoch, TimeUnits};
let e = Epoch::from_gregorian_tai_hms(2022, 5, 20, 17, 57, 43);
assert_eq!(
e.ceil(1.hours()),
Epoch::from_gregorian_tai_hms(2022, 5, 20, 18, 0, 0)
);
// 45 minutes is a multiple of 3 minutes, hence this result
let e = Epoch::from_gregorian_tai(2022, 10, 3, 17, 44, 29, 898032665);
assert_eq!(
e.ceil(3.minutes()),
Epoch::from_gregorian_tai_hms(2022, 10, 3, 17, 45, 0)
);
sourcepub fn round(&self, duration: Duration) -> Self
pub fn round(&self, duration: Duration) -> Self
Rounds this epoch to the closest provided duration in TAI
Example
use hifitime::{Epoch, TimeUnits};
let e = Epoch::from_gregorian_tai_hms(2022, 5, 20, 17, 57, 43);
assert_eq!(
e.round(1.hours()),
Epoch::from_gregorian_tai_hms(2022, 5, 20, 18, 0, 0)
);
sourcepub fn in_time_scale(&self, new_time_scale: TimeScale) -> Self
pub fn in_time_scale(&self, new_time_scale: TimeScale) -> Self
Copies this epoch and sets it to the new time scale provided.
sourcepub fn to_time_of_week(&self) -> (u32, u64)
pub fn to_time_of_week(&self) -> (u32, u64)
Converts this epoch into the time of week, represented as a rolling week counter into that time scale and the number of nanoseconds elapsed in current week (since closest Sunday midnight). This is usually how GNSS receivers describe a timestamp.
sourcepub fn weekday_in_time_scale(&self, time_scale: TimeScale) -> Weekday
pub fn weekday_in_time_scale(&self, time_scale: TimeScale) -> Weekday
Returns the weekday in provided time scale ASSUMING that the reference epoch of that time scale is a Monday.
You probably do not want to use this. You probably either want weekday()
or weekday_utc()
.
Several time scales do not have a reference day that’s on a Monday, e.g. BDT.
sourcepub fn weekday(&self) -> Weekday
pub fn weekday(&self) -> Weekday
Returns weekday (uses the TAI representation for this calculation).
sourcepub fn weekday_utc(&self) -> Weekday
pub fn weekday_utc(&self) -> Weekday
Returns weekday in UTC timescale
sourcepub fn next(&self, weekday: Weekday) -> Self
pub fn next(&self, weekday: Weekday) -> Self
Returns the next weekday.
use hifitime::prelude::*;
let epoch = Epoch::from_gregorian_utc_at_midnight(1988, 1, 2);
assert_eq!(epoch.weekday_utc(), Weekday::Saturday);
assert_eq!(epoch.next(Weekday::Sunday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 3));
assert_eq!(epoch.next(Weekday::Monday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 4));
assert_eq!(epoch.next(Weekday::Tuesday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 5));
assert_eq!(epoch.next(Weekday::Wednesday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 6));
assert_eq!(epoch.next(Weekday::Thursday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 7));
assert_eq!(epoch.next(Weekday::Friday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 8));
assert_eq!(epoch.next(Weekday::Saturday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 9));
pub fn next_weekday_at_midnight(&self, weekday: Weekday) -> Self
pub fn next_weekday_at_noon(&self, weekday: Weekday) -> Self
sourcepub fn previous(&self, weekday: Weekday) -> Self
pub fn previous(&self, weekday: Weekday) -> Self
Returns the next weekday.
use hifitime::prelude::*;
let epoch = Epoch::from_gregorian_utc_at_midnight(1988, 1, 2);
assert_eq!(epoch.previous(Weekday::Friday), Epoch::from_gregorian_utc_at_midnight(1988, 1, 1));
assert_eq!(epoch.previous(Weekday::Thursday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 31));
assert_eq!(epoch.previous(Weekday::Wednesday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 30));
assert_eq!(epoch.previous(Weekday::Tuesday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 29));
assert_eq!(epoch.previous(Weekday::Monday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 28));
assert_eq!(epoch.previous(Weekday::Sunday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 27));
assert_eq!(epoch.previous(Weekday::Saturday), Epoch::from_gregorian_utc_at_midnight(1987, 12, 26));
pub fn previous_weekday_at_midnight(&self, weekday: Weekday) -> Self
pub fn previous_weekday_at_noon(&self, weekday: Weekday) -> Self
sourcepub fn duration_in_year(&self) -> Duration
pub fn duration_in_year(&self) -> Duration
Returns the duration since the start of the year
sourcepub fn day_of_year(&self) -> f64
pub fn day_of_year(&self) -> f64
Returns the number of days since the start of the year.
sourcepub fn year(&self) -> i32
pub fn year(&self) -> i32
Returns the number of Gregorian years of this epoch in the current time scale.
sourcepub fn year_days_of_year(&self) -> (i32, f64)
pub fn year_days_of_year(&self) -> (i32, f64)
Returns the year and the days in the year so far (days of year).
sourcepub fn hours(&self) -> u64
pub fn hours(&self) -> u64
Returns the hours of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn minutes(&self) -> u64
pub fn minutes(&self) -> u64
Returns the minutes of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn seconds(&self) -> u64
pub fn seconds(&self) -> u64
Returns the seconds of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn milliseconds(&self) -> u64
pub fn milliseconds(&self) -> u64
Returns the milliseconds of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn microseconds(&self) -> u64
pub fn microseconds(&self) -> u64
Returns the microseconds of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn nanoseconds(&self) -> u64
pub fn nanoseconds(&self) -> u64
Returns the nanoseconds of the Gregorian representation of this epoch in the time scale it was initialized in.
sourcepub fn with_hms(&self, hours: u64, minutes: u64, seconds: u64) -> Self
pub fn with_hms(&self, hours: u64, minutes: u64, seconds: u64) -> Self
Returns a copy of self where the time is set to the provided hours, minutes, seconds Invalid number of hours, minutes, and seconds will overflow into their higher unit. Warning: this does not set the subdivisions of second to zero.
sourcepub fn with_hms_from(&self, other: Self) -> Self
pub fn with_hms_from(&self, other: Self) -> Self
Returns a copy of self where the hours, minutes, seconds is set to the time of the provided epoch but the sub-second parts are kept from the current epoch.
use hifitime::prelude::*;
let epoch = Epoch::from_gregorian_utc(2022, 12, 01, 10, 11, 12, 13);
let other_utc = Epoch::from_gregorian_utc(2024, 12, 01, 20, 21, 22, 23);
let other = other_utc.in_time_scale(TimeScale::TDB);
assert_eq!(
epoch.with_hms_from(other),
Epoch::from_gregorian_utc(2022, 12, 01, 20, 21, 22, 13)
);
sourcepub fn with_time_from(&self, other: Self) -> Self
pub fn with_time_from(&self, other: Self) -> Self
Returns a copy of self where all of the time components (hours, minutes, seconds, and sub-seconds) are set to the time of the provided epoch.
use hifitime::prelude::*;
let epoch = Epoch::from_gregorian_utc(2022, 12, 01, 10, 11, 12, 13);
let other_utc = Epoch::from_gregorian_utc(2024, 12, 01, 20, 21, 22, 23);
// If the other Epoch is in another time scale, it does not matter, it will be converted to the correct time scale.
let other = other_utc.in_time_scale(TimeScale::TDB);
assert_eq!(
epoch.with_time_from(other),
Epoch::from_gregorian_utc(2022, 12, 01, 20, 21, 22, 23)
);
sourcepub fn with_hms_strict(&self, hours: u64, minutes: u64, seconds: u64) -> Self
pub fn with_hms_strict(&self, hours: u64, minutes: u64, seconds: u64) -> Self
Returns a copy of self where the time is set to the provided hours, minutes, seconds Invalid number of hours, minutes, and seconds will overflow into their higher unit. Warning: this will set the subdivisions of seconds to zero.
sourcepub fn with_hms_strict_from(&self, other: Self) -> Self
pub fn with_hms_strict_from(&self, other: Self) -> Self
Returns a copy of self where the time is set to the time of the other epoch but the subseconds are set to zero.
use hifitime::prelude::*;
let epoch = Epoch::from_gregorian_utc(2022, 12, 01, 10, 11, 12, 13);
let other_utc = Epoch::from_gregorian_utc(2024, 12, 01, 20, 21, 22, 23);
let other = other_utc.in_time_scale(TimeScale::TDB);
assert_eq!(
epoch.with_hms_strict_from(other),
Epoch::from_gregorian_utc(2022, 12, 01, 20, 21, 22, 0)
);
pub fn month_name(&self) -> MonthName
sourcepub fn to_gregorian_utc_str(&self) -> String
👎Deprecated since 3.8.0: Prefer using format!("{}", epoch)
directly
pub fn to_gregorian_utc_str(&self) -> String
format!("{}", epoch)
directlyConverts the Epoch to UTC Gregorian in the ISO8601 format.
sourcepub fn to_gregorian_tai_str(&self) -> String
👎Deprecated since 3.8.0: Prefer using format!("{:x}", epoch)
directly
pub fn to_gregorian_tai_str(&self) -> String
format!("{:x}", epoch)
directlyConverts the Epoch to TAI Gregorian in the ISO8601 format with “ TAI“ appended to the string
sourcepub fn to_gregorian_str(&self, time_scale: TimeScale) -> String
pub fn to_gregorian_str(&self, time_scale: TimeScale) -> String
Converts the Epoch to Gregorian in the provided time scale and in the ISO8601 format with the time scale appended to the string
sourcepub fn to_rfc3339(&self) -> String
pub fn to_rfc3339(&self) -> String
Returns this epoch in UTC in the RFC3339 format
sourcepub fn min(&self, other: Self) -> Self
pub fn min(&self, other: Self) -> Self
Returns the minimum of the two epochs.
use hifitime::Epoch;
let e0 = Epoch::from_gregorian_utc_at_midnight(2022, 10, 20);
let e1 = Epoch::from_gregorian_utc_at_midnight(2022, 10, 21);
assert_eq!(e0, e1.min(e0));
assert_eq!(e0, e0.min(e1));
Note: this uses a pointer to self
which will be copied immediately because Python requires a pointer.
sourcepub fn max(&self, other: Self) -> Self
pub fn max(&self, other: Self) -> Self
Returns the maximum of the two epochs.
use hifitime::Epoch;
let e0 = Epoch::from_gregorian_utc_at_midnight(2022, 10, 20);
let e1 = Epoch::from_gregorian_utc_at_midnight(2022, 10, 21);
assert_eq!(e1, e1.max(e0));
assert_eq!(e1, e0.max(e1));
Note: this uses a pointer to self
which will be copied immediately because Python requires a pointer.
source§impl Epoch
impl Epoch
sourcepub fn now() -> Result<Self, Errors>
pub fn now() -> Result<Self, Errors>
Initializes a new Epoch from now
.
WARNING: This assumes that the system time returns the time in UTC (which is the case on Linux)
Uses std::time::SystemTime::now
or javascript interop under the hood
source§impl Epoch
impl Epoch
sourcepub fn get_num_leap_seconds(&self) -> i32
👎Deprecated since 3.4.0: Prefer leap_seconds_iers or leap_seconds
pub fn get_num_leap_seconds(&self) -> i32
Get the accumulated number of leap seconds up to this Epoch accounting only for the IERS leap seconds.
For the leap seconds and the scaling in “prehistoric” times from 1960 to 1972, use leap_seconds()
.
sourcepub fn as_tdb_duration_since_j2000(&self) -> Duration
👎Deprecated since 3.4.0: Prefer as_tdb_duration
pub fn as_tdb_duration_since_j2000(&self) -> Duration
Returns the duration since Dynamic Barycentric Time (TDB) J2000 (used for Archinal et al. rotations)
sourcepub fn as_et_duration_since_j2000(&self) -> Duration
👎Deprecated since 3.4.0: Prefer as_et_duration
pub fn as_et_duration_since_j2000(&self) -> Duration
Returns the duration since Ephemeris Time (ET) J2000 (used for Archinal et al. rotations)
pub fn as_duration(&self) -> Duration
to_
instead of as_
.pub fn as_duration_in_time_scale(&self, time_scale: TimeScale) -> Duration
to_
instead of as_
.pub fn as_duration_since_j1900(&self) -> Duration
to_
instead of as_
.pub fn as_duration_since_j1900_in_time_scale( &self, time_scale: TimeScale ) -> Duration
to_
instead of as_
.pub fn as_tai_seconds(&self) -> f64
to_
instead of as_
.pub const fn as_tai_duration(&self) -> Duration
to_
instead of as_
.pub fn as_tai(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_tai_days(&self) -> f64
to_
instead of as_
.pub fn as_utc_seconds(&self) -> f64
to_
instead of as_
.pub fn as_utc_duration(&self) -> Duration
to_
instead of as_
.pub fn as_utc(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_utc_days(&self) -> f64
to_
instead of as_
.pub fn as_mjd_tai_days(&self) -> f64
to_
instead of as_
.pub fn as_mjd_tai_seconds(&self) -> f64
to_
instead of as_
.pub fn as_mjd_tai(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_mjd_utc_days(&self) -> f64
to_
instead of as_
.pub fn as_mjd_utc(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_mjd_utc_seconds(&self) -> f64
to_
instead of as_
.pub fn as_jde_tai_days(&self) -> f64
to_
instead of as_
.pub fn as_jde_tai(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_jde_tai_duration(&self) -> Duration
to_
instead of as_
.pub fn as_jde_tai_seconds(&self) -> f64
to_
instead of as_
.pub fn as_jde_utc_days(&self) -> f64
to_
instead of as_
.pub fn as_jde_utc_duration(&self) -> Duration
to_
instead of as_
.pub fn as_jde_utc_seconds(&self) -> f64
to_
instead of as_
.pub fn as_tt_seconds(&self) -> f64
to_
instead of as_
.pub fn as_tt_duration(&self) -> Duration
to_
instead of as_
.pub fn as_tt_days(&self) -> f64
to_
instead of as_
.pub fn as_tt_centuries_j2k(&self) -> f64
to_
instead of as_
.pub fn as_tt_since_j2k(&self) -> Duration
to_
instead of as_
.pub fn as_jde_tt_days(&self) -> f64
to_
instead of as_
.pub fn as_jde_tt_duration(&self) -> Duration
to_
instead of as_
.pub fn as_mjd_tt_days(&self) -> f64
to_
instead of as_
.pub fn as_mjd_tt_duration(&self) -> Duration
to_
instead of as_
.pub fn as_gpst_seconds(&self) -> f64
to_
instead of as_
.pub fn as_gpst_duration(&self) -> Duration
to_
instead of as_
.pub fn as_gpst_nanoseconds(&self) -> Result<u64, Errors>
to_
instead of as_
.pub fn as_gpst_days(&self) -> f64
to_
instead of as_
.pub fn as_unix(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_unix_seconds(&self) -> f64
to_
instead of as_
.pub fn as_unix_milliseconds(&self) -> f64
to_
instead of as_
.pub fn as_unix_days(&self) -> f64
to_
instead of as_
.pub fn as_et_seconds(&self) -> f64
to_
instead of as_
.pub fn as_et_duration_since_j1900(&self) -> Duration
to_
instead of as_
.pub fn as_et_duration(&self) -> Duration
to_
instead of as_
.pub fn as_tdb_duration(&self) -> Duration
to_
instead of as_
.pub fn as_tdb_seconds(&self) -> f64
to_
instead of as_
.pub fn as_tdb_duration_since_j1900(&self) -> Duration
to_
instead of as_
.pub fn as_jde_et_days(&self) -> f64
to_
instead of as_
.pub fn as_jde_et_duration(&self) -> Duration
to_
instead of as_
.pub fn as_jde_et(&self, unit: Unit) -> f64
to_
instead of as_
.pub fn as_jde_tdb_duration(&self) -> Duration
to_
instead of as_
.pub fn as_jde_tdb_days(&self) -> f64
to_
instead of as_
.pub fn as_tdb_days_since_j2000(&self) -> f64
to_
instead of as_
.pub fn as_tdb_centuries_since_j2000(&self) -> f64
to_
instead of as_
.pub fn as_et_days_since_j2000(&self) -> f64
to_
instead of as_
.pub fn as_et_centuries_since_j2000(&self) -> f64
to_
instead of as_
.pub fn as_gregorian_utc(&self) -> (i32, u8, u8, u8, u8, u8, u32)
to_
instead of as_
.pub fn as_gregorian_tai(&self) -> (i32, u8, u8, u8, u8, u8, u32)
to_
instead of as_
.source§impl Epoch
impl Epoch
pub fn as_gregorian_utc_str(&self) -> String
to_
instead of as_
.pub fn as_gregorian_tai_str(&self) -> String
to_
instead of as_
.pub fn as_gregorian_str(&self, ts: TimeScale) -> String
to_
instead of as_
.Trait Implementations§
source§impl Add<f64> for Epoch
impl Add<f64> for Epoch
WARNING: For speed, there is a possibility to add seconds directly to an Epoch. These will be added in the time scale the Epoch was initialized in. Using this is discouraged and should only be used if you have facing bottlenecks with the units.
source§impl AddAssign<Duration> for Epoch
impl AddAssign<Duration> for Epoch
source§fn add_assign(&mut self, duration: Duration)
fn add_assign(&mut self, duration: Duration)
+=
operation. Read moresource§impl AddAssign<Unit> for Epoch
impl AddAssign<Unit> for Epoch
source§fn add_assign(&mut self, unit: Unit)
fn add_assign(&mut self, unit: Unit)
+=
operation. Read moresource§impl<'de> Deserialize<'de> for Epoch
impl<'de> Deserialize<'de> for Epoch
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
source§impl FromStr for Epoch
impl FromStr for Epoch
source§fn from_str(s_in: &str) -> Result<Self, Self::Err>
fn from_str(s_in: &str) -> Result<Self, Self::Err>
Attempts to convert a string to an Epoch.
Format identifiers:
- JD: Julian days
- MJD: Modified Julian days
- SEC: Seconds past a given epoch (e.g. SEC 17.2 TAI is 17.2 seconds past TAI Epoch)
Example
use hifitime::Epoch;
use core::str::FromStr;
assert!(Epoch::from_str("JD 2452312.500372511 TDB").is_ok());
assert!(Epoch::from_str("JD 2452312.500372511 ET").is_ok());
assert!(Epoch::from_str("JD 2452312.500372511 TAI").is_ok());
assert!(Epoch::from_str("MJD 51544.5 TAI").is_ok());
assert!(Epoch::from_str("SEC 0.5 TAI").is_ok());
assert!(Epoch::from_str("SEC 66312032.18493909 TDB").is_ok());
source§impl Ord for Epoch
impl Ord for Epoch
source§impl PartialEq for Epoch
impl PartialEq for Epoch
Equality only checks the duration since J1900 match in TAI, because this is how all of the epochs are referenced.
source§impl PartialOrd for Epoch
impl PartialOrd for Epoch
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl SubAssign<Duration> for Epoch
impl SubAssign<Duration> for Epoch
source§fn sub_assign(&mut self, duration: Duration)
fn sub_assign(&mut self, duration: Duration)
-=
operation. Read moresource§impl SubAssign<Unit> for Epoch
impl SubAssign<Unit> for Epoch
source§fn sub_assign(&mut self, unit: Unit)
fn sub_assign(&mut self, unit: Unit)
-=
operation. Read more