fugit 0.4.0

use crate::helpers::{div_round_nearest_u64, Helpers};
use crate::NanosDurationU64;
use crate::Rate;
use crate::SecsDurationU64;
use core::cmp::Ordering;
use core::convert;
use core::ops;

/// Represents a duration of time.
///
/// The generic `T` can either be `u32` or `u64`, and the const generics represent the ratio of the
/// ticks contained within the duration: `duration in seconds = NOM / DENOM * ticks`
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(
    feature = "postcard_max_size",
    derive(postcard::experimental::max_size::MaxSize)
)]
#[derive(Clone, Copy, Debug)]
pub struct Duration<T, const NOM: u64, const DENOM: u64> {
    pub(crate) ticks: T,
}

// Unwrap a const-time `Option` or panic with the given static message. Lets the
// shorthand methods turn `checked_mul` failures into a clear panic at the user's
// call site instead of silently wrapping in release builds.
macro_rules! const_checked {
    ($e:expr, $msg:expr) => {
        match $e {
            Some(v) => v,
            None => panic!("{}", $msg),
        }
    };
}

macro_rules! shorthand {
    ($i:ty, $nom:literal, $denum:literal, $from_unit:ident, $as_unit:ident, $from_unital:ident, $unitstr:literal) => {
        #[doc = concat!("Convert the Duration to an integer number of ", $unitstr, ".")]
        #[doc = ""]
        #[doc = concat!("**Compile-time error** if the conversion constants don't fit in `", stringify!($i), "`. **Panics** if the multiplication overflows `", stringify!($i), "`.")]
        #[inline]
        #[track_caller]
        pub const fn $as_unit(&self) -> $i {
            const {
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN <= <$i>::MAX as u64,
                    concat!("Conversion constant RD_TIMES_LN doesn't fit in ", stringify!($i), " for this Duration type")
                );
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN <= <$i>::MAX as u64,
                    concat!("Conversion constant LD_TIMES_RN doesn't fit in ", stringify!($i), " for this Duration type")
                );
            }

            let prod = const_checked!(
                (Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN as $i).checked_mul(self.ticks),
                concat!("Duration::", stringify!($as_unit), ": multiplication overflowed storage type")
            );
            prod / Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN as $i
        }

        #[doc = concat!("Create a duration from a number of ", $unitstr, ".")]
        #[doc = ""]
        #[doc = concat!("**Compile-time error** if the conversion constants don't fit in `", stringify!($i), "`. **Panics** if the multiplication overflows `", stringify!($i), "`.")]
        #[inline]
        #[track_caller]
        pub const fn $from_unit(val: $i) -> Self {
            const {
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN <= <$i>::MAX as u64,
                    concat!("Conversion constant RD_TIMES_LN doesn't fit in ", stringify!($i), " for this Duration type")
                );
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN <= <$i>::MAX as u64,
                    concat!("Conversion constant LD_TIMES_RN doesn't fit in ", stringify!($i), " for this Duration type")
                );
            }

            let prod = const_checked!(
                (Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN as $i).checked_mul(val),
                concat!("Duration::", stringify!($from_unit), ": multiplication overflowed storage type")
            );
            Self::from_ticks(prod / Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN as $i)
        }

        #[doc = concat!("Create a duration from a number of ", $unitstr, " (ceil rounded).")]
        #[doc = ""]
        #[doc = concat!("**Compile-time error** if the conversion constants don't fit in `", stringify!($i), "`. **Panics** if the multiplication overflows `", stringify!($i), "`.")]
        #[inline]
        #[track_caller]
        pub const fn $from_unital(val: $i) -> Self {
            const {
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN <= <$i>::MAX as u64,
                    concat!("Conversion constant RD_TIMES_LN doesn't fit in ", stringify!($i), " for this Duration type")
                );
                assert!(
                    Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN <= <$i>::MAX as u64,
                    concat!("Conversion constant LD_TIMES_RN doesn't fit in ", stringify!($i), " for this Duration type")
                );
            }

            let mul = const_checked!(
                (Helpers::<$nom, $denum, NOM, DENOM>::RD_TIMES_LN as $i).checked_mul(val),
                concat!("Duration::", stringify!($from_unital), ": multiplication overflowed storage type")
            );
            let ld_times_rn = Helpers::<$nom, $denum, NOM, DENOM>::LD_TIMES_RN as $i;
            Self::from_ticks(mul.div_ceil(ld_times_rn))
        }
    };
}

macro_rules! impl_duration_for_integer {
    ($i:ty) => {
        impl<const NOM: u64, const DENOM: u64> Duration<$i, NOM, DENOM> {
            /// Create a `Duration` from a ticks value.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let _d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            /// ```
            #[inline]
            pub const fn from_ticks(ticks: $i) -> Self {
                const { assert!(NOM > 0) };
                const { assert!(DENOM > 0) };

                Duration { ticks }
            }

            /// Extract the ticks from a `Duration`.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(234);")]
            ///
            /// assert_eq!(d.as_ticks(), 234);
            /// ```
            #[inline]
            pub const fn as_ticks(&self) -> $i {
                self.ticks
            }

            /// A duration of zero time.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::ZERO;")]
            ///
            /// assert_eq!(d.as_ticks(), 0);
            /// assert!(d.is_zero());
            /// ```
            pub const ZERO: Self = Self::from_ticks(0);

            /// The maximum duration.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::MAX;")]
            ///
            #[doc = concat!("assert_eq!(d.as_ticks(), ", stringify!($i), "::MAX);")]
            /// ```
            pub const MAX: Self = Self::from_ticks(<$i>::MAX);

            /// Returns true if this `Duration` spans no time
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let zero = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(0);")]
            #[doc = concat!("let one = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            ///
            /// assert_eq!(zero.is_zero(), true);
            /// assert_eq!(one.is_zero(), false);
            /// ```
            #[inline]
            pub const fn is_zero(&self) -> bool {
                self.ticks == 0
            }

            /// Add two durations.
            ///
            /// Returns `None` on tick overflow or cross-base conversion overflow.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(2);")]
            #[doc = concat!("let d3 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(", stringify!($i), "::MAX);")]
            ///
            /// assert_eq!(d1.checked_add(d2).unwrap().as_ticks(), 3);
            /// assert_eq!(d1.checked_add(d3), None);
            /// ```
            pub const fn checked_add<const O_NOM: u64, const O_DENOM: u64>(
                self,
                other: Duration<$i, O_NOM, O_DENOM>,
            ) -> Option<Self> {
                if Helpers::<NOM, DENOM, O_NOM, O_DENOM>::SAME_BASE {
                    if let Some(ticks) = self.ticks.checked_add(other.ticks) {
                        Some(Self::from_ticks(ticks))
                    } else {
                        None
                    }
                } else {
                    if let Some(lh) = other
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, O_NOM, O_DENOM>::LD_TIMES_RN as $i)
                    {
                        let ticks = lh / Helpers::<NOM, DENOM, O_NOM, O_DENOM>::RD_TIMES_LN as $i;

                        if let Some(ticks) = self.ticks.checked_add(ticks) {
                            Some(Self::from_ticks(ticks))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                }
            }

            /// Subtract two durations.
            ///
            /// Returns `None` on tick underflow or cross-base conversion overflow.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(2);")]
            #[doc = concat!("let d3 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(", stringify!($i), "::MAX);")]
            ///
            /// assert_eq!(d2.checked_sub(d1).unwrap().as_ticks(), 1);
            /// assert_eq!(d1.checked_sub(d3), None);
            /// ```
            pub const fn checked_sub<const O_NOM: u64, const O_DENOM: u64>(
                self,
                other: Duration<$i, O_NOM, O_DENOM>,
            ) -> Option<Self> {
                if Helpers::<NOM, DENOM, O_NOM, O_DENOM>::SAME_BASE {
                    if let Some(ticks) = self.ticks.checked_sub(other.ticks) {
                        Some(Self::from_ticks(ticks))
                    } else {
                        None
                    }
                } else {
                    if let Some(lh) = other
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, O_NOM, O_DENOM>::LD_TIMES_RN as $i)
                    {
                        let ticks = lh / Helpers::<NOM, DENOM, O_NOM, O_DENOM>::RD_TIMES_LN as $i;

                        if let Some(ticks) = self.ticks.checked_sub(ticks) {
                            Some(Self::from_ticks(ticks))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                }
            }

            /// Multiply this duration by an integer while checking for overflow.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10);")]
            ///
            /// assert_eq!(d.checked_mul(3).unwrap().as_ticks(), 30);
            #[doc = concat!("assert_eq!(Duration::<", stringify!($i), ", 1, 1_000>::MAX.checked_mul(2), None);")]
            /// ```
            #[inline]
            pub const fn checked_mul(self, rhs: $i) -> Option<Self> {
                if let Some(ticks) = self.ticks.checked_mul(rhs) {
                    Some(Self::from_ticks(ticks))
                } else {
                    None
                }
            }

            /// Divide this duration by an integer while checking for division by zero.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(30);")]
            ///
            /// assert_eq!(d.checked_div(3).unwrap().as_ticks(), 10);
            #[doc = concat!("assert_eq!(Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10).checked_div(0), None);")]
            /// ```
            #[inline]
            pub const fn checked_div(self, rhs: $i) -> Option<Self> {
                if rhs == 0 {
                    None
                } else {
                    Some(Self::from_ticks(self.ticks / rhs))
                }
            }

            /// Remainder of dividing two durations.
            ///
            /// Returns `None` if `other` is zero or the cross-base conversion overflows.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(3);")]
            ///
            /// assert_eq!(d1.checked_rem(d2).unwrap().as_ticks(), 1);
            /// ```
            pub const fn checked_rem<const O_NOM: u64, const O_DENOM: u64>(
                self,
                other: Duration<$i, O_NOM, O_DENOM>,
            ) -> Option<Self> {
                if other.ticks == 0 {
                    None
                } else if Helpers::<NOM, DENOM, O_NOM, O_DENOM>::SAME_BASE {
                    Some(Self::from_ticks(self.ticks % other.ticks))
                } else {
                    if let Some(lh) = other
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, O_NOM, O_DENOM>::LD_TIMES_RN as $i)
                    {
                        let ticks = lh / Helpers::<NOM, DENOM, O_NOM, O_DENOM>::RD_TIMES_LN as $i;

                        if ticks > 0 {
                            Some(Self::from_ticks(self.ticks % ticks))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                }
            }

            /// Divide this duration by an integer, rounding up (ceiling division).
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(31);")]
            ///
            /// assert_eq!(d.div_ceil(3).as_ticks(), 11);
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(30);")]
            /// assert_eq!(d.div_ceil(3).as_ticks(), 10);
            /// ```
            ///
            /// # Panics
            ///
            /// This function will panic if `rhs` is zero.
            #[inline]
            #[track_caller]
            pub const fn div_ceil(self, rhs: $i) -> Self {
                Self::from_ticks(self.ticks.div_ceil(rhs))
            }

            /// Saturating duration addition. Computes `self + other`, saturating at the maximum value.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(2);")]
            ///
            /// assert_eq!(d1.saturating_add(d2).as_ticks(), 3);
            #[doc = concat!("assert_eq!(Duration::<", stringify!($i), ", 1, 1_000>::MAX.saturating_add(d1).as_ticks(), ", stringify!($i), "::MAX);")]
            /// ```
            pub const fn saturating_add<const O_NOM: u64, const O_DENOM: u64>(
                self,
                other: Duration<$i, O_NOM, O_DENOM>,
            ) -> Self {
                if let Some(result) = self.checked_add(other) {
                    result
                } else {
                    Self::MAX
                }
            }

            /// Saturating duration subtraction. Computes `self - other`, saturating at zero.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(2);")]
            ///
            /// assert_eq!(d1.saturating_sub(d2).as_ticks(), 8);
            /// assert_eq!(d2.saturating_sub(d1).as_ticks(), 0);
            /// ```
            pub const fn saturating_sub<const O_NOM: u64, const O_DENOM: u64>(
                self,
                other: Duration<$i, O_NOM, O_DENOM>,
            ) -> Self {
                if let Some(result) = self.checked_sub(other) {
                    result
                } else {
                    Self::ZERO
                }
            }

            /// Saturating duration multiplication. Computes `self * rhs`, saturating at the maximum value.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10);")]
            ///
            /// assert_eq!(d.saturating_mul(3).as_ticks(), 30);
            #[doc = concat!("assert_eq!(Duration::<", stringify!($i), ", 1, 1_000>::MAX.saturating_mul(2).as_ticks(), ", stringify!($i), "::MAX);")]
            /// ```
            #[inline]
            pub const fn saturating_mul(self, rhs: $i) -> Self {
                if let Some(result) = self.checked_mul(rhs) {
                    result
                } else {
                    Self::MAX
                }
            }

            #[doc = concat!("Const `cmp` for ", stringify!($i))]
            #[inline(always)]
            const fn _const_cmp(a: $i, b: $i) -> Ordering {
                if a < b {
                    Ordering::Less
                } else if a > b {
                    Ordering::Greater
                } else {
                    Ordering::Equal
                }
            }

            /// Const partial comparison.
            ///
            /// Returns `None` if either side's tick value cannot be expressed in
            /// the common base without overflowing the storage type.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 100>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(1);")]
            ///
            /// assert_eq!(d1.const_partial_cmp(d2), Some(core::cmp::Ordering::Greater));
            /// ```
            #[inline]
            pub const fn const_partial_cmp<const R_NOM: u64, const R_DENOM: u64>(
                self,
                other: Duration<$i, R_NOM, R_DENOM>
            ) -> Option<Ordering> {
                //
                // We want to check:
                //
                // n_lh / d_lh * lh_ticks {cmp} n_rh / d_rh * rh_ticks
                //
                // simplify to
                //
                // n_lh * d_rh * lh_ticks {cmp} n_rh * d_lh * rh_ticks
                //
                // find gdc(n_lh * d_rh, n_rh * d_lh) and use that to make the constants minimal (done
                // with the `helpers::Helpers` struct)
                //
                // then perform the comparison in a comparable basis
                //

                if Helpers::<NOM, DENOM, R_NOM, R_DENOM>::SAME_BASE {
                    // If we are in the same base, comparison in trivial
                    Some(Self::_const_cmp(self.ticks, other.ticks))
                } else {
                    let lh = self
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, R_NOM, R_DENOM>::RD_TIMES_LN as $i);
                    let rh = other
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, R_NOM, R_DENOM>::LD_TIMES_RN as $i);

                    if let (Some(lh), Some(rh)) = (lh, rh) {
                        Some(Self::_const_cmp(lh, rh))
                    } else {
                        None
                    }
                }
            }

            /// Const equality check.
            ///
            /// Returns `false` (rather than panicking) if the cross-base
            /// conversion overflows the storage type.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_00>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(10);")]
            ///
            /// assert!(d1.const_eq(d2));
            /// ```
            #[inline]
            pub const fn const_eq<const R_NOM: u64, const R_DENOM: u64>(
                self,
                other: Duration<$i, R_NOM, R_DENOM>
            ) -> bool {
                if Helpers::<NOM, DENOM, R_NOM, R_DENOM>::SAME_BASE {
                    // If we are in the same base, comparison in trivial
                    self.ticks == other.ticks
                } else {
                    let lh = self
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, R_NOM, R_DENOM>::RD_TIMES_LN as $i);
                    let rh = other
                        .ticks
                        .checked_mul(Helpers::<NOM, DENOM, R_NOM, R_DENOM>::LD_TIMES_RN as $i);

                    if let (Some(lh), Some(rh)) = (lh, rh) {
                        lh == rh
                    } else {
                        false
                    }
                }
            }

            /// Const try from, checking for overflow.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_00>::from_ticks(1);")]
            #[doc = concat!("let d2 = Duration::<", stringify!($i), ", 1, 1_000>::const_try_from(d1);")]
            ///
            /// assert_eq!(d2.unwrap().as_ticks(), 10);
            /// ```
            pub const fn const_try_from<const I_NOM: u64, const I_DENOM: u64>(
                duration: Duration<$i, I_NOM, I_DENOM>,
            ) -> Option<Self> {
                if Helpers::<I_NOM, I_DENOM, NOM, DENOM>::SAME_BASE {
                    Some(Self::from_ticks(duration.ticks))
                } else {
                    if let Some(lh) = (duration.ticks as u64)
                        .checked_mul(Helpers::<I_NOM, I_DENOM, NOM, DENOM>::RD_TIMES_LN)
                    {
                        let ticks = div_round_nearest_u64(
                            lh,
                            Helpers::<I_NOM, I_DENOM, NOM, DENOM>::LD_TIMES_RN,
                        );

                        if ticks <= <$i>::MAX as u64 {
                            Some(Self::from_ticks(ticks as $i))
                        } else {
                            None
                        }
                    } else {
                        None
                    }
                }
            }

            /// Const try into, checking for overflow.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_00>::from_ticks(1);")]
            #[doc = concat!("let d2: Option<Duration::<", stringify!($i), ", 1, 1_000>> = d1.const_try_into();")]
            ///
            /// assert_eq!(d2.unwrap().as_ticks(), 10);
            /// ```
            #[inline]
            pub const fn const_try_into<const O_NOM: u64, const O_DENOM: u64>(
                self,
            ) -> Option<Duration<$i, O_NOM, O_DENOM>> {
                Duration::<$i, O_NOM, O_DENOM>::const_try_from(self)
            }

            /// Convert to a rate. Returns `None` if this duration is zero.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::from_ticks(2);")]
            #[doc = concat!("let r1: Option<Rate::<", stringify!($i), ", 1, 1>> = d1.try_to_rate();")]
            ///
            /// assert_eq!(r1.unwrap().to_raw(), 500);
            /// ```
            #[inline]
            pub const fn try_to_rate<const O_NOM: u64, const O_DENOM: u64>(
                self,
            ) -> Option<Rate<$i, O_NOM, O_DENOM>> {
                Rate::<$i, O_NOM, O_DENOM>::try_from_duration(self)
            }

            /// Convert to a rate. Panics if this duration is zero.
            #[inline]
            #[track_caller]
            pub const fn to_rate<const O_NOM: u64, const O_DENOM: u64>(
                self,
            ) -> Rate<$i, O_NOM, O_DENOM> {
                if let Some(v) = self.try_to_rate() {
                    v
                } else {
                    panic!("Into rate failed, divide-by-zero!");
                }
            }

            /// Convert from a rate. Returns `None` if the rate is zero.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let r1 = Rate::<", stringify!($i), ", 1, 1>::from_raw(1);")]
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 1_000>::try_from_rate(r1);")]
            ///
            /// assert_eq!(d1.unwrap().as_ticks(), 1_000);
            /// ```
            #[inline]
            pub const fn try_from_rate<const I_NOM: u64, const I_DENOM: u64>(
                rate: Rate<$i, I_NOM, I_DENOM>,
            ) -> Option<Self> {
                const {
                    assert!(
                        Helpers::<I_NOM, I_DENOM, NOM, DENOM>::RATE_TO_DURATION_NUMERATOR <= <$i>::MAX as u64,
                        concat!("RATE_TO_DURATION_NUMERATOR doesn't fit in ", stringify!($i), " for this Rate/Duration combination")
                    );
                }
                if rate.raw > 0 {
                    Some(Self::from_ticks(
                        Helpers::<I_NOM, I_DENOM, NOM, DENOM>::RATE_TO_DURATION_NUMERATOR as $i
                        / rate.raw
                    ))
                } else {
                    None
                }
            }

            /// Convert from a rate. Panics if the rate is zero.
            #[inline]
            #[track_caller]
            pub const fn from_rate<const I_NOM: u64, const I_DENOM: u64>(
                rate: Rate<$i, I_NOM, I_DENOM>,
            ) -> Self {
                if let Some(v) = Self::try_from_rate(rate) {
                    v
                } else {
                    panic!("From rate failed, divide-by-zero!");
                }
            }

            /// Convert between bases for a duration, rounds to nearest.
            ///
            /// Unfortunately not a `From` impl due to collision with the std lib.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d1 = Duration::<", stringify!($i), ", 1, 100>::from_ticks(1);")]
            #[doc = concat!("let d2: Duration::<", stringify!($i), ", 1, 1_000> = d1.convert();")]
            ///
            /// assert_eq!(d2.as_ticks(), 10);
            /// ```
            /// Can be used in const contexts. Compilation will fail if the conversion causes overflow
            /// ```compile_fail
            /// # use fugit::*;
            #[doc = concat!("const TICKS: ", stringify!($i), "= ", stringify!($i), "::MAX - 10;")]
            #[doc = concat!("const D1: Duration::<", stringify!($i), ", 1, 100> = Duration::<", stringify!($i), ", 1, 100>::from_ticks(TICKS);")]
            /// // Fails conversion due to tick overflow
            #[doc = concat!("const D2: Duration::<", stringify!($i), ", 1, 200> = D1.convert();")]
            #[inline]
            #[track_caller]
            pub const fn convert<const O_NOM: u64, const O_DENOM: u64>(
                self,
            ) -> Duration<$i, O_NOM, O_DENOM> {
                if let Some(v) = self.const_try_into() {
                    v
                } else {
                    panic!("Convert failed!");
                }
            }

            shorthand!($i, 1, 1_000_000_000_000, from_picos, as_picos, from_picos_at_least, "picoseconds");
            shorthand!($i, 1, 1_000_000_000, from_nanos, as_nanos, from_nanos_at_least, "nanoseconds");
            shorthand!($i, 1, 1_000_000, from_micros, as_micros, from_micros_at_least, "microseconds");
            shorthand!($i, 1, 1_000, from_millis, as_millis, from_millis_at_least, "milliseconds");
            shorthand!($i, 1, 1, from_secs, as_secs, from_secs_at_least, "seconds");
            shorthand!($i, 60, 1, from_minutes, as_minutes, from_minutes_at_least, "minutes");
            shorthand!($i, 3600, 1, from_hours, as_hours, from_hours_at_least, "hours");

            /// Convert the Duration to a floating point number of seconds.
            #[inline]
            pub const fn as_secs_f32(&self) -> f32 {
                let factor = const { NOM as f32 / DENOM as f32 };
                factor * self.ticks as f32
            }

            /// Convert the Duration to a floating point number of seconds.
            #[inline]
            pub const fn as_secs_f64(&self) -> f64 {
                let factor = const { NOM as f64 / DENOM as f64 };
                factor * self.ticks as f64
            }

            /// Create a duration from a floating point number of seconds.
            ///
            /// The value is rounded to the nearest tick.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_secs_f32(1.5);")]
            ///
            /// assert_eq!(d.as_ticks(), 1_500);
            ///
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_secs_f32(1.5005);")]
            /// assert_eq!(d.as_ticks(), 1_501);
            /// ```
            #[inline]
            pub const fn from_secs_f32(secs: f32) -> Self {
                let factor = const { DENOM as f32 / NOM as f32 };
                Self::from_ticks((secs * factor + 0.5) as $i)
            }

            /// Create a duration from a floating point number of seconds.
            ///
            /// The value is rounded to the nearest tick.
            ///
            /// ```
            /// # use fugit::*;
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_secs_f64(1.5);")]
            ///
            /// assert_eq!(d.as_ticks(), 1_500);
            ///
            #[doc = concat!("let d = Duration::<", stringify!($i), ", 1, 1_000>::from_secs_f64(1.5005);")]
            /// assert_eq!(d.as_ticks(), 1_501);
            /// ```
            #[inline]
            pub const fn from_secs_f64(secs: f64) -> Self {
                let factor = const { DENOM as f64 / NOM as f64 };
                Self::from_ticks((secs * factor + 0.5) as $i)
            }

            /// Period of a hertz rate. Panics if `val` is zero.
            #[inline]
            #[track_caller]
            #[allow(non_snake_case)]
            pub const fn Hz(val: $i) -> Self {
                Self::from_rate(crate::Hertz::<$i>::from_raw(val))
            }

            /// Period of a kilohertz rate. Panics if `val` is zero.
            #[inline]
            #[track_caller]
            #[allow(non_snake_case)]
            pub const fn kHz(val: $i) -> Self {
                Self::from_rate(crate::Kilohertz::<$i>::from_raw(val))
            }

            /// Period of a megahertz rate. Panics if `val` is zero.
            #[inline]
            #[track_caller]
            #[allow(non_snake_case)]
            pub const fn MHz(val: $i) -> Self {
                Self::from_rate(crate::Megahertz::<$i>::from_raw(val))
            }
        }

        impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
            PartialOrd<Duration<$i, R_NOM, R_DENOM>> for Duration<$i, L_NOM, L_DENOM>
        {
            #[inline]
            fn partial_cmp(&self, other: &Duration<$i, R_NOM, R_DENOM>) -> Option<Ordering> {
                self.const_partial_cmp(*other)
            }
        }

        impl<const NOM: u64, const DENOM: u64> Ord for Duration<$i, NOM, DENOM> {
            #[inline]
            fn cmp(&self, other: &Self) -> Ordering {
                Self::_const_cmp(self.ticks, other.ticks)
            }
        }

        impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
            PartialEq<Duration<$i, R_NOM, R_DENOM>> for Duration<$i, L_NOM, L_DENOM>
        {
            #[inline]
            fn eq(&self, other: &Duration<$i, R_NOM, R_DENOM>) -> bool {
                self.const_eq(*other)
            }
        }

        impl<const NOM: u64, const DENOM: u64> Eq for Duration<$i, NOM, DENOM> {}

        // Duration - Duration = Duration (only same base until const_generics_defaults is
        // stabilized)
        impl<const NOM: u64, const DENOM: u64> ops::Sub for Duration<$i, NOM, DENOM>
        {
            type Output = Self;

            #[inline]
            #[track_caller]
            fn sub(self, other: Self) -> Self::Output {
                if let Some(v) = self.checked_sub(other) {
                    v
                } else {
                    panic!("Sub failed!");
                }
            }
        }

        // Duration -= Duration
        impl<const NOM: u64, const DENOM: u64> ops::SubAssign for Duration<$i, NOM, DENOM>
        {
            #[inline]
            #[track_caller]
            fn sub_assign(&mut self, other: Self) {
                *self = *self - other;
            }
        }

        // Duration + Duration = Duration (only same base until const_generics_defaults is
        // stabilized)
        impl<const NOM: u64, const DENOM: u64> ops::Add for Duration<$i, NOM, DENOM>
        {
            type Output = Self;

            #[inline]
            #[track_caller]
            fn add(self, other: Self) -> Self::Output {
                if let Some(v) = self.checked_add(other) {
                    v
                } else {
                    panic!("Add failed!");
                }
            }
        }

        // Duration += Duration
        impl<const NOM: u64, const DENOM: u64> ops::AddAssign for Duration<$i, NOM, DENOM>
        {
            #[inline]
            #[track_caller]
            fn add_assign(&mut self, other: Self) {
                *self = *self + other;
            }
        }

        // integer * Duration = Duration
        impl<const NOM: u64, const DENOM: u64> ops::Mul<Duration<$i, NOM, DENOM>> for u32 {
            type Output = Duration<$i, NOM, DENOM>;

            #[inline]
            #[track_caller]
            fn mul(self, mut other: Duration<$i, NOM, DENOM>) -> Self::Output {
                other.ticks *= self as $i;
                other
            }
        }

        // Duration * integer = Duration
        impl<const NOM: u64, const DENOM: u64> ops::Mul<u32> for Duration<$i, NOM, DENOM> {
            type Output = Self;

            #[inline]
            #[track_caller]
            fn mul(mut self, other: u32) -> Self::Output {
                self.ticks *= other as $i;
                self
            }
        }

        // Duration *= integer
        impl<const NOM: u64, const DENOM: u64> ops::MulAssign<u32>
            for Duration<$i, NOM, DENOM>
        {
            #[inline]
            #[track_caller]
            fn mul_assign(&mut self, other: u32) {
                *self = *self * other;
            }
        }

        // Duration / integer = Duration
        impl<const NOM: u64, const DENOM: u64> ops::Div<u32> for Duration<$i, NOM, DENOM> {
            type Output = Self;

            #[inline]
            #[track_caller]
            fn div(mut self, other: u32) -> Self::Output {
                self.ticks /= other as $i;
                self
            }
        }

        // Duration /= integer
        impl<const NOM: u64, const DENOM: u64> ops::DivAssign<u32>
            for Duration<$i, NOM, DENOM>
        {
            #[inline]
            #[track_caller]
            fn div_assign(&mut self, other: u32) {
                *self = *self / other;
            }
        }

        // Duration % Duration = Duration (only same base until const_generics_defaults is
        // stabilized)
        impl<const NOM: u64, const DENOM: u64> ops::Rem for Duration<$i, NOM, DENOM>
        {
            type Output = Self;

            #[inline]
            #[track_caller]
            fn rem(self, other: Self) -> Self::Output {
                if let Some(v) = self.checked_rem(other) {
                    v
                } else {
                    panic!("Rem failed!");
                }
            }
        }

        // Duration %= Duration
        impl<const NOM: u64, const DENOM: u64> ops::RemAssign for Duration<$i, NOM, DENOM>
        {
            #[inline]
            #[track_caller]
            fn rem_assign(&mut self, other: Self) {
                *self = *self % other;
            }
        }

        // Duration / Duration = integer
        impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64> ops::Div<Duration<$i, R_NOM, R_DENOM>>
            for Duration<$i, L_NOM, L_DENOM>
        {
            type Output = $i;

            #[inline]
            #[track_caller]
            fn div(self, other: Duration<$i, R_NOM, R_DENOM>) -> Self::Output {
                let conv: Duration<$i, R_NOM, R_DENOM> = self.convert();
                conv.ticks / other.ticks
            }
        }

        #[cfg(feature = "defmt")]
        impl<const NOM: u64, const DENOM: u64> defmt::Format for Duration<$i, NOM, DENOM>
        {
            fn format(&self, f: defmt::Formatter) {
                if NOM == 3_600 && DENOM == 1 {
                    defmt::write!(f, "{} h", self.ticks)
                } else if NOM == 60 && DENOM == 1 {
                    defmt::write!(f, "{} min", self.ticks)
                } else if NOM == 1 && DENOM == 1 {
                    defmt::write!(f, "{} s", self.ticks)
                } else if NOM == 1 && DENOM == 1_000 {
                    defmt::write!(f, "{} ms", self.ticks)
                } else if NOM == 1 && DENOM == 1_000_000 {
                    defmt::write!(f, "{} us", self.ticks)
                } else if NOM == 1 && DENOM == 1_000_000_000 {
                    defmt::write!(f, "{} ns", self.ticks)
                } else {
                    defmt::write!(f, "{} ticks @ ({}/{})", self.ticks, NOM, DENOM)
                }
            }
        }

        impl<const NOM: u64, const DENOM: u64> core::fmt::Display for Duration<$i, NOM, DENOM> {
            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                if NOM == 3_600 && DENOM == 1 {
                    write!(f, "{} h", self.ticks)
                } else if NOM == 60 && DENOM == 1 {
                    write!(f, "{} min", self.ticks)
                } else if NOM == 1 && DENOM == 1 {
                    write!(f, "{} s", self.ticks)
                } else if NOM == 1 && DENOM == 1_000 {
                    write!(f, "{} ms", self.ticks)
                } else if NOM == 1 && DENOM == 1_000_000 {
                    write!(f, "{} us", self.ticks)
                } else if NOM == 1 && DENOM == 1_000_000_000 {
                    write!(f, "{} ns", self.ticks)
                } else {
                    write!(f, "{} ticks @ ({}/{})", self.ticks, NOM, DENOM)
                }
            }
        }
    };
}

impl_duration_for_integer!(u32);
impl_duration_for_integer!(u64);

//
// Conversion from core::time::Duration
//

impl<const NOM: u64, const DENOM: u64> convert::TryFrom<core::time::Duration>
    for Duration<u32, NOM, DENOM>
{
    type Error = ();

    #[inline]
    fn try_from(val: core::time::Duration) -> Result<Self, Self::Error> {
        Duration::<u64, NOM, DENOM>::try_from(val)?.try_into()
    }
}

impl<const NOM: u64, const DENOM: u64> convert::TryFrom<core::time::Duration>
    for Duration<u64, NOM, DENOM>
{
    type Error = ();

    #[inline]
    fn try_from(val: core::time::Duration) -> Result<Self, Self::Error> {
        let secs_duration = SecsDurationU64::from_ticks(val.as_secs());
        let nanos_duration = NanosDurationU64::from_ticks(val.subsec_nanos() as u64);

        let secs_converted: Self = secs_duration.const_try_into().ok_or(())?;
        let nanos_converted: Self = nanos_duration.const_try_into().ok_or(())?;

        secs_converted.checked_add(nanos_converted).ok_or(())
    }
}

//
// Conversion to core::time::Duration
//

impl<const NOM: u64, const DENOM: u64> From<Duration<u32, NOM, DENOM>> for core::time::Duration {
    #[inline]
    fn from(val: Duration<u32, NOM, DENOM>) -> Self {
        let val_u64: Duration<u64, NOM, DENOM> = val.into();
        core::time::Duration::from(val_u64)
    }
}

impl<const NOM: u64, const DENOM: u64> From<Duration<u64, NOM, DENOM>> for core::time::Duration {
    #[inline]
    fn from(val: Duration<u64, NOM, DENOM>) -> Self {
        let secs = val.as_secs();
        let secs_duration = Duration::<u64, NOM, DENOM>::from_secs(secs);
        let remainder = val.saturating_sub(secs_duration);
        let nanos = remainder.as_nanos() as u32;

        core::time::Duration::new(secs, nanos)
    }
}

//
// Operations between u32 and u64 Durations
//

impl<const NOM: u64, const DENOM: u64> From<Duration<u32, NOM, DENOM>>
    for Duration<u64, NOM, DENOM>
{
    #[inline]
    fn from(val: Duration<u32, NOM, DENOM>) -> Self {
        Duration::<u64, NOM, DENOM>::from_ticks(val.as_ticks() as u64)
    }
}

impl<const NOM: u64, const DENOM: u64> convert::TryFrom<Duration<u64, NOM, DENOM>>
    for Duration<u32, NOM, DENOM>
{
    type Error = ();

    #[inline]
    fn try_from(val: Duration<u64, NOM, DENOM>) -> Result<Self, ()> {
        Ok(Duration::<u32, NOM, DENOM>::from_ticks(
            val.as_ticks().try_into().map_err(|_| ())?,
        ))
    }
}

// Duration - Duration = Duration (to make shorthands work, until const_generics_defaults is
// stabilized)
impl<const NOM: u64, const DENOM: u64> ops::Sub<Duration<u32, NOM, DENOM>>
    for Duration<u64, NOM, DENOM>
{
    type Output = Self;

    #[inline]
    #[track_caller]
    fn sub(self, other: Duration<u32, NOM, DENOM>) -> Self::Output {
        if let Some(v) = self.checked_sub(Self::from_ticks(other.as_ticks() as u64)) {
            v
        } else {
            panic!("Sub failed!");
        }
    }
}

// Duration -= Duration (to make shorthands work, until const_generics_defaults is stabilized)
impl<const NOM: u64, const DENOM: u64> ops::SubAssign<Duration<u32, NOM, DENOM>>
    for Duration<u64, NOM, DENOM>
{
    #[inline]
    #[track_caller]
    fn sub_assign(&mut self, other: Duration<u32, NOM, DENOM>) {
        *self = *self - other;
    }
}

// Duration + Duration = Duration (to make shorthands work, until const_generics_defaults is
// stabilized)
impl<const NOM: u64, const DENOM: u64> ops::Add<Duration<u32, NOM, DENOM>>
    for Duration<u64, NOM, DENOM>
{
    type Output = Self;

    #[inline]
    #[track_caller]
    fn add(self, other: Duration<u32, NOM, DENOM>) -> Self::Output {
        if let Some(v) = self.checked_add(Self::from_ticks(other.as_ticks() as u64)) {
            v
        } else {
            panic!("Add failed!");
        }
    }
}

// Duration += Duration (to make shorthands work, until const_generics_defaults is stabilized)
impl<const NOM: u64, const DENOM: u64> ops::AddAssign<Duration<u32, NOM, DENOM>>
    for Duration<u64, NOM, DENOM>
{
    #[inline]
    #[track_caller]
    fn add_assign(&mut self, other: Duration<u32, NOM, DENOM>) {
        *self = *self + other;
    }
}

impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
    PartialOrd<Duration<u32, R_NOM, R_DENOM>> for Duration<u64, L_NOM, L_DENOM>
{
    #[inline]
    fn partial_cmp(&self, other: &Duration<u32, R_NOM, R_DENOM>) -> Option<Ordering> {
        self.partial_cmp(&Duration::<u64, R_NOM, R_DENOM>::from_ticks(
            other.as_ticks() as u64,
        ))
    }
}

impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
    PartialEq<Duration<u32, R_NOM, R_DENOM>> for Duration<u64, L_NOM, L_DENOM>
{
    #[inline]
    fn eq(&self, other: &Duration<u32, R_NOM, R_DENOM>) -> bool {
        self.eq(&Duration::<u64, R_NOM, R_DENOM>::from_ticks(
            other.as_ticks() as u64,
        ))
    }
}

impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
    PartialOrd<Duration<u64, R_NOM, R_DENOM>> for Duration<u32, L_NOM, L_DENOM>
{
    #[inline]
    fn partial_cmp(&self, other: &Duration<u64, R_NOM, R_DENOM>) -> Option<Ordering> {
        Duration::<u64, L_NOM, L_DENOM>::from_ticks(self.ticks as u64).partial_cmp(other)
    }
}

impl<const L_NOM: u64, const L_DENOM: u64, const R_NOM: u64, const R_DENOM: u64>
    PartialEq<Duration<u64, R_NOM, R_DENOM>> for Duration<u32, L_NOM, L_DENOM>
{
    #[inline]
    fn eq(&self, other: &Duration<u64, R_NOM, R_DENOM>) -> bool {
        Duration::<u64, L_NOM, L_DENOM>::from_ticks(self.ticks as u64).eq(other)
    }
}

/// Extension trait for simple short-hands for u32 Durations
pub trait ExtU32 {
    /// Shorthand for creating a duration which represents picoseconds.
    fn picos<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents nanoseconds.
    fn nanos<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents microseconds.
    fn micros<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents milliseconds.
    fn millis<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents seconds.
    fn secs<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents minutes.
    fn minutes<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents hours.
    fn hours<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;
}

impl ExtU32 for u32 {
    #[inline]
    fn picos<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_picos(self)
    }

    #[inline]
    fn nanos<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_nanos(self)
    }

    #[inline]
    fn micros<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_micros(self)
    }

    #[inline]
    fn millis<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_millis(self)
    }

    #[inline]
    fn secs<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_secs(self)
    }

    #[inline]
    fn minutes<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_minutes(self)
    }

    #[inline]
    fn hours<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_hours(self)
    }
}

/// Extension trait for simple short-hands for u32 Durations (ceil rounded)
pub trait ExtU32Ceil {
    /// Shorthand for creating a duration which represents picoseconds.
    fn picos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents nanoseconds.
    fn nanos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents microseconds.
    fn micros_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents milliseconds.
    fn millis_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents seconds.
    fn secs_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents minutes.
    fn minutes_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;

    /// Shorthand for creating a duration which represents hours.
    fn hours_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM>;
}

impl ExtU32Ceil for u32 {
    #[inline]
    fn picos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_picos_at_least(self)
    }

    #[inline]
    fn nanos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_nanos_at_least(self)
    }

    #[inline]
    fn micros_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_micros_at_least(self)
    }

    #[inline]
    fn millis_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_millis_at_least(self)
    }

    #[inline]
    fn secs_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_secs_at_least(self)
    }

    #[inline]
    fn minutes_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_minutes_at_least(self)
    }

    #[inline]
    fn hours_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u32, NOM, DENOM> {
        Duration::<u32, NOM, DENOM>::from_hours_at_least(self)
    }
}

/// Extension trait for simple short-hands for u64 Durations
pub trait ExtU64 {
    /// Shorthand for creating a duration which represents picoseconds.
    fn picos<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents nanoseconds.
    fn nanos<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents microseconds.
    fn micros<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents milliseconds.
    fn millis<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents seconds.
    fn secs<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents minutes.
    fn minutes<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents hours.
    fn hours<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;
}

impl ExtU64 for u64 {
    #[inline]
    fn picos<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_picos(self)
    }

    #[inline]
    fn nanos<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_nanos(self)
    }

    #[inline]
    fn micros<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_micros(self)
    }

    #[inline]
    fn millis<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_millis(self)
    }

    #[inline]
    fn secs<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_secs(self)
    }

    #[inline]
    fn minutes<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_minutes(self)
    }

    #[inline]
    fn hours<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_hours(self)
    }
}

/// Extension trait for simple short-hands for u64 Durations (ceil rounded)
pub trait ExtU64Ceil {
    /// Shorthand for creating a duration which represents picoseconds.
    fn picos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents nanoseconds.
    fn nanos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents microseconds.
    fn micros_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents milliseconds.
    fn millis_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents seconds.
    fn secs_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents minutes.
    fn minutes_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;

    /// Shorthand for creating a duration which represents hours.
    fn hours_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM>;
}

impl ExtU64Ceil for u64 {
    #[inline]
    fn picos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_picos_at_least(self)
    }

    #[inline]
    fn nanos_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_nanos_at_least(self)
    }

    #[inline]
    fn micros_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_micros_at_least(self)
    }

    #[inline]
    fn millis_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_millis_at_least(self)
    }

    #[inline]
    fn secs_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_secs_at_least(self)
    }

    #[inline]
    fn minutes_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_minutes_at_least(self)
    }

    #[inline]
    fn hours_at_least<const NOM: u64, const DENOM: u64>(self) -> Duration<u64, NOM, DENOM> {
        Duration::<u64, NOM, DENOM>::from_hours_at_least(self)
    }
}