vsrg 0.6.0

use std::ops::{Add, Div, Sub};

use crate::math::{Fraction, Number};

/// Time measured in either clock time, or musical beat time.
///
/// # Remarks:
/// Events in a notes storage can be defined by either timing unit. Both untis disallow NaN values, but
/// allows infinity.
///
/// The conversion between two variants requires knowing the full list of tempo change over time,
/// which is described by [`super::TempoTrack`].
///
/// Arithmetic between two time values can only be done if they have the same unit. You must
/// first prove two [`Time`] values have the same unit first with [`Time::prove_same_unit`],
/// which returns [`SameUnitTime`].
///
/// Arithmetic can be done safely with [`SameUnitTime`] without panicking.
///
/// Addition and subtraction automatically produces positive infinity for INF - INF or -INF + INF
/// cases without panicking.
#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Time {
    Clock(ClockTime),
    Beat(BeatTime),
}

impl PartialOrd for Time {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match (self, other) {
            (Time::Clock(x), Time::Clock(y)) => x.0.partial_cmp(&y.0),
            (Time::Beat(x), Time::Beat(y)) => x.0.partial_cmp(&y.0),
            _ => None,
        }
    }
}

impl Time {
    /// Creates a beat time from a floating-point value or fraction.
    ///
    /// Returns `None` if the value is NaN.
    pub fn beat(beat_num: impl Into<Number>) -> Option<Self> {
        BeatTime::from_number(beat_num.into()).map(Self::Beat)
    }

    /// Creates a clock time from milliseconds.
    ///
    /// Returns `None` if the value is NaN or the exact fraction conversion overflows.
    pub fn clock_milis(ms: impl Into<Number>) -> Option<Self> {
        ClockTime::from_milis(ms).map(Self::Clock)
    }

    /// Creates a clock time from seconds.
    ///
    /// Returns `None` if the value is NaN.
    pub fn clock_secs(secs: impl Into<Number>) -> Option<Self> {
        ClockTime::from_seconds(secs).map(Self::Clock)
    }

    /// Creates a clock time from an exact fraction of seconds.
    pub fn clock_secs_fraction(secs: Fraction) -> Self {
        Time::Clock(ClockTime::from_fraction_seconds(secs))
    }

    /// Creates a clock time from an exact fraction of seconds.
    pub fn beat_fraction(beats: Fraction) -> Self {
        Time::Beat(BeatTime::from_fraction(beats))
    }
}

/// [`Time`] value proven to have the same unit as other values sharing its lifetime id.
///
/// # Remarks
/// This type uses [`generativity`] trick. Values with the same 'id lifetime parameter are proven to
/// have same unit at compile time, which means arithmetic between values of the same
/// [`SameUnitTime`] type instance is guaranteed to be valid.
///
/// Arithmetic can be done safely with [`SameUnitTime`] without panicking.
/// Addition and subtraction automatically produces positive infinity for INF - INF or -INF + INF
/// cases without panicking.
///
/// # Examples
/// ```
/// use vsrg::rhythm::{Time, ClockTime};
/// use vsrg::generativity::make_guard;
///
/// let t1 = Time::Clock(ClockTime::ZERO);
/// let t2 = Time::Clock(ClockTime::ONE);
///
/// make_guard!(guard);
/// let (t1, t2) = Time::prove_same_unit(t1, t2, guard).expect("Both are clock time");
/// assert_eq!((t1 + t2).as_time(), t2.as_time());
/// ```
///
/// This would not compile, only units proven with the same [`generativity::Guard`] have the same
/// type.
/// ```compile_fail
/// use vsrg::rhythm::{Time, BeatTime, ClockTime};
/// use vsrg::generativity::make_guard;
///
/// let t1 = Time::Clock(ClockTime::ZERO);
/// let t2 = Time::Clock(ClockTime::ONE);
/// let t3 = Time::Beat(BeatTime::ZERO);
/// let t4 = Time::Beat(BeatTime::ONE);
///
/// make_guard!(g12);
/// let (t1, t2) = Time::prove_same_unit(t1, t2, g12).expect("Both are clock time");
/// make_guard!(g34);
/// let (t3, t4) = Time::prove_same_unit(t3, t4, g34).expect("Both are beat time");
///
/// // Invalid, because t1 and t3 are different instances of the same SameUnitTime type.
/// let this_is_invalid = t1 - t3;
/// ```
///
#[derive(Debug, Clone, Copy)]
pub struct SameUnitTime<'id>(Time, generativity::Id<'id>);

impl From<SameUnitTime<'_>> for Time {
    fn from(value: SameUnitTime<'_>) -> Self {
        value.0
    }
}

impl Time {
    /// Proves that two [`Time`] values have the same unit.
    ///
    /// See [`SameUnitTime`] for examples.
    pub fn prove_same_unit<'id>(
        self,
        other: Time,
        guard: generativity::Guard<'id>,
    ) -> Option<(SameUnitTime<'id>, SameUnitTime<'id>)> {
        let id = guard.into();
        match (self, other) {
            (Time::Clock(_), Time::Clock(_)) | (Time::Beat(_), Time::Beat(_)) => {
                Some((SameUnitTime(self, id), SameUnitTime(other, id)))
            }
            _ => None,
        }
    }
}

impl<'id> SameUnitTime<'id> {
    /// Proves that a raw [`Time`] value has the same unit with this value.
    ///
    /// This reflexively proves that the value has the same unit as other values with the same
    /// 'id life time parameter.
    pub fn prove_same_unit(self, other: Time) -> Option<SameUnitTime<'id>> {
        match (self.0, other) {
            (Time::Clock(_), Time::Clock(_)) | (Time::Beat(_), Time::Beat(_)) => {
                Some(SameUnitTime(other, self.1))
            }
            _ => None,
        }
    }

    /// Retrieves back a raw [`Time`] value.
    pub fn as_time(&self) -> Time {
        self.0
    }
}

impl<'id> Add for SameUnitTime<'id> {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        match (self.0, rhs.0) {
            (Time::Clock(x), Time::Clock(y)) => {
                SameUnitTime(Time::Clock(ClockTime(non_nan_add(x.0, y.0))), self.1)
            }
            (Time::Beat(x), Time::Beat(y)) => {
                SameUnitTime(Time::Beat(BeatTime(non_nan_add(x.0, y.0))), self.1)
            }
            _ => unreachable!("Both are proven to have the same unit"),
        }
    }
}

impl<'id> Sub for SameUnitTime<'id> {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        match (self.0, rhs.0) {
            (Time::Clock(x), Time::Clock(y)) => {
                SameUnitTime(Time::Clock(ClockTime(non_nan_sub(x.0, y.0))), self.1)
            }
            (Time::Beat(x), Time::Beat(y)) => {
                SameUnitTime(Time::Beat(BeatTime(non_nan_sub(x.0, y.0))), self.1)
            }
            _ => unreachable!("Both are proven to have the same unit"),
        }
    }
}

impl<'id> Div for SameUnitTime<'id> {
    type Output = f64;

    fn div(self, rhs: Self) -> Self::Output {
        match (self.0, rhs.0) {
            (Time::Clock(x), Time::Clock(y)) => x.seconds() / y.seconds(),
            (Time::Beat(x), Time::Beat(y)) => x.beats() / y.beats(),
            _ => unreachable!("Both are proven to have the same unit"),
        }
    }
}

/// Time measured in clock time (seconds, miliseconds, etc.).
///
/// # Remarks:
/// NaN time values are disallowed, but infinities are allowed.
///
/// Addition and subtraction automatically produces positive infinity for INF - INF or -INF + INF
/// cases without panicking.
#[derive(Default, Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClockTime(Number);

impl Eq for ClockTime {}

impl PartialOrd for ClockTime {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for ClockTime {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        // IMPORTANT: We do not use total_cmp because it defines -0.0 < 0.0.
        self.0.partial_cmp(&other.0).expect("Time can not be NaN")
    }
}

impl ClockTime {
    pub const ZERO: Self = Self(Number::Float(0.0));
    pub const ONE: Self = Self(Number::Float(1.0));
    pub const INF: Self = Self(Number::Float(f64::INFINITY));
    pub const NEG_INF: Self = Self(Number::Float(f64::NEG_INFINITY));

    /// Creates a clock time from seconds.
    ///
    /// Returns `None` only if `secs` is NaN.
    /// Infinite values are permitted.
    pub fn from_seconds(secs: impl Into<Number>) -> Option<Self> {
        let secs = secs.into();
        (!secs.is_nan()).then_some(Self(secs))
    }

    /// Creates a clock time from an exact fraction of seconds.
    ///
    /// Different to the other constructors ([`Self::from_seconds`], and [`Self::from_milis`]),
    /// this is infallible.
    pub fn from_fraction_seconds(secs: Fraction) -> Self {
        Self(Number::Fraction(secs))
    }

    /// Creates a clock time from miliseconds.
    ///
    /// Returns `None` only if `milis` is NaN.
    /// Infinite values are permitted.
    pub fn from_milis(milis: impl Into<Number>) -> Option<Self> {
        let milis = milis.into();
        milis
            .checked_mul(Number::Fraction(Fraction::new(1, 1000)?))
            .map(Self)
    }

    /// Creates a clock time from [`std::time::Duration`].
    ///
    /// This is infallible because [`std::time::Duration`] can not be NaN.
    pub const fn from_duration(dur: std::time::Duration) -> Self {
        Self(Number::Float(dur.as_secs_f64()))
    }

    pub fn seconds(self) -> f64 {
        self.0.to_f64()
    }

    /// Returns the underlying seconds value without converting fractions to `f64`.
    pub fn seconds_number(self) -> Number {
        self.0
    }

    /// Converts to a [`std::time::Duration`].
    pub fn duration(self) -> Result<std::time::Duration, std::time::TryFromFloatSecsError> {
        std::time::Duration::try_from_secs_f64(self.seconds())
    }

    /// Scale by a factor.
    ///
    /// Returns `None` if the resulting multiplcation produces is NaN (e.g. 0 × inf).
    pub fn scale(self, factor: f64) -> Option<Self> {
        self.0.checked_mul(Number::from(factor)).map(Self)
    }

    /// Scales by an exact fraction.
    pub fn scale_fraction(self, factor: Fraction) -> Option<Self> {
        self.0.checked_mul(Number::Fraction(factor)).map(Self)
    }
}

impl Add for ClockTime {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Self(non_nan_add(self.0, rhs.0))
    }
}

impl Sub for ClockTime {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        Self(non_nan_sub(self.0, rhs.0))
    }
}

impl Div for ClockTime {
    type Output = f64;
    fn div(self, rhs: Self) -> Self::Output {
        self.seconds() / rhs.seconds()
    }
}

/// Time measured in beats.
///
/// # Remarks:
/// NaN time values are disallowed, but infinities are allowed.
///
/// The concrete [`ClockTime`] of a beat time depends on the exact tempo change throughout the
/// song. It can be calculated with a [`super::TempoTrack`].
///
/// Addition and subtraction automatically produces positive infinity for INF - INF or -INF + INF
/// cases without panicking.
#[derive(Default, Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BeatTime(Number);

impl Eq for BeatTime {}

impl PartialOrd for BeatTime {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for BeatTime {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        // IMPORTANT: We do not use total_cmp because it defines -0.0 < 0.0
        self.0.partial_cmp(&other.0).expect("Time can not be NaN")
    }
}

impl BeatTime {
    pub const ZERO: Self = Self(Number::Float(0.0));
    pub const ONE: Self = Self(Number::Float(1.0));
    pub const INF: Self = Self(Number::Float(f64::INFINITY));

    /// Creates a beat time.
    ///
    /// Returns `None` only if `beats` is NaN.
    /// Infinite values are permitted.
    pub fn new(beats: f64) -> Option<Self> {
        Self::from_number(Number::from(beats))
    }

    /// Creates a beat time from an exact fraction.
    pub fn from_fraction(beats: Fraction) -> Self {
        Self(Number::Fraction(beats))
    }

    /// Creates a beat time from a [`Number`].
    pub fn from_number(number: Number) -> Option<Self> {
        (!number.is_nan()).then_some(Self(number))
    }

    pub fn beats(self) -> f64 {
        self.0.to_f64()
    }

    /// Returns the underlying beat value without converting fractions to `f64`.
    pub fn beats_number(self) -> Number {
        self.0
    }

    /// Scale by a factor.
    ///
    /// Returns `None` if the multiplication produces NaN (e.g. 0 × inf).
    pub fn scale(self, factor: f64) -> Option<Self> {
        self.0.checked_mul(Number::from(factor)).map(Self)
    }

    /// Scales by an exact fraction.
    pub fn scale_fraction(self, factor: Fraction) -> Option<Self> {
        self.0.checked_mul(Number::Fraction(factor)).map(Self)
    }
}

impl Add for BeatTime {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Self(non_nan_add(self.0, rhs.0))
    }
}

impl Sub for BeatTime {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        Self(non_nan_sub(self.0, rhs.0))
    }
}

impl Div for BeatTime {
    type Output = f64;
    fn div(self, rhs: Self) -> Self::Output {
        self.beats() / rhs.beats()
    }
}

/// A vec of time values that have the same unit.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SameUnitTimeVec {
    Clock(Vec<ClockTime>),
    Beat(Vec<BeatTime>),
}

impl SameUnitTimeVec {
    /// Creates [`SameUnitTimeVec`] from a list of Time.
    ///
    /// Returns None if all values don't havethe same unit.
    pub fn try_from_iter(times: impl ExactSizeIterator<Item = Time>) -> Option<Self> {
        let len = times.len();
        let mut peekable = times.peekable();
        let Some(first) = peekable.peek().copied() else {
            return Some(Self::Clock(vec![]));
        };
        match first {
            Time::Clock(_) => {
                let mut v = Vec::with_capacity(len);
                for t in peekable {
                    let Time::Clock(t) = t else {
                        return None;
                    };
                    v.push(t);
                }
                Some(Self::Clock(v))
            }
            Time::Beat(_) => {
                let mut v = Vec::with_capacity(len);
                for t in peekable {
                    let Time::Beat(t) = t else {
                        return None;
                    };
                    v.push(t);
                }
                Some(Self::Beat(v))
            }
        }
    }

    /// Creates [`SameUnitTimeVec`] from a list of Time.
    ///
    /// Unlike [`Self::from_iter`], since all values are proven to have the same unit, this is always
    /// valid.
    pub fn from_proven_iter<'id>(times: impl ExactSizeIterator<Item = SameUnitTime<'id>>) -> Self {
        Self::try_from_iter(times.map(|x| x.into())).expect("Proven to be same unit")
    }

    /// Gets the length of the collection.
    pub fn len(&self) -> usize {
        match self {
            Self::Clock(times) => times.len(),
            Self::Beat(times) => times.len(),
        }
    }

    /// Gets the length of the collection.
    pub fn is_empty(&self) -> bool {
        match self {
            Self::Clock(times) => times.is_empty(),
            Self::Beat(times) => times.is_empty(),
        }
    }

    /// Index into the vec.
    ///
    /// Standard vec panic rules apply, the index must not be out of bound.
    pub fn index(&self, i: usize) -> Time {
        match self {
            Self::Clock(times) => Time::Clock(times[i]),
            Self::Beat(times) => Time::Beat(times[i]),
        }
    }

    /// Check if a raw [Time] value has matching unit.
    pub fn unit_match(&self, t: Time) -> bool {
        matches!(
            (self, t),
            (SameUnitTimeVec::Clock(_), Time::Clock(_)) | (SameUnitTimeVec::Beat(_), Time::Beat(_))
        )
    }

    /// Try to insert a raw [`Time`] value into the vec.
    ///
    /// # Errors
    /// Returns an error if the index is out of bound, or if the time has non matching unit.
    pub fn try_insert(&mut self, index: usize, time: Time) -> Result<(), SameUnitTimeVecEditError> {
        match (self, time) {
            (SameUnitTimeVec::Clock(list), Time::Clock(t)) => {
                if index > list.len() {
                    return Err(SameUnitTimeVecEditError::OutOfBound);
                }
                list.insert(index, t);
                Ok(())
            }
            (SameUnitTimeVec::Beat(list), Time::Beat(t)) => {
                if index > list.len() {
                    return Err(SameUnitTimeVecEditError::OutOfBound);
                }
                list.insert(index, t);
                Ok(())
            }
            _ => Err(SameUnitTimeVecEditError::UnitMismatch),
        }
    }

    /// Try to set a raw [`Time`] value in the vec.
    ///
    /// # Errors
    /// Returns an error if the index is out of bound, or if the time has non matching unit.
    pub fn try_set(&mut self, index: usize, time: Time) -> Result<(), SameUnitTimeVecEditError> {
        match (self, time) {
            (SameUnitTimeVec::Clock(list), Time::Clock(t)) => {
                if index >= list.len() {
                    return Err(SameUnitTimeVecEditError::OutOfBound);
                }
                list[index] = t;
                Ok(())
            }
            (SameUnitTimeVec::Beat(list), Time::Beat(t)) => {
                if index >= list.len() {
                    return Err(SameUnitTimeVecEditError::OutOfBound);
                }
                list[index] = t;
                Ok(())
            }
            _ => Err(SameUnitTimeVecEditError::UnitMismatch),
        }
    }

    /// Removes a value from the vec.
    pub fn remove(&mut self, index: usize) -> Time {
        match self {
            SameUnitTimeVec::Clock(list) => Time::Clock(list.remove(index)),
            SameUnitTimeVec::Beat(list) => Time::Beat(list.remove(index)),
        }
    }

    /// Swap two values in the vec.
    pub fn swap(&mut self, i: usize, j: usize) {
        match self {
            SameUnitTimeVec::Clock(list) => list.swap(i, j),
            SameUnitTimeVec::Beat(list) => list.swap(i, j),
        }
    }

    /// Constructs a wrapper that allows proving values to have the same unit.
    ///
    /// See [SameUnitTime] for more details.
    pub fn read_with_guard<'id>(
        &'id self,
        g: generativity::Guard<'id>,
    ) -> SameUnitTimeVecRead<'id> {
        SameUnitTimeVecRead(self, g.into())
    }
}

/// A wrapper of [`SameUnitTimeVec`] that allows proving [`Time`] values to have matching unit.
///
/// See [`SameUnitTime`] for more details.
pub struct SameUnitTimeVecRead<'id>(&'id SameUnitTimeVec, generativity::Id<'id>);

impl<'id> SameUnitTimeVecRead<'id> {
    /// Index a a value of the vec.
    ///
    /// All values returned by this method are guaranteed to have the same unit.
    ///
    /// # Panics
    /// Standard vec indexing rule apply, the index must not be out of bound.
    pub fn index(&self, i: usize) -> SameUnitTime<'id> {
        SameUnitTime(self.0.index(i), self.1)
    }

    /// Proves that a raw [`Time`] value has the same unit with this vec.
    ///
    /// This reflexively proves that the value has the same unit as other values with the same
    /// 'id life time parameter.
    pub fn prove_same_unit(self, other: Time) -> Option<SameUnitTime<'id>> {
        match (self.0, other) {
            (SameUnitTimeVec::Clock(_), Time::Clock(_))
            | (SameUnitTimeVec::Beat(_), Time::Beat(_)) => Some(SameUnitTime(other, self.1)),
            _ => None,
        }
    }
}

#[derive(Debug)]
pub enum SameUnitTimeVecEditError {
    OutOfBound,
    UnitMismatch,
}

impl std::fmt::Display for SameUnitTimeVecEditError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SameUnitTimeVecEditError::OutOfBound => {
                write!(f, "Indexing a vec with an index that is out of bound")
            }
            SameUnitTimeVecEditError::UnitMismatch => {
                write!(
                    f,
                    "Adding an Time to a SameUnitVec that does not have matching unit"
                )
            }
        }
    }
}

impl std::error::Error for SameUnitTimeVecEditError {}

impl Default for SameUnitTimeVec {
    fn default() -> Self {
        Self::Clock(vec![])
    }
}

/// Adds two times, saturating failed checked arithmetic at positive infinity.
fn non_nan_add(a: Number, b: Number) -> Number {
    a.checked_add(b).unwrap_or(Number::Float(f64::INFINITY))
}

/// Subtracts two times, saturating failed checked arithmetic at positive infinity.
fn non_nan_sub(a: Number, b: Number) -> Number {
    a.checked_sub(b).unwrap_or(Number::Float(f64::INFINITY))
}

#[cfg(test)]
mod tests {
    use super::{BeatTime, ClockTime, Time};
    use crate::math::Fraction;

    fn fraction(numerator: i32, denominator: i32) -> Fraction {
        Fraction::new(numerator, denominator).unwrap()
    }

    #[test]
    fn fraction_constructors_keep_exact_values() {
        let half = fraction(1, 2);
        let beat = BeatTime::from_fraction(half);
        let clock = ClockTime::from_fraction_seconds(half);
        let millis = ClockTime::from_milis(fraction(125, 1)).unwrap();

        assert_eq!(beat.beats_number(), half.into());
        assert_eq!(clock.seconds_number(), half.into());
        assert_eq!(millis.seconds_number(), fraction(1, 8).into());
        assert_eq!(
            Time::clock_milis(fraction(125, 1)).unwrap(),
            Time::Clock(millis)
        );
    }

    #[test]
    fn fraction_scaling_stays_exact_and_reports_overflow() {
        let time = BeatTime::from_fraction(fraction(2, 3));
        assert_eq!(
            time.scale_fraction(fraction(3, 4)).unwrap().beats_number(),
            fraction(1, 2).into()
        );
        assert_eq!(
            BeatTime::from_fraction(fraction(i32::MAX, 1)).scale_fraction(fraction(2, 1)),
            None
        );
    }

    #[test]
    fn arithmetic_saturates_checked_failures_at_positive_infinity() {
        let too_large = ClockTime::from_fraction_seconds(fraction(i32::MAX, 1));
        assert_eq!(
            too_large + ClockTime::from_fraction_seconds(fraction(1, 1)),
            ClockTime::INF
        );
        assert_eq!(ClockTime::INF - ClockTime::INF, ClockTime::INF);
        assert_eq!(ClockTime::NEG_INF + ClockTime::INF, ClockTime::INF);
    }

    #[test]
    fn time_ordering_uses_exact_fraction_values() {
        let fraction_clock = ClockTime::from_fraction_seconds(fraction(1, 10));
        let float_clock = ClockTime::from_seconds(0.1).unwrap();
        assert_eq!(
            fraction_clock.partial_cmp(&float_clock),
            Some(std::cmp::Ordering::Less)
        );
        assert_eq!(fraction_clock.cmp(&float_clock), std::cmp::Ordering::Less);
        assert_ne!(fraction_clock, float_clock);

        let fraction_beat = BeatTime::from_fraction(fraction(1, 10));
        let float_beat = BeatTime::new(0.1).unwrap();
        assert_eq!(
            fraction_beat.partial_cmp(&float_beat),
            Some(std::cmp::Ordering::Less)
        );
        assert_eq!(fraction_beat.cmp(&float_beat), std::cmp::Ordering::Less);
        assert_ne!(fraction_beat, float_beat);
    }

    #[test]
    fn floating_point_constructors_still_reject_nan() {
        assert!(ClockTime::from_seconds(f64::NAN).is_none());
        assert!(BeatTime::new(f64::NAN).is_none());
        assert!(Time::beat(f64::NAN).is_none());
        assert!(Time::clock_secs(f64::NAN).is_none());
        assert!(Time::clock_milis(f64::NAN).is_none());
    }
}