unit_intervals/

signed_unit_interval.rs

use core::{
    cmp::Ordering,
    error::Error,
    fmt,
    ops::{Add, Deref, Div, Mul, Neg, Rem, Sub},
};

use crate::{UnitInterval, UnitIntervalError, UnitIntervalFloat};

/// A floating-point value constrained to the closed signed unit interval `[-1, 1]`.
///
/// `SignedUnitInterval` is useful for normalized signed values such as direction,
/// balance, centered offsets, joystick axes, and correlation-like coefficients.
#[cfg_attr(
    feature = "rkyv",
    derive(::rkyv::Archive, ::rkyv::Serialize),
    rkyv(crate = ::rkyv)
)]
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct SignedUnitInterval<T = f32>(T);

/// Error returned when converting an out-of-range value into a [`SignedUnitInterval`].
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct SignedUnitIntervalError;

impl fmt::Display for SignedUnitIntervalError {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("value is outside the signed unit interval")
    }
}

impl Error for SignedUnitIntervalError {}

#[cfg(feature = "rkyv")]
#[cfg_attr(docsrs, doc(cfg(feature = "rkyv")))]
mod rkyv {
    use super::*;
    use ::rkyv::{
        Archive, Deserialize,
        rancor::{Fallible, Source, fail},
    };

    impl<T, D> Deserialize<SignedUnitInterval<T>, D> for ArchivedSignedUnitInterval<T>
    where
        T: Archive + UnitIntervalFloat,
        T::Archived: Deserialize<T, D>,
        D: Fallible + ?Sized,
        D::Error: Source,
    {
        #[inline]
        fn deserialize(&self, deserializer: &mut D) -> Result<SignedUnitInterval<T>, D::Error> {
            let value = self.0.deserialize(deserializer)?;

            if let Some(value) = SignedUnitInterval::new(value) {
                Ok(value)
            } else {
                fail!(SignedUnitIntervalError);
            }
        }
    }
}

#[cfg(feature = "serde")]
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
mod serde {
    use super::*;
    use ::serde::{Deserialize, Deserializer, Serialize, Serializer, de};

    impl<T: Serialize> Serialize for SignedUnitInterval<T> {
        #[inline]
        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
            self.0.serialize(serializer)
        }
    }

    impl<'de, T> Deserialize<'de> for SignedUnitInterval<T>
    where
        T: UnitIntervalFloat + Deserialize<'de>,
    {
        #[inline]
        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
            // Keep deserialization on the same invariant-preserving path as
            // construction from a raw float. Serialization is intentionally
            // transparent, so the data format only stores the inner value and
            // cannot encode whether that value came from a previously checked
            // `SignedUnitInterval`. Treating decoded input as trusted wrapper
            // state would let out-of-range values and `NaN` bypass the type's
            // public contract. Decoding the backing value first and then
            // routing it through `new` gives every serde format the same
            // behavior as `TryFrom<T>`: valid values reconstruct the wrapper,
            // and invalid values become ordinary deserialization errors.
            let value = T::deserialize(deserializer)?;

            Self::new(value).ok_or_else(|| de::Error::custom(SignedUnitIntervalError))
        }
    }
}

#[cfg(feature = "bytemuck")]
#[cfg_attr(docsrs, doc(cfg(feature = "bytemuck")))]
mod bytemuck {
    use super::*;

    unsafe impl<T> ::bytemuck::Zeroable for SignedUnitInterval<T> where
        T: UnitIntervalFloat + ::bytemuck::Zeroable
    {
    }

    unsafe impl<T> ::bytemuck::NoUninit for SignedUnitInterval<T> where
        T: UnitIntervalFloat + ::bytemuck::NoUninit
    {
    }

    unsafe impl<T> ::bytemuck::CheckedBitPattern for SignedUnitInterval<T>
    where
        T: UnitIntervalFloat + ::bytemuck::AnyBitPattern,
    {
        type Bits = T;

        #[inline]
        fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
            SignedUnitInterval::contains(*bits)
        }
    }
}

#[cfg(feature = "arbitrary")]
#[cfg_attr(docsrs, doc(cfg(feature = "arbitrary")))]
mod arbitrary {
    use super::*;
    use ::arbitrary::{Arbitrary, Result, Unstructured};

    macro_rules! impl_arbitrary_signed_unit_interval {
        ($float:ty, $unsigned:ty) => {
            impl<'a> Arbitrary<'a> for SignedUnitInterval<$float> {
                #[inline]
                fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
                    let raw = <$unsigned as Arbitrary<'a>>::arbitrary(u)?;
                    let unit = raw as $float / <$unsigned>::MAX as $float;
                    let value = unit * 2.0 - 1.0;

                    Ok(Self::from_inner(value))
                }

                #[inline]
                fn size_hint(depth: usize) -> (usize, Option<usize>) {
                    <$unsigned as Arbitrary<'a>>::size_hint(depth)
                }
            }
        };
    }

    impl_arbitrary_signed_unit_interval!(f32, u32);
    impl_arbitrary_signed_unit_interval!(f64, u64);
}

#[cfg(feature = "num-traits")]
#[cfg_attr(docsrs, doc(cfg(feature = "num-traits")))]
mod num_traits {
    use super::*;
    use ::num_traits::{
        AsPrimitive, Bounded, ConstOne, FromPrimitive, NumCast, One, Pow, ToBytes, ToPrimitive,
        ops::{
            checked::{CheckedMul, CheckedNeg},
            saturating::SaturatingMul,
        },
    };

    macro_rules! impl_num_traits_signed_unit_interval {
        ($float:ty) => {
            impl ToPrimitive for SignedUnitInterval<$float> {
                #[inline]
                fn to_isize(&self) -> Option<isize> {
                    self.0.to_isize()
                }

                #[inline]
                fn to_i8(&self) -> Option<i8> {
                    self.0.to_i8()
                }

                #[inline]
                fn to_i16(&self) -> Option<i16> {
                    self.0.to_i16()
                }

                #[inline]
                fn to_i32(&self) -> Option<i32> {
                    self.0.to_i32()
                }

                #[inline]
                fn to_i64(&self) -> Option<i64> {
                    self.0.to_i64()
                }

                #[inline]
                fn to_i128(&self) -> Option<i128> {
                    self.0.to_i128()
                }

                #[inline]
                fn to_usize(&self) -> Option<usize> {
                    self.0.to_usize()
                }

                #[inline]
                fn to_u8(&self) -> Option<u8> {
                    self.0.to_u8()
                }

                #[inline]
                fn to_u16(&self) -> Option<u16> {
                    self.0.to_u16()
                }

                #[inline]
                fn to_u32(&self) -> Option<u32> {
                    self.0.to_u32()
                }

                #[inline]
                fn to_u64(&self) -> Option<u64> {
                    self.0.to_u64()
                }

                #[inline]
                fn to_u128(&self) -> Option<u128> {
                    self.0.to_u128()
                }

                #[inline]
                fn to_f32(&self) -> Option<f32> {
                    self.0.to_f32()
                }

                #[inline]
                fn to_f64(&self) -> Option<f64> {
                    self.0.to_f64()
                }
            }

            impl FromPrimitive for SignedUnitInterval<$float> {
                #[inline]
                fn from_i64(n: i64) -> Option<Self> {
                    <$float as FromPrimitive>::from_i64(n).and_then(Self::new)
                }

                #[inline]
                fn from_u64(n: u64) -> Option<Self> {
                    <$float as FromPrimitive>::from_u64(n).and_then(Self::new)
                }

                #[inline]
                fn from_f32(n: f32) -> Option<Self> {
                    <$float as FromPrimitive>::from_f32(n).and_then(Self::new)
                }

                #[inline]
                fn from_f64(n: f64) -> Option<Self> {
                    <$float as FromPrimitive>::from_f64(n).and_then(Self::new)
                }
            }

            impl NumCast for SignedUnitInterval<$float> {
                #[inline]
                fn from<T: ToPrimitive>(n: T) -> Option<Self> {
                    <$float as NumCast>::from(n).and_then(Self::new)
                }
            }

            impl One for SignedUnitInterval<$float> {
                #[inline]
                fn one() -> Self {
                    Self::ONE
                }

                #[inline]
                fn is_one(&self) -> bool {
                    SignedUnitInterval::is_one(*self)
                }
            }

            impl ConstOne for SignedUnitInterval<$float> {
                const ONE: Self = Self::ONE;
            }

            impl Bounded for SignedUnitInterval<$float> {
                #[inline]
                fn min_value() -> Self {
                    Self::NEG_ONE
                }

                #[inline]
                fn max_value() -> Self {
                    Self::ONE
                }
            }

            impl ToBytes for SignedUnitInterval<$float> {
                type Bytes = <$float as ToBytes>::Bytes;

                #[inline]
                fn to_be_bytes(&self) -> Self::Bytes {
                    self.0.to_be_bytes()
                }

                #[inline]
                fn to_le_bytes(&self) -> Self::Bytes {
                    self.0.to_le_bytes()
                }

                #[inline]
                fn to_ne_bytes(&self) -> Self::Bytes {
                    self.0.to_ne_bytes()
                }
            }

            impl CheckedMul for SignedUnitInterval<$float> {
                #[inline]
                fn checked_mul(&self, v: &Self) -> Option<Self> {
                    Some(*self * *v)
                }
            }

            impl CheckedNeg for SignedUnitInterval<$float> {
                #[inline]
                fn checked_neg(&self) -> Option<Self> {
                    Some(-*self)
                }
            }

            impl SaturatingMul for SignedUnitInterval<$float> {
                #[inline]
                fn saturating_mul(&self, v: &Self) -> Self {
                    *self * *v
                }
            }
        };
    }

    macro_rules! impl_pow_signed_unit_interval {
        ($rhs:ty) => {
            impl<T: UnitIntervalFloat> Pow<$rhs> for SignedUnitInterval<T> {
                type Output = Self;

                #[inline]
                fn pow(self, rhs: $rhs) -> Self::Output {
                    pow_signed_unit_interval(self, rhs as usize)
                }
            }

            impl<T: UnitIntervalFloat> Pow<&$rhs> for SignedUnitInterval<T> {
                type Output = Self;

                #[inline]
                fn pow(self, rhs: &$rhs) -> Self::Output {
                    pow_signed_unit_interval(self, *rhs as usize)
                }
            }

            impl<T: UnitIntervalFloat> Pow<$rhs> for &SignedUnitInterval<T> {
                type Output = SignedUnitInterval<T>;

                #[inline]
                fn pow(self, rhs: $rhs) -> Self::Output {
                    pow_signed_unit_interval(*self, rhs as usize)
                }
            }

            impl<T: UnitIntervalFloat> Pow<&$rhs> for &SignedUnitInterval<T> {
                type Output = SignedUnitInterval<T>;

                #[inline]
                fn pow(self, rhs: &$rhs) -> Self::Output {
                    pow_signed_unit_interval(*self, *rhs as usize)
                }
            }
        };
    }

    macro_rules! impl_as_primitive_signed_unit_interval {
        ($float:ty => $($target:ty),+ $(,)?) => {
            $(
                impl AsPrimitive<$target> for SignedUnitInterval<$float> {
                    #[inline]
                    fn as_(self) -> $target {
                        self.0 as $target
                    }
                }
            )+
        };
    }

    impl_num_traits_signed_unit_interval!(f32);
    impl_num_traits_signed_unit_interval!(f64);
    impl_pow_signed_unit_interval!(u8);
    impl_pow_signed_unit_interval!(u16);
    impl_pow_signed_unit_interval!(u32);
    impl_pow_signed_unit_interval!(usize);

    impl_as_primitive_signed_unit_interval!(f32 => f32, f64);
    impl_as_primitive_signed_unit_interval!(f64 => f32, f64);

    impl AsPrimitive<SignedUnitInterval<f32>> for SignedUnitInterval<f32> {
        #[inline]
        fn as_(self) -> SignedUnitInterval<f32> {
            self
        }
    }

    impl AsPrimitive<SignedUnitInterval<f64>> for SignedUnitInterval<f32> {
        #[inline]
        fn as_(self) -> SignedUnitInterval<f64> {
            SignedUnitInterval::from_inner(self.0 as f64)
        }
    }

    impl AsPrimitive<SignedUnitInterval<f32>> for SignedUnitInterval<f64> {
        #[inline]
        fn as_(self) -> SignedUnitInterval<f32> {
            SignedUnitInterval::from_inner(self.0 as f32)
        }
    }

    impl AsPrimitive<SignedUnitInterval<f64>> for SignedUnitInterval<f64> {
        #[inline]
        fn as_(self) -> SignedUnitInterval<f64> {
            self
        }
    }

    #[inline]
    fn pow_signed_unit_interval<T: UnitIntervalFloat>(
        base: SignedUnitInterval<T>,
        exp: usize,
    ) -> SignedUnitInterval<T> {
        let mut result = SignedUnitInterval::ONE;
        let mut factor = base;
        let mut exp = exp;

        while exp > 0 {
            if exp & 1 == 1 {
                result = result * factor;
            }

            exp >>= 1;

            if exp > 0 {
                factor = factor * factor;
            }
        }

        result
    }
}

impl<T: UnitIntervalFloat> SignedUnitInterval<T> {
    /// The lower bound of the signed unit interval.
    pub const NEG_ONE: Self = Self(T::NEG_ONE);

    /// The midpoint of the signed unit interval.
    pub const ZERO: Self = Self(T::ZERO);

    /// The upper bound of the signed unit interval.
    pub const ONE: Self = Self(T::ONE);

    /// The positive midpoint of the signed unit interval.
    pub const HALF: Self = Self(T::HALF);

    /// Creates a value if `v` is inside `[-1, 1]`.
    ///
    /// Returns `None` for values outside the interval and for `NaN`.
    #[inline]
    pub fn new(v: T) -> Option<Self> {
        if Self::contains(v) {
            Some(Self::from_inner(v))
        } else {
            None
        }
    }

    /// Creates a value without checking that `v` is inside `[-1, 1]`.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that `v` is greater than or equal to negative
    /// one, less than or equal to one, and not `NaN`.
    #[cfg(feature = "unsafe")]
    #[inline]
    pub const unsafe fn new_unchecked(v: T) -> Self {
        Self(v)
    }

    /// Returns whether `v` is inside `[-1, 1]`.
    ///
    /// `NaN` is not contained in the interval.
    #[inline]
    pub fn contains(v: T) -> bool {
        v >= T::NEG_ONE && v <= T::ONE
    }

    /// Creates a value by clamping `v` into `[-1, 1]`.
    ///
    /// `NaN` is treated as zero.
    #[inline]
    pub fn saturating(v: T) -> Self {
        Self::from_inner(v.clamp_signed_unit())
    }

    #[inline]
    pub(crate) fn from_inner(v: T) -> Self {
        Self::assert_contains(v);
        Self(v)
    }

    #[cfg(any(test, feature = "assertions"))]
    #[inline]
    fn assert_contains(v: T) {
        assert!(
            Self::contains(v),
            "SignedUnitInterval invariant violated: value is outside [-1, 1]"
        );
    }

    #[cfg(not(any(test, feature = "assertions")))]
    #[cfg_attr(docsrs, doc(cfg(feature = "assertions")))]
    #[inline]
    fn assert_contains(_v: T) {}

    /// Returns the inner floating-point value.
    #[inline]
    pub const fn get(self) -> T {
        self.0
    }

    /// Consumes the wrapper and returns the inner floating-point value.
    #[inline]
    pub const fn into_inner(self) -> T {
        self.0
    }

    /// Returns whether this value is exactly zero.
    #[inline]
    pub fn is_zero(self) -> bool {
        self.0 == T::ZERO
    }

    /// Returns whether this value is exactly one.
    #[inline]
    pub fn is_one(self) -> bool {
        self.0 == T::ONE
    }

    /// Returns whether this value is exactly negative one.
    #[inline]
    pub fn is_neg_one(self) -> bool {
        self.0 == T::NEG_ONE
    }

    /// Returns `1 - self`.
    #[inline]
    pub fn complement(self) -> T {
        T::ONE - self.0
    }

    /// Returns the smaller of two signed unit interval values.
    #[inline]
    pub fn min<R: Into<Self>>(self, rhs: R) -> Self {
        let rhs = rhs.into();

        if self.0 <= rhs.0 { self } else { rhs }
    }

    /// Returns the larger of two signed unit interval values.
    #[inline]
    pub fn max<R: Into<Self>>(self, rhs: R) -> Self {
        let rhs = rhs.into();

        if self.0 >= rhs.0 { self } else { rhs }
    }

    /// Returns the midpoint between two signed unit interval values.
    #[inline]
    pub fn midpoint<R: Into<Self>>(self, rhs: R) -> Self {
        let rhs = rhs.into();

        Self::from_inner((self.0 + rhs.0) * T::HALF)
    }

    /// Returns the absolute distance between two signed unit interval values.
    #[inline]
    pub fn distance_to<R: Into<Self>>(self, rhs: R) -> T {
        let rhs = rhs.into();

        if self.0 >= rhs.0 {
            self.0 - rhs.0
        } else {
            rhs.0 - self.0
        }
    }

    /// Adds two values, returning `None` if the result is outside `[-1, 1]`.
    #[inline]
    pub fn checked_add<R: Into<Self>>(self, rhs: R) -> Option<Self> {
        Self::new(self.0 + rhs.into().0)
    }

    /// Adds two values without checking that the result is inside `[-1, 1]`.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that `self + rhs` is inside `[-1, 1]` and not
    /// `NaN`.
    #[cfg(feature = "unsafe")]
    #[cfg_attr(docsrs, doc(cfg(feature = "unsafe")))]
    #[inline]
    pub unsafe fn add_unchecked<R: Into<Self>>(self, rhs: R) -> Self {
        // SAFETY: Guaranteed by the caller.
        unsafe { Self::new_unchecked(self.0 + rhs.into().0) }
    }

    /// Adds two values and clamps the result into `[-1, 1]`.
    #[inline]
    pub fn saturating_add<R: Into<Self>>(self, rhs: R) -> Self {
        Self::saturating(self.0 + rhs.into().0)
    }

    /// Subtracts `rhs`, returning `None` if the result is outside `[-1, 1]`.
    #[inline]
    pub fn checked_sub<R: Into<Self>>(self, rhs: R) -> Option<Self> {
        Self::new(self.0 - rhs.into().0)
    }

    /// Subtracts `rhs` without checking that the result is inside `[-1, 1]`.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that `self - rhs` is inside `[-1, 1]` and not
    /// `NaN`.
    #[cfg(feature = "unsafe")]
    #[cfg_attr(docsrs, doc(cfg(feature = "unsafe")))]
    #[inline]
    pub unsafe fn sub_unchecked<R: Into<Self>>(self, rhs: R) -> Self {
        // SAFETY: Guaranteed by the caller.
        unsafe { Self::new_unchecked(self.0 - rhs.into().0) }
    }

    /// Subtracts `rhs` and clamps the result into `[-1, 1]`.
    #[inline]
    pub fn saturating_sub<R: Into<Self>>(self, rhs: R) -> Self {
        Self::saturating(self.0 - rhs.into().0)
    }

    /// Divides by `rhs`, returning `None` if the result is outside `[-1, 1]`.
    #[inline]
    pub fn checked_div<R: Into<Self>>(self, rhs: R) -> Option<Self> {
        Self::new(self.0 / rhs.into().0)
    }

    /// Divides by `rhs` without checking that the result is inside `[-1, 1]`.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that `self / rhs` is inside `[-1, 1]` and not
    /// `NaN`.
    #[cfg(feature = "unsafe")]
    #[cfg_attr(docsrs, doc(cfg(feature = "unsafe")))]
    #[inline]
    pub unsafe fn div_unchecked<R: Into<Self>>(self, rhs: R) -> Self {
        // SAFETY: Guaranteed by the caller.
        unsafe { Self::new_unchecked(self.0 / rhs.into().0) }
    }

    /// Divides by `rhs` and clamps the result into `[-1, 1]`.
    #[inline]
    pub fn saturating_div<R: Into<Self>>(self, rhs: R) -> Self {
        Self::saturating(self.0 / rhs.into().0)
    }

    /// Multiplies by an arbitrary float, returning `None` if the result is outside `[-1, 1]`.
    #[inline]
    pub fn checked_scale(self, factor: T) -> Option<Self> {
        Self::new(self.0 * factor)
    }

    /// Multiplies by an arbitrary float without checking that the result is
    /// inside `[-1, 1]`.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that `self * factor` is inside `[-1, 1]` and
    /// not `NaN`.
    #[cfg(feature = "unsafe")]
    #[cfg_attr(docsrs, doc(cfg(feature = "unsafe")))]
    #[inline]
    pub unsafe fn scale_unchecked(self, factor: T) -> Self {
        // SAFETY: Guaranteed by the caller.
        unsafe { Self::new_unchecked(self.0 * factor) }
    }

    /// Multiplies by an arbitrary float and clamps the result into `[-1, 1]`.
    #[inline]
    pub fn saturating_scale(self, factor: T) -> Self {
        Self::saturating(self.0 * factor)
    }

    /// Linearly interpolates between `start` and `end`.
    #[inline]
    pub fn lerp(self, start: T, end: T) -> T {
        start + (end - start) * self.0
    }
}

/// Returns [`SignedUnitInterval::ZERO`].
impl<T: UnitIntervalFloat> Default for SignedUnitInterval<T> {
    #[inline]
    fn default() -> Self {
        Self::ZERO
    }
}

/// Dereferences to the inner floating-point value.
impl<T> Deref for SignedUnitInterval<T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Borrows the inner floating-point value.
impl<T> AsRef<T> for SignedUnitInterval<T> {
    #[inline]
    fn as_ref(&self) -> &T {
        &self.0
    }
}

impl<T: UnitIntervalFloat> From<UnitInterval<T>> for SignedUnitInterval<T> {
    #[inline]
    fn from(u: UnitInterval<T>) -> Self {
        Self::from_inner(u.get())
    }
}

impl<T: UnitIntervalFloat> TryFrom<SignedUnitInterval<T>> for UnitInterval<T> {
    type Error = UnitIntervalError;

    #[inline]
    fn try_from(value: SignedUnitInterval<T>) -> Result<Self, Self::Error> {
        Self::new(value.0).ok_or(UnitIntervalError)
    }
}

macro_rules! impl_signed_unit_interval_float {
    ($float:ty) => {
        impl From<SignedUnitInterval<$float>> for $float {
            #[inline]
            fn from(u: SignedUnitInterval<$float>) -> Self {
                u.0
            }
        }

        impl TryFrom<$float> for SignedUnitInterval<$float> {
            type Error = SignedUnitIntervalError;

            #[inline]
            fn try_from(value: $float) -> Result<Self, Self::Error> {
                Self::new(value).ok_or(SignedUnitIntervalError)
            }
        }

        impl PartialEq<$float> for SignedUnitInterval<$float> {
            #[inline]
            fn eq(&self, other: &$float) -> bool {
                self.0 == *other
            }
        }

        impl PartialEq<SignedUnitInterval<$float>> for $float {
            #[inline]
            fn eq(&self, other: &SignedUnitInterval<$float>) -> bool {
                *self == other.0
            }
        }

        impl PartialOrd<$float> for SignedUnitInterval<$float> {
            #[inline]
            fn partial_cmp(&self, other: &$float) -> Option<Ordering> {
                self.0.partial_cmp(other)
            }
        }

        impl PartialOrd<SignedUnitInterval<$float>> for $float {
            #[inline]
            fn partial_cmp(&self, other: &SignedUnitInterval<$float>) -> Option<Ordering> {
                self.partial_cmp(&other.0)
            }
        }

        impl Add for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn add(self, rhs: Self) -> Self::Output {
                self.0 + rhs.0
            }
        }

        impl Add<UnitInterval<$float>> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn add(self, rhs: UnitInterval<$float>) -> Self::Output {
                self.0 + rhs.get()
            }
        }

        impl Add<SignedUnitInterval<$float>> for UnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn add(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self.get() + rhs.0
            }
        }

        impl Add<$float> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn add(self, rhs: $float) -> Self::Output {
                self.0 + rhs
            }
        }

        impl Add<SignedUnitInterval<$float>> for $float {
            type Output = $float;

            #[inline]
            fn add(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self + rhs.0
            }
        }

        impl Sub for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn sub(self, rhs: Self) -> Self::Output {
                self.0 - rhs.0
            }
        }

        impl Sub<UnitInterval<$float>> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn sub(self, rhs: UnitInterval<$float>) -> Self::Output {
                self.0 - rhs.get()
            }
        }

        impl Sub<SignedUnitInterval<$float>> for UnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn sub(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self.get() - rhs.0
            }
        }

        impl Sub<$float> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn sub(self, rhs: $float) -> Self::Output {
                self.0 - rhs
            }
        }

        impl Sub<SignedUnitInterval<$float>> for $float {
            type Output = $float;

            #[inline]
            fn sub(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self - rhs.0
            }
        }

        impl Mul<$float> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn mul(self, rhs: $float) -> Self::Output {
                self.0 * rhs
            }
        }

        impl Mul<SignedUnitInterval<$float>> for $float {
            type Output = $float;

            #[inline]
            fn mul(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self * rhs.0
            }
        }

        impl Div for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn div(self, rhs: Self) -> Self::Output {
                self.0 / rhs.0
            }
        }

        impl Div<UnitInterval<$float>> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn div(self, rhs: UnitInterval<$float>) -> Self::Output {
                self.0 / rhs.get()
            }
        }

        impl Div<SignedUnitInterval<$float>> for UnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn div(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self.get() / rhs.0
            }
        }

        impl Div<$float> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn div(self, rhs: $float) -> Self::Output {
                self.0 / rhs
            }
        }

        impl Div<SignedUnitInterval<$float>> for $float {
            type Output = $float;

            #[inline]
            fn div(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self / rhs.0
            }
        }

        impl Rem for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn rem(self, rhs: Self) -> Self::Output {
                self.0 % rhs.0
            }
        }

        impl Rem<UnitInterval<$float>> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn rem(self, rhs: UnitInterval<$float>) -> Self::Output {
                self.0 % rhs.get()
            }
        }

        impl Rem<SignedUnitInterval<$float>> for UnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn rem(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self.get() % rhs.0
            }
        }

        impl Rem<$float> for SignedUnitInterval<$float> {
            type Output = $float;

            #[inline]
            fn rem(self, rhs: $float) -> Self::Output {
                self.0 % rhs
            }
        }

        impl Rem<SignedUnitInterval<$float>> for $float {
            type Output = $float;

            #[inline]
            fn rem(self, rhs: SignedUnitInterval<$float>) -> Self::Output {
                self % rhs.0
            }
        }

        impl Neg for SignedUnitInterval<$float> {
            type Output = Self;

            #[inline]
            fn neg(self) -> Self::Output {
                Self::from_inner(-self.0)
            }
        }

        impl SignedUnitInterval<$float> {
            /// Returns the absolute value.
            #[inline]
            pub fn abs(self) -> UnitInterval<$float> {
                UnitInterval::new(self.0.abs()).expect("absolute signed unit value is in [0, 1]")
            }

            /// Returns a number representing the sign of this value.
            #[inline]
            pub fn signum(self) -> Self {
                Self::from_inner(self.0.signum())
            }

            /// Returns this value with the sign of `sign`.
            #[inline]
            pub fn copysign(self, sign: $float) -> Self {
                Self::from_inner(self.0.copysign(sign))
            }

            /// Returns `true` if this value is positive zero or positive.
            #[inline]
            pub fn is_sign_positive(self) -> bool {
                self.0.is_sign_positive()
            }

            /// Returns `true` if this value is negative zero or negative.
            #[inline]
            pub fn is_sign_negative(self) -> bool {
                self.0.is_sign_negative()
            }

            /// Returns `true`; signed unit interval values are always finite.
            #[inline]
            pub fn is_finite(self) -> bool {
                self.0.is_finite()
            }

            /// Returns `false`; signed unit interval values cannot be infinite.
            #[inline]
            pub fn is_infinite(self) -> bool {
                self.0.is_infinite()
            }

            /// Returns `false`; signed unit interval values cannot be `NaN`.
            #[inline]
            pub fn is_nan(self) -> bool {
                self.0.is_nan()
            }

            /// Takes the reciprocal, `1 / self`.
            #[inline]
            pub fn recip(self) -> $float {
                self.0.recip()
            }
        }

        #[cfg(any(test, feature = "std"))]
        impl SignedUnitInterval<$float> {
            /// Returns the largest integer less than or equal to this value.
            #[inline]
            pub fn floor(self) -> Self {
                Self::from_inner(self.0.floor())
            }

            /// Returns the smallest integer greater than or equal to this value.
            #[inline]
            pub fn ceil(self) -> Self {
                Self::from_inner(self.0.ceil())
            }

            /// Returns the nearest integer to this value, rounding halfway cases away from zero.
            #[inline]
            pub fn round(self) -> Self {
                Self::from_inner(self.0.round())
            }

            /// Returns the integer part of this value.
            #[inline]
            pub fn trunc(self) -> Self {
                Self::from_inner(self.0.trunc())
            }

            /// Returns the fractional part of this value.
            #[inline]
            pub fn fract(self) -> Self {
                Self::from_inner(self.0.fract())
            }

            /// Raises this value to an integer power.
            #[inline]
            pub fn powi(self, n: i32) -> $float {
                self.0.powi(n)
            }

            /// Raises this value to a floating-point power.
            #[inline]
            pub fn powf(self, n: $float) -> $float {
                self.0.powf(n)
            }

            /// Returns the square root.
            #[inline]
            pub fn sqrt(self) -> $float {
                self.0.sqrt()
            }

            /// Returns the cube root.
            #[inline]
            pub fn cbrt(self) -> Self {
                Self::from_inner(self.0.cbrt())
            }

            /// Computes `self * a + b` with one rounding error.
            #[inline]
            pub fn mul_add(self, a: $float, b: $float) -> $float {
                self.0.mul_add(a, b)
            }

            /// Returns the Euclidean division of this value by `rhs`.
            #[inline]
            pub fn div_euclid(self, rhs: $float) -> $float {
                self.0.div_euclid(rhs)
            }

            /// Returns the least non-negative remainder of this value divided by `rhs`.
            #[inline]
            pub fn rem_euclid(self, rhs: $float) -> $float {
                self.0.rem_euclid(rhs)
            }

            /// Returns `e^(self)`.
            #[inline]
            pub fn exp(self) -> $float {
                self.0.exp()
            }

            /// Returns `2^(self)`.
            #[inline]
            pub fn exp2(self) -> $float {
                self.0.exp2()
            }

            /// Returns the natural logarithm.
            #[inline]
            pub fn ln(self) -> $float {
                self.0.ln()
            }

            /// Returns the logarithm with respect to an arbitrary base.
            #[inline]
            pub fn log(self, base: $float) -> $float {
                self.0.log(base)
            }

            /// Returns the base 2 logarithm.
            #[inline]
            pub fn log2(self) -> $float {
                self.0.log2()
            }

            /// Returns the base 10 logarithm.
            #[inline]
            pub fn log10(self) -> $float {
                self.0.log10()
            }

            /// Returns the sine, in radians.
            #[inline]
            pub fn sin(self) -> Self {
                Self::from_inner(self.0.sin())
            }

            /// Returns the cosine, in radians.
            #[inline]
            pub fn cos(self) -> UnitInterval<$float> {
                UnitInterval::new(self.0.cos()).expect("cosine on [-1, 1] is in [0, 1]")
            }

            /// Returns the tangent, in radians.
            #[inline]
            pub fn tan(self) -> $float {
                self.0.tan()
            }

            /// Returns both sine and cosine, in radians.
            #[inline]
            pub fn sin_cos(self) -> (Self, UnitInterval<$float>) {
                let (sin, cos) = self.0.sin_cos();
                (
                    Self::from_inner(sin),
                    UnitInterval::new(cos).expect("cosine on [-1, 1] is in [0, 1]"),
                )
            }

            /// Returns the arcsine, in radians.
            #[inline]
            pub fn asin(self) -> $float {
                self.0.asin()
            }

            /// Returns the arccosine, in radians.
            #[inline]
            pub fn acos(self) -> $float {
                self.0.acos()
            }

            /// Returns the arctangent, in radians.
            #[inline]
            pub fn atan(self) -> Self {
                Self::from_inner(self.0.atan())
            }

            /// Returns the four-quadrant arctangent of `self` and `other`, in radians.
            #[inline]
            pub fn atan2(self, other: $float) -> $float {
                self.0.atan2(other)
            }

            /// Returns the hyperbolic sine.
            #[inline]
            pub fn sinh(self) -> $float {
                self.0.sinh()
            }

            /// Returns the hyperbolic cosine.
            #[inline]
            pub fn cosh(self) -> $float {
                self.0.cosh()
            }

            /// Returns the hyperbolic tangent.
            #[inline]
            pub fn tanh(self) -> Self {
                Self::from_inner(self.0.tanh())
            }

            /// Returns the inverse hyperbolic sine.
            #[inline]
            pub fn asinh(self) -> Self {
                Self::from_inner(self.0.asinh())
            }

            /// Returns the inverse hyperbolic cosine.
            #[inline]
            pub fn acosh(self) -> $float {
                self.0.acosh()
            }

            /// Returns the inverse hyperbolic tangent.
            #[inline]
            pub fn atanh(self) -> $float {
                self.0.atanh()
            }

            /// Calculates the length of the hypotenuse of a right-angle triangle.
            #[inline]
            pub fn hypot(self, other: $float) -> $float {
                self.0.hypot(other)
            }
        }
    };
}

impl_signed_unit_interval_float!(f32);
impl_signed_unit_interval_float!(f64);

/// Converts a `SignedUnitInterval<f32>` into its inner value widened to `f64`.
impl From<SignedUnitInterval<f32>> for f64 {
    #[inline]
    fn from(u: SignedUnitInterval) -> Self {
        u.0 as f64
    }
}

/// Converts a `SignedUnitInterval<f32>` into `SignedUnitInterval<f64>`.
impl From<SignedUnitInterval<f32>> for SignedUnitInterval<f64> {
    #[inline]
    fn from(u: SignedUnitInterval<f32>) -> Self {
        Self::from_inner(u.0 as f64)
    }
}

/// Converts a `SignedUnitInterval<f64>` into `SignedUnitInterval<f32>`.
impl From<SignedUnitInterval<f64>> for SignedUnitInterval<f32> {
    #[inline]
    fn from(u: SignedUnitInterval<f64>) -> Self {
        Self::from_inner(u.0 as f32)
    }
}

/// Multiplies two signed unit interval values.
impl<T: UnitIntervalFloat> Mul for SignedUnitInterval<T> {
    type Output = Self;

    #[inline]
    fn mul(self, rhs: Self) -> Self::Output {
        Self::from_inner(self.0 * rhs.0)
    }
}

/// Multiplies a signed unit interval by a unit interval.
impl<T: UnitIntervalFloat> Mul<UnitInterval<T>> for SignedUnitInterval<T> {
    type Output = Self;

    #[inline]
    fn mul(self, rhs: UnitInterval<T>) -> Self::Output {
        Self::from_inner(self.0 * rhs.get())
    }
}

/// Multiplies a unit interval by a signed unit interval.
impl<T: UnitIntervalFloat> Mul<SignedUnitInterval<T>> for UnitInterval<T> {
    type Output = SignedUnitInterval<T>;

    #[inline]
    fn mul(self, rhs: SignedUnitInterval<T>) -> Self::Output {
        SignedUnitInterval::from_inner(self.get() * rhs.0)
    }
}

#[cfg(test)]
mod tests {
    use super::SignedUnitInterval;

    #[test]
    #[should_panic(expected = "SignedUnitInterval invariant violated")]
    fn test_configuration_enables_internal_assertions() {
        SignedUnitInterval::<f32>::from_inner(1.1);
    }

    #[cfg(feature = "rkyv")]
    #[test]
    fn rkyv_deserialization_rejects_invalid_archived_inner_value() {
        let invalid = super::ArchivedSignedUnitInterval(rkyv::Archived::<f32>::from_native(1.25));

        assert!(
            rkyv::deserialize::<SignedUnitInterval<f32>, rkyv::rancor::Error>(&invalid).is_err()
        );
    }
}