Move to core.

Author: calder

library/core/src/num/f32.rs

@@ -1506,4 +1506,44 @@ impl f32 {
         // SAFETY: this is actually a safe intrinsic
         unsafe { intrinsics::copysignf32(self, sign) }
     }
+
+    /// Float addition that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn add_algebraic(self, rhs: f32) -> f32 {
+        intrinsics::fadd_algebraic(self, rhs)
+    }
+
+    /// Float subtraction that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn sub_algebraic(self, rhs: f32) -> f32 {
+        intrinsics::fsub_algebraic(self, rhs)
+    }
+
+    /// Float multiplication that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn mul_algebraic(self, rhs: f32) -> f32 {
+        intrinsics::fmul_algebraic(self, rhs)
+    }
+
+    /// Float division that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn div_algebraic(self, rhs: f32) -> f32 {
+        intrinsics::fdiv_algebraic(self, rhs)
+    }
+
+    /// Float remainder that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn rem_algebraic(self, rhs: f32) -> f32 {
+        intrinsics::frem_algebraic(self, rhs)
+    }
 }

library/core/src/num/f64.rs

@@ -1506,4 +1506,44 @@ impl f64 {
         // SAFETY: this is actually a safe intrinsic
         unsafe { intrinsics::copysignf64(self, sign) }
     }
+
+    /// Float addition that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn add_algebraic(self, rhs: f64) -> f64 {
+        intrinsics::fadd_algebraic(self, rhs)
+    }
+
+    /// Float subtraction that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn sub_algebraic(self, rhs: f64) -> f64 {
+        intrinsics::fsub_algebraic(self, rhs)
+    }
+
+    /// Float multiplication that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn mul_algebraic(self, rhs: f64) -> f64 {
+        intrinsics::fmul_algebraic(self, rhs)
+    }
+
+    /// Float division that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn div_algebraic(self, rhs: f64) -> f64 {
+        intrinsics::fdiv_algebraic(self, rhs)
+    }
+
+    /// Float remainder that allows optimizations based on algebraic rules.
+    #[must_use = "method returns a new number and does not mutate the original value"]
+    #[unstable(feature = "float_algebraic", issue = "21690")]
+    #[inline]
+    pub fn rem_algebraic(self, rhs: f64) -> f64 {
+        intrinsics::frem_algebraic(self, rhs)
+    }
 }

library/std/src/f32.rs

@@ -1154,54 +1154,4 @@ impl f32 {
         let x = unsafe { cmath::lgammaf_r(self, &mut signgamp) };
         (x, signgamp)
     }
-
-    /// Float addition that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fadd_algebraic", alias = "addAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn add_algebraic(self, rhs: f32) -> f32 {
-        intrinsics::fadd_algebraic(self, rhs)
-    }
-
-    /// Float subtraction that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fsub_algebraic", alias = "subAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn sub_algebraic(self, rhs: f32) -> f32 {
-        intrinsics::fsub_algebraic(self, rhs)
-    }
-
-    /// Float multiplication that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fmul_algebraic", alias = "mulAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn mul_algebraic(self, rhs: f32) -> f32 {
-        intrinsics::fmul_algebraic(self, rhs)
-    }
-
-    /// Float division that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fdiv_algebraic", alias = "divAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn div_algebraic(self, rhs: f32) -> f32 {
-        intrinsics::fdiv_algebraic(self, rhs)
-    }
-
-    /// Float remainder that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "frem_algebraic", alias = "remAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn rem_algebraic(self, rhs: f32) -> f32 {
-        intrinsics::frem_algebraic(self, rhs)
-    }
 }

library/std/src/f64.rs

@@ -1154,54 +1154,4 @@ impl f64 {
         let x = unsafe { cmath::lgamma_r(self, &mut signgamp) };
         (x, signgamp)
     }
-
-    /// Float addition that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fadd_algebraic", alias = "addAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn add_algebraic(self, rhs: f64) -> f64 {
-        intrinsics::fadd_algebraic(self, rhs)
-    }
-
-    /// Float subtraction that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fsub_algebraic", alias = "subAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn sub_algebraic(self, rhs: f64) -> f64 {
-        intrinsics::fsub_algebraic(self, rhs)
-    }
-
-    /// Float multiplication that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fmul_algebraic", alias = "mulAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn mul_algebraic(self, rhs: f64) -> f64 {
-        intrinsics::fmul_algebraic(self, rhs)
-    }
-
-    /// Float division that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "fdiv_algebraic", alias = "divAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn div_algebraic(self, rhs: f64) -> f64 {
-        intrinsics::fdiv_algebraic(self, rhs)
-    }
-
-    /// Float remainder that allows optimizations based on algebraic rules.
-    #[rustc_allow_incoherent_impl]
-    #[doc(alias = "frem_algebraic", alias = "remAlgebraic")]
-    #[must_use = "method returns a new number and does not mutate the original value"]
-    #[unstable(feature = "float_algebraic", issue = "21690")]
-    #[inline]
-    pub fn rem_algebraic(self, rhs: f64) -> f64 {
-        intrinsics::frem_algebraic(self, rhs)
-    }
 }