Repository files navigation

Hifitime is a powerful Rust and Python library designed for time management. It provides extensive functionalities with precise operations for time calculation in different time scales, making it suitable for engineering and scientific applications where general relativity and time dilation matter. Hifitime guarantees nanosecond precision for 65,536 years around the reference epoch of the initialization time scale, e.g. 01 January 1900 for TAI. Hifitime is also formally verified using theKani model checker, read more about itthis verification here.

Most users of Hifitime will only need to rely on theEpoch andDuration structures, and optionally theWeekday enum for week based computations. Scientific applications may make use of theTimeScale enum as well.

First, installhifitime either withcargo add hifitime in your Rust project orpip install hifitime in Python.

If building from source, note that the Python package is only built if thepython feature is enabled.

Create an epoch in different time scales.

use hifitime::prelude::*;use core::str::FromStr;// Create an epoch in UTClet epoch =Epoch::from_gregorian_utc(2000,2,29,14,57,29,37);// Or from a stringlet epoch_from_str =Epoch::from_str("2000-02-29T14:57:29.000000037 UTC").unwrap();assert_eq!(epoch, epoch_from_str);// Creating it from TAI will effectively show the number of leap seconds in between UTC an TAI at that epochlet epoch_tai =Epoch::from_gregorian_tai(2000,2,29,14,57,29,37);// The difference between two epochs is a Durationlet num_leap_s = epoch - epoch_tai;assert_eq!(format!("{num_leap_s}"),"32 s");// Trivially convert to another time scale// Either by grabbing a subdivision of time in that time scaleassert_eq!(epoch.to_gpst_days(),7359.623402777777);// Compare to the GPS time scale// Or by fetching the exact durationlet mjd_offset =Duration::from_str("51603 days 14 h 58 min 33 s 184 ms 37 ns").unwrap();assert_eq!(epoch.to_mjd_tt_duration(), mjd_offset);// Compare to the modified Julian days in the Terrestrial Time time scale.

In Python:

>>>fromhifitimeimport*>>>epoch=Epoch("2000-02-29T14:57:29.000000037 UTC")>>>epoch2000-02-29T14:57:29.000000037UTC>>>epoch_tai=Epoch.init_from_gregorian_tai(2000,2,29,14,57,29,37)>>>epoch_tai2000-02-29T14:57:29.000000037TAI>>>epoch.timedelta(epoch_tai)32s>>>epoch.to_gpst_days()7359.623402777777>>>epoch.to_mjd_tt_duration()51603days14h58min33s184ms37ns>>>

Hifitime provides several date time formats like RFC2822, ISO8601, or RFC3339.

use hifitime::efmt::consts::{ISO8601,RFC2822,RFC3339};use hifitime::prelude::*;let epoch =Epoch::from_gregorian_utc(2000,2,29,14,57,29,37);// The default Display shows the UTC time scaleassert_eq!(format!("{epoch}"),"2000-02-29T14:57:29.000000037 UTC");// Format it in RFC 2822let fmt =Formatter::new(epoch,RFC2822);assert_eq!(format!("{fmt}"), format!("Tue, 29 Feb 2000 14:57:29"));// Or in ISO8601let fmt =Formatter::new(epoch,ISO8601);assert_eq!(    format!("{fmt}"),    format!("2000-02-29T14:57:29.000000037 UTC"));// Which is somewhat similar to RFC3339let fmt =Formatter::new(epoch,RFC3339);assert_eq!(    format!("{fmt}"),    format!("2000-02-29T14:57:29.000000037+00:00"));

Need some custom format? Hifitime also supports the C89 token, cf.the documentation.

use core::str::FromStr;use hifitime::prelude::*;let epoch =Epoch::from_gregorian_utc_hms(2015,2,7,11,22,33);// Parsing with a custom formatassert_eq!(Epoch::from_format_str("Sat, 07 Feb 2015 11:22:33","%a, %d %b %Y %H:%M:%S").unwrap(),    epoch);// And printing with a custom formatlet fmt =Format::from_str("%a, %d %b %Y %H:%M:%S").unwrap();assert_eq!(    format!("{}",Formatter::new(epoch, fmt)),"Sat, 07 Feb 2015 11:22:33");

You can also grab the current system time in UTC, if thestd feature is enabled (default), and find the next or previous day of the week.

use hifitime::prelude::*;#[cfg(feature ="std")]{let now =Epoch::now().unwrap();println!("{}", now.next(Weekday::Tuesday));println!("{}", now.previous(Weekday::Sunday));}

Oftentimes, we'll want to query something at a fixed step between two epochs. Hifitime makes this trivial withTimeSeries.

use hifitime::prelude::*;let start =Epoch::from_gregorian_utc_at_midnight(2017,1,14);let end = start +12.hours();let step =2.hours();let time_series =TimeSeries::inclusive(start, end, step);letmut cnt =0;for epochin time_series{#[cfg(feature ="std")]println!("{}", epoch);    cnt +=1}// Check that there are indeed seven two-hour periods in a half a day,// including start and end times.assert_eq!(cnt,7)

In Python:

>>>fromhifitimeimport*>>>start=Epoch.init_from_gregorian_utc_at_midnight(2017,1,14)>>>end=start+Unit.Hour*12>>>iterator=TimeSeries(start,end,step=Unit.Hour*2,inclusive=True)>>>forepochiniterator:...print(epoch)...2017-01-14T00:00:00UTC2017-01-14T02:00:00UTC2017-01-14T04:00:00UTC2017-01-14T06:00:00UTC2017-01-14T08:00:00UTC2017-01-14T10:00:00UTC2017-01-14T12:00:00UTC>>>

use hifitime::prelude::*;use core::str::FromStr;// Create a duration using the `TimeUnits` helping trait.let d =5.minutes() +7.minutes() +35.nanoseconds();assert_eq!(format!("{d}"),"12 min 35 ns");// Or using the built-in enumslet d_enum =12*Unit::Minute +35.0*Unit::Nanosecond;// But it can also be created from a stringlet d_from_str =Duration::from_str("12 min 35 ns").unwrap();assert_eq!(d, d_from_str);

Hifitime guarantees nanosecond precision, but most human applications don't care too much about that. Durations can be rounded to provide a useful approximation for humans.

use hifitime::prelude::*;// Create a duration using the `TimeUnits` helping trait.let d =5.minutes() +7.minutes() +35.nanoseconds();// Round to the nearest minutelet rounded = d.round(1.minutes());assert_eq!(format!("{rounded}"),"12 min");// And this works on Epochs as well.let previous_post =Epoch::from_gregorian_utc_hms(2015,2,7,11,22,33);let example_now =Epoch::from_gregorian_utc_hms(2015,8,17,22,55,01);// We'll round to the nearest fifteen dayslet this_much_ago = example_now - previous_post;assert_eq!(format!("{this_much_ago}"),"191 days 11 h 32 min 28 s");let about_this_much_ago_floor = this_much_ago.floor(15.days());assert_eq!(format!("{about_this_much_ago_floor}"),"180 days");let about_this_much_ago_ceil = this_much_ago.ceil(15.days());assert_eq!(format!("{about_this_much_ago_ceil}"),"195 days");

In Python:

>>>fromhifitimeimport*>>>d=Duration("12 min 32 ns")>>>d.round(Unit.Minute*1)12min>>>d12min32ns>>>

First off, bothtime andchrono are fantastic libraries in their own right. There's a reason why they have millions and millions of downloads. Secondly, hifitime was started in October 2017, so quite a while before the revival oftime (~ 2019).

One of the key differences is that bothchrono andtime separate the concepts of "time" and "date." Hifitime asserts that this is physically invalid: both a time and a date are an offset from a reference in a given time scale. That's why, Hifitime does not separate the components that make up a date, but instead, only stores a fixed duration with respect to TAI. Moreover, Hifitime is formally verified with a model checker, which is much more thorough than property testing.

More importantly, neithertime norchrono are suitable for astronomy, astrodynamics, or any physics that must account for time dilation due to relativistic speeds or lack of the Earth as a gravity source (which sets the "tick" of a second).

Hifitime also natively supports the UT1 time scale (the only "true" time) if built with theut1 feature.

• Initialize a high precision Epoch from the system time in UTC
• Leap seconds (as announced by the IETF on a yearly basis)
• UTC representation with ISO8601 and RFC3339 formatting and blazing fast parsing (45 nanoseconds)
• Trivial support of time arithmetic: addition (e.g.2.hours() + 3.seconds()), subtraction (e.g.2.hours() - 3.seconds()), round/floor/ceil operations (e.g.2.hours().round(3.seconds()))
• Supports ranges of Epochs and TimeSeries (linspace ofEpochs andDurations)
• Trivial conversion between many time scales
• High fidelity Ephemeris Time / Dynamic Barycentric Time (TDB) computations fromESA's Navipedia
• Julian dates and Modified Julian dates
• Embedded device friendly:no-std andconst fn where possible

This library is validated against NASA/NAIF SPICE for the Ephemeris Time to Universal Coordinated Time computations: there are exactly zero nanoseconds of difference between SPICE and hifitime for the computation of ET and UTC after 01 January 1972. Refer to theleap second section for details. Other examples are validated with external references, as detailed on a test-by-test basis.

• Temps Atomique International (TAI)
• Universal Coordinated Time (UTC)
• Terrestrial Time (TT)
• Ephemeris Time (ET) without the small perturbations as per NASA/NAIF SPICE leap seconds kernel
• Dynamic Barycentric Time (TDB), a higher fidelity ephemeris time
• Global Positioning System (GPST)
• Galileo System Time (GST)
• BeiDou Time (BDT)
• UNIX

• Time-agnostic / date-only epochs. Hifitime only supports the combination of date and time, but theEpoch::{at_midnight, at_noon} is provided as helper functions.

No software is perfect, so please report any issue or bug onGithub.

Under the hood, a Duration is represented as a 16 bit signed integer of centuries (i16) and a 64 bit unsigned integer (u64) of the nanoseconds past that century. The overflowing and underflowing of nanoseconds is handled by changing the number of centuries such that the nanoseconds number never represents more than one century (just over four centuries can be stored in 64 bits).

Advantages:

1. Exact precision of a duration: using a floating point value would cause large durations (e.g. Julian Dates) to have less precision than smaller durations. Durations in hifitime have exactly one nanosecond of precision for 65,536 years.
2. Skipping floating point operations allows this library to be used in embedded devices without a floating point unit.
3. Duration arithmetics are exact, e.g. one third of an hour is exactly twenty minutes and not "0.33333 hours."

Disadvantages:

1. Most astrodynamics applications require the computation of a duration in floating point values such as when querying an ephemeris. This design leads to an overhead of about 5.2 nanoseconds according to the benchmarks (Duration to f64 seconds benchmark). You may run the benchmarks withcargo bench.

The Epoch stores a duration with respect to the reference of a time scale, and that time scale itself. For monotonic time on th Earth,Standard of Fundamental Astronomy (SOFA) recommends of opting for a glitch-free time scale like TAI (i.e. without discontinuities like leap seconds or non-uniform seconds like TDB).

Leap seconds allow TAI (the absolute time reference) and UTC (the civil time reference) to not drift too much. In short, UTC allows humans to see the sun at zenith at noon, whereas TAI does not worry about that. Leap seconds are introduced to allow for UTC to catch up with the absolute time reference of TAI. Specifically, UTC clocks are "stopped" for one second to make up for the accumulated difference between TAI and UTC. These leap seconds are announced several months in advance by IERS, cf. in theIETF leap second reference.

The "placement" of these leap seconds in the formatting of a UTC date is left up to the software: there is no common way to handle this. Some software prevents a second tick, i.e. at 23:59:59 the UTC clock will tick fortwo seconds (instead of one) before hoping to 00:00:00. Some software, like hifitime, allow UTC dates to be formatted as 23:59:60 on strictly the days when a leap second is inserted. For example, the date2016-12-31 23:59:60 UTC is a valid date in hifitime because a leap second was inserted on 01 Jan 2017.

Prior to the first leap second, NAIF SPICE claims that there were nine seconds of difference between TAI and UTC: this is different from theStandard of Fundamental Astronomy (SOFA). SOFA'siauDat function will return non-integer leap seconds from 1960 to 1972. It will return an error for dates prior to 1960.Hifitime only accounts for leap seconds announced byIERS in its computations: there is a ten (10) second jump between TAI and UTC on 01 January 1972. This allows the computation of UNIX time to be a specific offset of TAI in hifitime. However, the prehistoric (pre-1972) leap seconds as returned by SOFA are available in theleap_seconds() method of an epoch if theiers_only parameter is set to false.

In theory, as of January 2000, ET and TDB should now be identical.However, the NASA NAIF leap seconds files (e.g.naif00012.tls) use a simplified algorithm to compute the TDB:

Equation [4], which ignores small-period fluctuations, is accurate to about 0.000030 seconds.

In order to provide full interoperability with NAIF, hifitime uses the NAIF algorithm for "ephemeris time" and theESA algorithm for "dynamical barycentric time." Hence, if exact NAIF behavior is needed, use all of the functions marked aset instead of thetdb functions, such asepoch.to_et_seconds() instead ofepoch.to_tdb_seconds().

This update is not mearly an iteration, but a redesign in how time scale are handled in hifitime, fixing nanosecond rounding errors, and improving the Python user experience. Refer to theblog post for details. As of version 4.0.0, Hifitime is licensed under the Mozilla Public License version 2, refer todiscussion #274 for details.

• Refactor epoch to keep time in its own time scale by @gwbres and @ChristopherRabotin in#280
• Duration serde now human readable + Display of Epoch is now Gregorian in its initialization time scale by @ChristopherRabotin in#299
• Improve error handling (switching tosnafu) by @ChristopherRabotin in#300
• Breaking change: renamed Julian date constants and removed other Julian date constants by @ChristopherRabotin in#307
• Minimum Support Rust Version (MSRV) bumped to 1.77.0

Note: as of version 4.0.0, dependency updates will increment the minor version.

• Support exceptions in Python by @ChristopherRabotin in#301
• Add Python regression test for #249 by @ChristopherRabotin in#305
• MJD/JDE UTC fix +to_time_scale now available in Python by @ChristopherRabotin in#332
• Add Python datetime interop by @ChristopherRabotin in#333
• Add autogenerated Kani harnesses by @cvick32 in#316
• Kani autogen follow on by @ChristopherRabotin in#318

• Fix bug into_gregorian_str by @ChristopherRabotin in#308
• Fix conversion to Gregorian by @ChristopherRabotin in#303
• RenameEpochError toHifitimeError and add exception testing by @ChristopherRabotin in#315
• Prevent rounding of the GNSS from nanoseconds initializers by @ChristopherRabotin in#319
• Fix ceil with zero duration by @cardigan1008 in#323
• Fix token exceed in from_str() by @cardigan1008 in#324

The main change in this refactoring is thatEpochs now keep the time in their own time scales. This greatly simplifies conversion between time scales, and ensures that all computations happen in the same time scale as the initialization time scale, then no sub-nanosecond rounding error could be introduced.

• Removed der dependency by @ChristopherRabotin in#297
• Refactor epochrs as a module by @ChristopherRabotin in#298
• 4.0.0 dev gh 237 by @gwbres in#289
• Introduce doc_cfg and mark ut1 within ut1 crate feature by @gwbres in#321
• Update pyo3 requirement from 0.21.1 to 0.22.0 by @dependabot in#312
• Update tabled requirement from 0.15.0 to 0.16.0 by @dependabot in#325
• Update lexical-core requirement from 0.8.5 to 1.0.1 by @dependabot in#330

• Update to der version 0.7.x.
• Introduce %y formatter by @gwbres in#268
• Possible breaking change: Fix day of year computation by @ChristopherRabotin in#273

Changes from 3.8.2 are only dependency upgrades until this release.

Minimum Supported Rust version bumped from 1.64 to1.70.

• Clarify README and add a section comparing Hifitime totime andchrono, cf.#221
• Fix incorrect printing of Gregorian dates prior to to 1900, cf.#204

• Fix documentation for the formatter, cf.#202
• Update MSRV to 1.59 for rayon v 1.10

Thanks again to@gwbres for his work in this release!

• Fix CI of the formal verification and upload artifacts, cf.#179
• Introduce time of week construction and conversion by@gwbres, cf.#180 and#188
• Fix minor typo insrc/timeunits.rs by@gwbres, cf.#189
• Significantly extend formal verification ofDuration andEpoch, and introducekani::Arbitrary toDuration andEpoch for users to formally verify their use of time, cf.#192
• It is now possible to specify a Leap Seconds file (in IERS format) using theLeapSecondsFile::from_path (requires thestd feature to read the file), cf.#43.
• UT1 time scale is now supported! You must build aUt1Provider structure with data from the JPL Earth Orientation Parameters, or just useUt1Provider::download_short_from_jpl() to automatically download the data from NASA JPL.
• strptime andstrftime equivalents from C89 are now supported, cf.#181. Please refer to thedocumentation for important limitations and how to build a custom formatter.
• ISO Day of Year and Day In Year are now supported for initialization of an Epoch (provided a time scale and a year), and formatting, cf.#182.
• Python: the representation of an epoch is now in the time scale it was initialized in

Huge thanks to@gwbres who put in all of the work for this release. These usability changes allowRinex to use hifitime, check out this work.

• timescale.rs: derive serdes traits when feasible by @gwbres in#167
• timecale.rs: introduce format/display by @gwbres in#168
• readme: fix BeiDou typo by @gwbres in#169
• epoch: derive Hash by @gwbres in#170
• timescale: identify GNSS timescales from standard 3 letter codes by @gwbres in#171
• timescale: standard formatting is now available by @gwbres in#174
• epoch, duration: improve and fix serdes feature by @gwbres in#175
• epoch, timescale: implement default trait by @gwbres in#176

• Galileo System Time and BeiDou Time are now supported, huge thanks to@gwbres for all that work!
• Significant speed improvement in the initialization of Epochs from their Gregorian representation, thanks@conradludgate for#160.
• Epoch and Duration now have amin andmax function which respectively returns a copy of the epoch/duration that is the smallest or the largest betweenself andother, cf.#164.
• [Python] Duration and Epochs now support the operators>,>=,<,<=,==, and!=. Epoch now supportsinit_from_gregorian with a time scape, like in Rust. Epochs can also be subtracted from one another using thetimedelta function, cf.#162.
• TimeSeries can now be formatted in different time scales, cf.#163

• Epoch now store the time scale that they were defined in: this allows durations to be added in their respective time scales. For example, adding 36 hours to 1971-12-31 at noon when the Epoch is initialized in UTC will lead to a different epoch than adding that same duration to an epoch initialized at the same time in TAI (because the first leap second announced by IERS was on 1972-01-01), cf. thetest_add_durations_over_leap_seconds test.
• RFC3339 and ISO8601 fully supported for initialization of an Epoch, including the offset, e.g.Epoch::from_str("1994-11-05T08:15:30-05:00"), cf.#73.
• Python package available on PyPI! To build the Python package, you must first installmaturin and then build with thepython feature flag. For example,maturin develop -F python && python will build the Python package in debug mode and start a new shell where the package can be imported.
• Fix bug when printing Duration::MIN (or any duration whose centuries are minimizing the number of centuries).
• TimeSeries can now be formatted
• Epoch can now beceil-ed,floor-ed, andround-ed according to the time scale they were initialized in, cf.#145.
• Epoch can now be initialized from Gregorian when specifying the time system:from_gregorian,from_gregorian_hms,from_gregorian_at_noon,from_gregorian_at_midnight.
• Fix bug in Duration when performing operations on durations very close toDuration::MIN (i.e. minus thirty-two centuries).
• Duration parsing now supports multiple units in a string and does not use regular expressions. THis allows it to work withno-std.
• Epoch parsing no longer requiresregex.
• Functions are not more idiomatic: all of theas_* functions becometo_* andin_* also becomesto_*, cf.#155.

• Ephemeris Time and Dynamical Barycentric Time fixed to use the J2000 reference epoch instead of the J1900 reference epoch. This is apotentially breaking change if you relied on the previous one century error when converting from/to ET/TDB into/from UTCand storing the data as a string. There isno difference if the original representation was used.
• Ephemeris Time nowstrictly matches NAIF SPICE:the error between SPICE and hifitime is now zero nanoseconds. after the introduction of the first leap second. Prior to the first leap second, NAIF SPICE claims that there were nine seconds of difference between TAI and UTC: this is different from SOFA. Hifitime instead does not account for leap seconds in prehistoric (pre-1972) computations at all.
• TheStandard of Fundamentals of Astronomy (SOFA) leap seconds from 1960 to 1972 are now available with theleap_seconds() -> Option<f64> function on an instance of Epoch.Importantly, no difference in the behavior of hifitime should be noticed here: the prehistoric leap seconds are ignored in all calculations in hifitime and only provided to meet the SOFA calculations.
• Epoch andDuration now have the C memory representation to allow for hifitime to be embedded in C more easily.
• Epoch andDuration can now be encoded or decoded as ASN1 DER with theasn1der crate feature (disabled by default).

• Formal verification of the normalization operation onDuration, which in turn guarantees thatEpoch operations cannot panic, cf.#127
• Fixlen andsize_hint forTimeSeries, cf.#131, reported by@d3v-null, thanks for the find!
• Epoch now implementsEq andOrd, cf.#133, thanks@mkolopanis for the PR!
• Epoch can now be printed in different time systems with format modifiers, cf.#130
• (minor)as_utc_duration inEpoch is now public, cf.#129
• (minor) The whole crate now usesnum-traits thereby skipping the explicit use oflibm. Basically, operations onf64 look like normal Rust again, cf.#128
• (minor) Move the tests to their own folder to make it obvious that this is thoroughly tested

• Fix no-std implementation by usinglibm for non-core f64 operations
• Add UNIX timestamp, thanks@mkolopanis
• Enums now deriveEq and some deriveOrd (where relevant)#118
• Use const fn where possible and switch to references where possible#119
• Allow extracting the centuries and nanoseconds of aDuration andEpoch, respectively with to_parts and to_tai_parts#122
• Addceil,floor,round operations toEpoch andDuration

• Add#![no_std] support
• Addto_parts toDuration to extract the centuries and nanoseconds of a duration
• Allow building anEpoch from its duration and parts in TAI system
• Add pure nanosecond (u64) constructor and getter for GPST since GPS based clocks will count in nanoseconds

• Errors::ParseError no longer contains aString but an enumParsingErrors instead. This is considered possibly breaking because it would only break code in the cases where a datetime parsing or unit parsing was caught and handled (uncommon). Moreover, the output is stillDisplay-able.

• Backend rewritten from TwoFloat to a struct of the centuries ini16 and nanoseconds inu64. Thanks to@pwnorbitals for proposing the idea in #107 and writing the proof of concept. This leads to at least a 2x speed up in most calculations, cf.this comment.
• Fix GPS epoch, and addition of a helper functions inEpoch by@cjordan

We want to inform our users of an important change in Hifitime's versioning approach. Starting with version 3.9.0, minor version updates may include changes that could potentially break backward compatibility. While we strive to maintain stability and minimize disruptions, this change allows us to incorporate significant improvements and adapt more swiftly to evolving user needs. We recommend users to carefully review the release notes for each update, even minor ones, to understand any potential impacts on their existing implementations. Our commitment to providing a robust and dynamic time management library remains steadfast, and we believe this change in versioning will better serve the evolving demands of our community.

Thanks for considering to help out on Hifitime!

For Rust development,cargo is all you need, along with build tools for the minimum supported Rust version.

First, please installmaturin and set up a Python virtual environment from which to develop. Also make sure that the package version in Cargo.toml isgreater than any published version. For example, if the latest version published onPyPi is 4.0.0-a.0 (for alpha-0), make sure that you change the Cargo.toml file such that you're at least in versionalpha-1, or thepip install will download from PyPi instead of installing from the local folder. To run the Python tests, you must installpytest in your virtual environment.

The exact steps should be:

1. Jump into the virtual environment:source .venv/bin/activate (e.g.)
2. Make sure pytest is installed:pip install pytest
3. Build hifitime specifying the output folder of the Python egg:maturin build -F python --out dist
4. Install the egg:pip install dist/hifitime-4.0.0.alpha1-cp311-cp311-linux_x86_64.whl
5. Run the tests using the environmental pytest:.venv/bin/pytest

Hifitime uses the approach fromdora to enable type hinting in IDEs. This approach requires runningmaturin twice: once to generate to the bindings and a second time for it to incorporate thepyi file.

maturin develop -F python;python generate_stubs.py hifitime hifitime.pyi;maturin develop