Move Float to separate crate

utils/float/src/fastfloat.rs

@@ -0,0 +1,120 @@
+use super::Float;
+
+#[repr(transparent)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+pub struct FastFloat(Float);
+
+use core::intrinsics::{fadd_fast, fdiv_fast, fmul_fast, fsub_fast};
+
+impl core::ops::Mul for FastFloat {
+    type Output = Self;
+    #[inline(always)]
+    fn mul(self, o: Self) -> Self::Output {
+        unsafe { Self(fmul_fast(self.0, o.0)) }
+    }
+}
+
+impl core::ops::Mul<Float> for FastFloat {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn mul(self, o: Float) -> Self::Output {
+        unsafe { Self(fmul_fast(self.0, o)) }
+    }
+}
+
+impl core::ops::Mul<FastFloat> for Float {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn mul(self, o: FastFloat) -> Self::Output {
+        unsafe { FastFloat(fmul_fast(self, o.0)) }
+    }
+}
+
+impl core::ops::Add<FastFloat> for FastFloat {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn add(self, o: FastFloat) -> Self::Output {
+        unsafe { Self(fadd_fast(self.0, o.0)) }
+    }
+}
+
+impl core::ops::Add<Float> for FastFloat {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn add(self, o: Float) -> Self::Output {
+        unsafe { Self(fadd_fast(self.0, o)) }
+    }
+}
+
+impl core::ops::Add<FastFloat> for Float {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn add(self, o: FastFloat) -> Self::Output {
+        unsafe { FastFloat(fadd_fast(self, o.0)) }
+    }
+}
+
+impl core::ops::Sub for FastFloat {
+    type Output = Self;
+    #[inline(always)]
+    fn sub(self, o: FastFloat) -> Self::Output {
+        unsafe { Self(fsub_fast(self.0, o.0)) }
+    }
+}
+
+impl core::ops::Div for FastFloat {
+    type Output = Self;
+    #[inline(always)]
+    fn div(self, o: FastFloat) -> Self::Output {
+        unsafe { Self(fdiv_fast(self.0, o.0)) }
+    }
+}
+
+impl core::ops::MulAssign<FastFloat> for FastFloat {
+    #[inline(always)]
+    fn mul_assign(&mut self, o: FastFloat) {
+        unsafe {
+            self.0 = fmul_fast(self.0, o.0);
+        }
+    }
+}
+
+impl core::ops::Mul for &FastFloat {
+    type Output = FastFloat;
+    #[inline(always)]
+    fn mul(self, o: Self) -> Self::Output {
+        unsafe { FastFloat(fmul_fast(self.0, o.0)) }
+    }
+}
+
+impl From<Float> for FastFloat {
+    #[inline(always)]
+    fn from(f: Float) -> Self {
+        Self(f)
+    }
+}
+impl From<FastFloat> for Float {
+    #[inline(always)]
+    fn from(f: FastFloat) -> Self {
+        f.0
+    }
+}
+
+mod numt {
+    use super::{FastFloat, Float};
+    use num_traits::identities::{One, Zero};
+
+    impl One for FastFloat {
+        fn one() -> Self {
+            Self(Float::one())
+        }
+    }
+    impl Zero for FastFloat {
+        fn zero() -> Self {
+            Self(Float::zero())
+        }
+        fn is_zero(&self) -> bool {
+            self.0.is_zero()
+        }
+    }
+}

utils/float/src/lib.rs

@@ -0,0 +1,23 @@
+//! The Float type used throughout the ecosystem
+
+#![cfg_attr(feature = "fast-float", feature(core_intrinsics))]
+
+/// Type used for floats, configure with the `f32` feature
+#[cfg(feature = "f32")]
+pub type Float = f32;
+#[cfg(not(feature = "f32"))]
+/// Type used for floats, configure with the `f32` feature
+pub type Float = f64;
+
+/// Associated constants for [`Float`]
+pub mod consts {
+    #[cfg(feature = "f32")]
+    pub use std::f32::consts::*;
+    #[cfg(not(feature = "f32"))]
+    pub use std::f64::consts::*;
+}
+
+#[cfg(feature = "fast-float")]
+mod fastfloat;
+#[cfg(feature = "fast-float")]
+pub use fastfloat::FastFloat;