Expose algebraic floating point intrinsics

Author: calder

library/core/src/intrinsics/mod.rs

@@ -2995,7 +2995,8 @@ pub unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> I
 
 /// Float addition that allows optimizations based on algebraic rules.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f32::add_algebraic`](../../std/primitive.f32.html#method.add_algebraic)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
@@ -3005,7 +3006,8 @@ pub fn fadd_algebraic<T: Copy>(_a: T, _b: T) -> T {
 
 /// Float subtraction that allows optimizations based on algebraic rules.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f32::sub_algebraic`](../../std/primitive.f32.html#method.sub_algebraic)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
@@ -3015,7 +3017,8 @@ pub fn fsub_algebraic<T: Copy>(_a: T, _b: T) -> T {
 
 /// Float multiplication that allows optimizations based on algebraic rules.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f32::mul_algebraic`](../../std/primitive.f32.html#method.mul_algebraic)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
@@ -3025,7 +3028,8 @@ pub fn fmul_algebraic<T: Copy>(_a: T, _b: T) -> T {
 
 /// Float division that allows optimizations based on algebraic rules.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f32::div_algebraic`](../../std/primitive.f32.html#method.div_algebraic)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
@@ -3035,7 +3039,8 @@ pub fn fdiv_algebraic<T: Copy>(_a: T, _b: T) -> T {
 
 /// Float remainder that allows optimizations based on algebraic rules.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f32::rem_algebraic`](../../std/primitive.f32.html#method.rem_algebraic)
 #[rustc_nounwind]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]

library/std/src/f32.rs

@@ -1154,4 +1154,54 @@ 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,4 +1154,54 @@ 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)
+    }
 }