Move mul_sub to StdFloat trait

Both mul_add and mul_sub now live in StdFloat for consistency.

Author: GrigoryEvko

crates/core_simd/src/simd/num/float.rs

@@ -235,25 +235,6 @@ pub trait SimdFloat: Copy + Sealed {
     /// assert!(v.reduce_min().is_nan());
     /// ```
     fn reduce_min(self) -> Self::Scalar;
-    /// Fused multiply-subtract: computes `(self * a) - b` with only one rounding error.
-    ///
-    /// This produces more accurate results than separate multiply and subtract operations,
-    /// and can be faster on platforms with dedicated FMS instructions.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(portable_simd)]
-    /// # #[cfg(feature = "as_crate")] use core_simd::simd;
-    /// # #[cfg(not(feature = "as_crate"))] use core::simd;
-    /// # use simd::prelude::*;
-    /// let a = f32x4::splat(2.0);
-    /// let b = f32x4::splat(3.0);
-    /// let c = f32x4::splat(4.0);
-    /// assert_eq!(a.mul_sub(b, c), f32x4::splat(2.0)); // 2*3 - 4 = 2
-    /// ```
-    #[must_use = "method returns a new vector and does not mutate the original value"]
-    fn mul_sub(self, a: Self, b: Self) -> Self;
 }
 
 macro_rules! impl_trait {
@@ -458,13 +439,6 @@ macro_rules! impl_trait {
                 // Safety: `self` is a float vector
                 unsafe { core::intrinsics::simd::simd_reduce_min(self) }
             }
-
-            #[inline]
-            fn mul_sub(self, a: Self, b: Self) -> Self {
-                // self * a - b = self * a + (-b)
-                // Safety: `self`, `a`, and `b` are float vectors
-                unsafe { core::intrinsics::simd::simd_fma(self, a, -b) }
-            }
         }
         )*
     }

crates/std_float/src/lib.rs

@@ -56,6 +56,19 @@ pub trait StdFloat: Sealed + Sized {
         unsafe { intrinsics::simd_fma(self, a, b) }
     }
 
+    /// Elementwise fused multiply-subtract. Computes `(self * a) - b` with only one rounding error,
+    /// yielding a more accurate result than an unfused multiply-subtract.
+    ///
+    /// Using `mul_sub` *may* be more performant than an unfused multiply-subtract if the target
+    /// architecture has a dedicated `fma` CPU instruction.  However, this is not always
+    /// true, and will be heavily dependent on designing algorithms with specific target
+    /// hardware in mind.
+    #[inline]
+    #[must_use = "method returns a new vector and does not mutate the original value"]
+    fn mul_sub(self, a: Self, b: Self) -> Self {
+        unsafe { intrinsics::simd_fma(self, a, -b) }
+    }
+
     /// Produces a vector where every element has the square root value
     /// of the equivalently-indexed element in `self`
     #[inline]