+use crate::{
+ f16::F16,
+ traits::{ConvertFrom, ConvertTo},
+};
+use core::{fmt, hash, ops};
+
+mod sealed {
+ use crate::f16::F16;
+
+ pub trait Sealed {}
+ impl Sealed for F16 {}
+ impl Sealed for f32 {}
+ impl Sealed for f64 {}
+ impl Sealed for u8 {}
+ impl Sealed for u16 {}
+ impl Sealed for u32 {}
+ impl Sealed for u64 {}
+ impl Sealed for i8 {}
+ impl Sealed for i16 {}
+ impl Sealed for i32 {}
+ impl Sealed for i64 {}
+}
+
+pub trait PrimBase:
+ sealed::Sealed
+ + Copy
+ + 'static
+ + Send
+ + Sync
+ + PartialOrd
+ + fmt::Debug
+ + fmt::Display
+ + ops::Add<Output = Self>
+ + ops::Sub<Output = Self>
+ + ops::Mul<Output = Self>
+ + ops::Div<Output = Self>
+ + ops::Rem<Output = Self>
+ + ops::AddAssign
+ + ops::SubAssign
+ + ops::MulAssign
+ + ops::DivAssign
+ + ops::RemAssign
+ + ConvertFrom<i8>
+ + ConvertFrom<u8>
+ + ConvertFrom<i16>
+ + ConvertFrom<u16>
+ + ConvertFrom<F16>
+ + ConvertFrom<i32>
+ + ConvertFrom<u32>
+ + ConvertFrom<f32>
+ + ConvertFrom<i64>
+ + ConvertFrom<u64>
+ + ConvertFrom<f64>
+ + ConvertTo<i8>
+ + ConvertTo<u8>
+ + ConvertTo<i16>
+ + ConvertTo<u16>
+ + ConvertTo<F16>
+ + ConvertTo<i32>
+ + ConvertTo<u32>
+ + ConvertTo<f32>
+ + ConvertTo<i64>
+ + ConvertTo<u64>
+ + ConvertTo<f64>
+{
+}
+
+pub trait PrimInt:
+ PrimBase
+ + Ord
+ + hash::Hash
+ + fmt::Binary
+ + fmt::LowerHex
+ + fmt::Octal
+ + fmt::UpperHex
+ + ops::BitAnd<Output = Self>
+ + ops::BitOr<Output = Self>
+ + ops::BitXor<Output = Self>
+ + ops::Shl<Output = Self>
+ + ops::Shr<Output = Self>
+ + ops::Not<Output = Self>
+ + ops::BitAndAssign
+ + ops::BitOrAssign
+ + ops::BitXorAssign
+ + ops::ShlAssign
+ + ops::ShrAssign
+{
+}
+
+pub trait PrimUInt: PrimInt + ConvertFrom<Self::SignedType> {
+ type SignedType: PrimSInt<UnsignedType = Self> + ConvertFrom<Self>;
+}
+
+pub trait PrimSInt: PrimInt + ops::Neg<Output = Self> + ConvertFrom<Self::UnsignedType> {
+ type UnsignedType: PrimUInt<SignedType = Self> + ConvertFrom<Self>;
+}
+
+macro_rules! impl_int {
+ ($uint:ident, $sint:ident) => {
+ impl PrimBase for $uint {}
+ impl PrimBase for $sint {}
+ impl PrimInt for $uint {}
+ impl PrimInt for $sint {}
+ impl PrimUInt for $uint {
+ type SignedType = $sint;
+ }
+ impl PrimSInt for $sint {
+ type UnsignedType = $uint;
+ }
+ };
+}
+
+impl_int!(u8, i8);
+impl_int!(u16, i16);
+impl_int!(u32, i32);
+impl_int!(u64, i64);
+
+pub trait PrimFloat:
+ PrimBase + ops::Neg<Output = Self> + ConvertFrom<Self::BitsType> + ConvertFrom<Self::SignedBitsType>
+{
+ type BitsType: PrimUInt<SignedType = Self::SignedBitsType> + ConvertFrom<Self>;
+ type SignedBitsType: PrimSInt<UnsignedType = Self::BitsType> + ConvertFrom<Self>;
+ const EXPONENT_BIAS_UNSIGNED: Self::BitsType;
+ const EXPONENT_BIAS_SIGNED: Self::SignedBitsType;
+ const SIGN_FIELD_WIDTH: Self::BitsType;
+ const EXPONENT_FIELD_WIDTH: Self::BitsType;
+ const MANTISSA_FIELD_WIDTH: Self::BitsType;
+ const SIGN_FIELD_SHIFT: Self::BitsType;
+ const EXPONENT_FIELD_SHIFT: Self::BitsType;
+ const MANTISSA_FIELD_SHIFT: Self::BitsType;
+ const SIGN_FIELD_MASK: Self::BitsType;
+ const EXPONENT_FIELD_MASK: Self::BitsType;
+ const MANTISSA_FIELD_MASK: Self::BitsType;
+ const IMPLICIT_MANTISSA_BIT: Self::BitsType;
+ const ZERO_SUBNORMAL_EXPONENT: Self::BitsType;
+ const NAN_INFINITY_EXPONENT: Self::BitsType;
+ const INFINITY_BITS: Self::BitsType;
+ const NAN_BITS: Self::BitsType;
+}
+
+macro_rules! impl_float {
+ (
+ impl PrimFloat for $float:ident {
+ type BitsType = $bits_type:ident;
+ type SignedBitsType = $signed_bits_type:ident;
+ const EXPONENT_FIELD_WIDTH: u32 = $exponent_field_width:literal;
+ const MANTISSA_FIELD_WIDTH: u32 = $mantissa_field_width:literal;
+ }
+ ) => {
+ impl PrimBase for $float {}
+
+ impl PrimFloat for $float {
+ type BitsType = $bits_type;
+ type SignedBitsType = $signed_bits_type;
+ const EXPONENT_BIAS_UNSIGNED: Self::BitsType =
+ (1 << (Self::EXPONENT_FIELD_WIDTH - 1)) - 1;
+ const EXPONENT_BIAS_SIGNED: Self::SignedBitsType = Self::EXPONENT_BIAS_UNSIGNED as _;
+ const SIGN_FIELD_WIDTH: Self::BitsType = 1;
+ const EXPONENT_FIELD_WIDTH: Self::BitsType = $exponent_field_width;
+ const MANTISSA_FIELD_WIDTH: Self::BitsType = $mantissa_field_width;
+ const SIGN_FIELD_SHIFT: Self::BitsType =
+ Self::EXPONENT_FIELD_SHIFT + Self::EXPONENT_FIELD_WIDTH;
+ const EXPONENT_FIELD_SHIFT: Self::BitsType = Self::MANTISSA_FIELD_WIDTH;
+ const MANTISSA_FIELD_SHIFT: Self::BitsType = 0;
+ const SIGN_FIELD_MASK: Self::BitsType = 1 << Self::SIGN_FIELD_SHIFT;
+ const EXPONENT_FIELD_MASK: Self::BitsType =
+ ((1 << Self::EXPONENT_FIELD_WIDTH) - 1) << Self::EXPONENT_FIELD_SHIFT;
+ const MANTISSA_FIELD_MASK: Self::BitsType = (1 << Self::MANTISSA_FIELD_WIDTH) - 1;
+ const IMPLICIT_MANTISSA_BIT: Self::BitsType = 1 << Self::MANTISSA_FIELD_WIDTH;
+ const ZERO_SUBNORMAL_EXPONENT: Self::BitsType = 0;
+ const NAN_INFINITY_EXPONENT: Self::BitsType = (1 << Self::EXPONENT_FIELD_WIDTH) - 1;
+ const INFINITY_BITS: Self::BitsType =
+ Self::NAN_INFINITY_EXPONENT << Self::EXPONENT_FIELD_SHIFT;
+ const NAN_BITS: Self::BitsType =
+ Self::INFINITY_BITS | (1 << (Self::MANTISSA_FIELD_WIDTH - 1));
+ }
+ };
+}
+
+impl_float! {
+ impl PrimFloat for F16 {
+ type BitsType = u16;
+ type SignedBitsType = i16;
+ const EXPONENT_FIELD_WIDTH: u32 = 5;
+ const MANTISSA_FIELD_WIDTH: u32 = 10;
+ }
+}
+
+impl_float! {
+ impl PrimFloat for f32 {
+ type BitsType = u32;
+ type SignedBitsType = i32;
+ const EXPONENT_FIELD_WIDTH: u32 = 8;
+ const MANTISSA_FIELD_WIDTH: u32 = 23;
+ }
+}
+
+impl_float! {
+ impl PrimFloat for f64 {
+ type BitsType = u64;
+ type SignedBitsType = i64;
+ const EXPONENT_FIELD_WIDTH: u32 = 11;
+ const MANTISSA_FIELD_WIDTH: u32 = 52;
+ }
+}
projects / vector-math.git / commitdiff