anytime 0.2.0

Ergonomic astronomical timescales in rust
Documentation
use crate::constants::{DAY_SECONDS, JD_TO_MJD, TAI_UTC};

pub(crate) struct UtcDay {
    pub(crate) midnight_jd: f64,
    pub(crate) scaled_fractional_day: f64,
    pub(crate) fractional_day_scale: f64,
    pub(crate) tai_minus_utc: f64,
}

pub(crate) fn utc_day(jd1: f64, jd2: f64) -> UtcDay {
    let (midnight_jd, fractional_day) = if jd2 >= 0.5 {
        (jd1 + 0.5, jd2 - 0.5)
    } else {
        (jd1 - 0.5, jd2 + 0.5)
    };

    let mut today_entry = TAI_UTC[0];
    for entry in TAI_UTC.iter().rev() {
        if midnight_jd >= entry.0 {
            today_entry = *entry;
            break;
        }
    }
    let today_offset = today_entry.1 + (midnight_jd - JD_TO_MJD - today_entry.2) * today_entry.3;
    let midday_offset =
        today_entry.1 + (midnight_jd + 0.5 - JD_TO_MJD - today_entry.2) * today_entry.3;

    let mut tomorrow_entry = TAI_UTC[0];
    for entry in TAI_UTC.iter().rev() {
        if midnight_jd + 1.0 >= entry.0 {
            tomorrow_entry = *entry;
            break;
        }
    }
    let tomorrow_offset =
        tomorrow_entry.1 + (midnight_jd + 1.0 - JD_TO_MJD - tomorrow_entry.2) * tomorrow_entry.3;

    let daily_drift = 2.0 * (midday_offset - today_offset);
    let boundary_jump = tomorrow_offset - (today_offset + daily_drift);
    let fractional_day_scale =
        (DAY_SECONDS + boundary_jump) / DAY_SECONDS * (DAY_SECONDS + daily_drift) / DAY_SECONDS;
    let scaled_fractional_day = fractional_day * fractional_day_scale;

    UtcDay {
        midnight_jd,
        scaled_fractional_day,
        fractional_day_scale,
        tai_minus_utc: today_offset + (scaled_fractional_day - fractional_day) * DAY_SECONDS,
    }
}

#[cfg(test)]
pub(crate) fn assert_round_trip<S, T>(time: crate::Time<S>)
where
    S: Clone,
    crate::Time<T>: From<crate::Time<S>>,
    crate::Time<S>: From<crate::Time<T>>,
{
    use chrono::TimeDelta;

    let original = time.clone();
    let converted: crate::Time<T> = time.into();
    let round_trip: crate::Time<S> = converted.into();
    let error = round_trip.value - original.value;
    let absolute_error = if error < TimeDelta::seconds(0) {
        -error
    } else {
        error
    };

    let error_ns = absolute_error.num_seconds() as f64 * 1e9 + absolute_error.subsec_nanos() as f64;
    assert!(error_ns <= 0.1, "round-trip error was {error_ns} ns");
}