Move float tests from std to core where applicable

A lot of float functionality lives in `core` but only gets tested in
`std`. Split tests between `std` and `core` to reflect this and ensure
as much as possible also can also get tested on no-std targets.

Author: tgross35

library/core/src/num/f32.rs

@@ -1508,9 +1508,7 @@ impl f32 {
     }
 }
 
-/// Returns the largest integer less than or equal to `self`.
-///
-/// This function always returns the precise result.
+/// Experimental version of `floor` in `core`. See [`f32::floor`] for details.
 ///
 /// # Examples
 ///
@@ -1537,9 +1535,7 @@ pub fn floor(x: f32) -> f32 {
     unsafe { intrinsics::floorf32(x) }
 }
 
-/// Returns the smallest integer greater than or equal to `self`.
-///
-/// This function always returns the precise result.
+/// Experimental version of `ceil` in `core`. See [`f32::ceil`] for details.
 ///
 /// # Examples
 ///
@@ -1565,10 +1561,7 @@ pub fn ceil(x: f32) -> f32 {
     unsafe { intrinsics::ceilf32(x) }
 }
 
-/// Returns the nearest integer to `self`. If a value is half-way between two
-/// integers, round away from `0.0`.
-///
-/// This function always returns the precise result.
+/// Experimental version of `round` in `core`. See [`f32::round`] for details.
 ///
 /// # Examples
 ///
@@ -1599,10 +1592,7 @@ pub fn round(x: f32) -> f32 {
     unsafe { intrinsics::roundf32(x) }
 }
 
-/// Returns the nearest integer to a number. Rounds half-way cases to the number
-/// with an even least significant digit.
-///
-/// This function always returns the precise result.
+/// Experimental version of `round_ties_even` in `core`. See [`f32::round_ties_even`] for details.
 ///
 /// # Examples
 ///
@@ -1630,10 +1620,7 @@ pub fn round_ties_even(x: f32) -> f32 {
     intrinsics::round_ties_even_f32(x)
 }
 
-/// Returns the integer part of `self`.
-/// This means that non-integer numbers are always truncated towards zero.
-///
-/// This function always returns the precise result.
+/// Experimental version of `trunc` in `core`. See [`f32::trunc`] for details.
 ///
 /// # Examples
 ///
@@ -1661,9 +1648,7 @@ pub fn trunc(x: f32) -> f32 {
     unsafe { intrinsics::truncf32(x) }
 }
 
-/// Returns the fractional part of `self`.
-///
-/// This function always returns the precise result.
+/// Experimental version of `fract` in `core`. See [`f32::fract`] for details.
 ///
 /// # Examples
 ///
@@ -1689,19 +1674,7 @@ pub fn fract(x: f32) -> f32 {
     x - trunc(x)
 }
 
-/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
-/// error, yielding a more accurate result than an unfused multiply-add.
-///
-/// Using `mul_add` *may* be more performant than an unfused multiply-add if
-/// the target architecture has a dedicated `fma` CPU instruction. However,
-/// this is not always true, and will be heavily dependant on designing
-/// algorithms with specific target hardware in mind.
-///
-/// # Precision
-///
-/// The result of this operation is guaranteed to be the rounded
-/// infinite-precision result. It is specified by IEEE 754 as
-/// `fusedMultiplyAdd` and guaranteed not to change.
+/// Experimental version of `mul_add` in `core`. See [`f32::mul_add`] for details.
 ///
 /// # Examples
 ///
@@ -1737,17 +1710,7 @@ pub fn mul_add(x: f32, y: f32, z: f32) -> f32 {
     unsafe { intrinsics::fmaf32(x, y, z) }
 }
 
-/// Calculates Euclidean division, the matching method for `rem_euclid`.
-///
-/// This computes the integer `n` such that
-/// `self = n * rhs + self.rem_euclid(rhs)`.
-/// In other words, the result is `self / rhs` rounded to the integer `n`
-/// such that `self >= n * rhs`.
-///
-/// # Precision
-///
-/// The result of this operation is guaranteed to be the rounded
-/// infinite-precision result.
+/// Experimental version of `div_euclid` in `core`. See [`f32::div_euclid`] for details.
 ///
 /// # Examples
 ///
@@ -1776,21 +1739,7 @@ pub fn div_euclid(x: f32, rhs: f32) -> f32 {
     q
 }
 
-/// Calculates the least nonnegative remainder of `self (mod rhs)`.
-///
-/// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
-/// most cases. However, due to a floating point round-off error it can
-/// result in `r == rhs.abs()`, violating the mathematical definition, if
-/// `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
-/// This result is not an element of the function's codomain, but it is the
-/// closest floating point number in the real numbers and thus fulfills the
-/// property `self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs)`
-/// approximately.
-///
-/// # Precision
-///
-/// The result of this operation is guaranteed to be the rounded
-/// infinite-precision result.
+/// Experimental version of `rem_euclid` in `core`. See [`f32::rem_euclid`] for details.
 ///
 /// # Examples
 ///
@@ -1819,16 +1768,7 @@ pub fn rem_euclid(x: f32, rhs: f32) -> f32 {
     if r < 0.0 { r + rhs.abs() } else { r }
 }
 
-/// Raises a number to an integer power.
-///
-/// Using this function is generally faster than using `powf`.
-/// It might have a different sequence of rounding operations than `powf`,
-/// so the results are not guaranteed to agree.
-///
-/// # Unspecified precision
-///
-/// The precision of this function is non-deterministic. This means it varies by platform, Rust version, and
-/// can even differ within the same execution from one invocation to the next.
+/// Experimental version of `powi` in `core`. See [`f32::powi`] for details.
 ///
 /// # Examples
 ///
@@ -1853,15 +1793,7 @@ pub fn powi(x: f32, n: i32) -> f32 {
     unsafe { intrinsics::powif32(x, n) }
 }
 
-/// Returns the square root of a number.
-///
-/// Returns NaN if `self` is a negative number other than `-0.0`.
-///
-/// # Precision
-///
-/// The result of this operation is guaranteed to be the rounded
-/// infinite-precision result. It is specified by IEEE 754 as `squareRoot`
-/// and guaranteed not to change.
+/// Experimental version of `sqrt` in `core`. See [`f32::sqrt`] for details.
 ///
 /// # Examples
 ///
@@ -1889,17 +1821,7 @@ pub fn sqrt(x: f32) -> f32 {
     unsafe { intrinsics::sqrtf32(x) }
 }
 
-/// The positive difference of two numbers.
-///
-/// * If `self <= other`: `0.0`
-/// * Else: `self - other`
-///
-/// # Unspecified precision
-///
-/// The precision of this function is non-deterministic. This means it varies by platform, Rust version, and
-/// can even differ within the same execution from one invocation to the next.
-/// This function currently corresponds to the `fdimf` from libc on Unix
-/// and Windows. Note that this might change in the future.
+/// Experimental version of `abs_sub` in `core`. See [`f32::abs_sub`] for details.
 ///
 /// # Examples
 ///
@@ -1937,7 +1859,7 @@ pub fn abs_sub(x: f32, other: f32) -> f32 {
     unsafe { libm::fdimf(x, other) }
 }
 
-/// Returns the cube root of a number.
+/// Experimental version of `cbrt` in `core`. See [`f32::cbrt`] for details.
 ///
 /// # Unspecified precision
 ///
@@ -1956,6 +1878,8 @@ pub fn abs_sub(x: f32, other: f32) -> f32 {
 ///
 /// assert!(abs_difference <= f32::EPSILON);
 /// ```
+///
+/// _This standalone function is for testing only. It will be stabilized as an inherent method._
 #[inline]
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "core_float_math", issue = "137578")]