nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #128417 - tgross35:f16-f128-math, r=dtolnay

Browse Source 
Add `f16` and `f128` math functions

This adds intrinsics and math functions for `f16` and `f128` floating point types. Support is quite limited and some things are broken so tests don't run on many platforms, but this provides a starting point.
This commit is contained in:
Trevor Gross 2024-08-06 22:17:32 -05:00 committed by GitHub
commit b3bfd66627
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 4157 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
compiler/rustc_codegen_llvm/src/context.rs
View File

@ -775,10 +775,10 @@ impl<'ll> CodegenCx<'ll, '_> {
ifn!("llvm.debugtrap", fn() -> void);
ifn!("llvm.frameaddress", fn(t_i32) -> ptr);
ifn!("llvm.powi.f16", fn(t_f16, t_i32) -> t_f16);
ifn!("llvm.powi.f32", fn(t_f32, t_i32) -> t_f32);
ifn!("llvm.powi.f64", fn(t_f64, t_i32) -> t_f64);
ifn!("llvm.powi.f128", fn(t_f128, t_i32) -> t_f128);
ifn!("llvm.powi.f16.i32", fn(t_f16, t_i32) -> t_f16);
ifn!("llvm.powi.f32.i32", fn(t_f32, t_i32) -> t_f32);
ifn!("llvm.powi.f64.i32", fn(t_f64, t_i32) -> t_f64);
ifn!("llvm.powi.f128.i32", fn(t_f128, t_i32) -> t_f128);
ifn!("llvm.pow.f16", fn(t_f16, t_f16) -> t_f16);
ifn!("llvm.pow.f32", fn(t_f32, t_f32) -> t_f32);

8
compiler/rustc_codegen_llvm/src/intrinsic.rs
View File

@ -35,10 +35,10 @@ fn get_simple_intrinsic<'ll>(
sym::sqrtf64 => "llvm.sqrt.f64",
sym::sqrtf128 => "llvm.sqrt.f128",
sym::powif16 => "llvm.powi.f16",
sym::powif32 => "llvm.powi.f32",
sym::powif64 => "llvm.powi.f64",
sym::powif128 => "llvm.powi.f128",
sym::powif16 => "llvm.powi.f16.i32",
sym::powif32 => "llvm.powi.f32.i32",
sym::powif64 => "llvm.powi.f64.i32",
sym::powif128 => "llvm.powi.f128.i32",
sym::sinf16 => "llvm.sin.f16",
sym::sinf32 => "llvm.sin.f32",

289
library/core/src/intrinsics.rs
View File

@ -1528,6 +1528,12 @@ extern "rust-intrinsic" {
#[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]
pub fn unaligned_volatile_store<T>(dst: *mut T, val: T);
/// Returns the square root of an `f16`
///
/// The stabilized version of this intrinsic is
/// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
#[rustc_nounwind]
pub fn sqrtf16(x: f16) -> f16;
/// Returns the square root of an `f32`
///
/// The stabilized version of this intrinsic is
@ -1540,6 +1546,12 @@ extern "rust-intrinsic" {
/// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
#[rustc_nounwind]
pub fn sqrtf64(x: f64) -> f64;
/// Returns the square root of an `f128`
///
/// The stabilized version of this intrinsic is
/// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
#[rustc_nounwind]
pub fn sqrtf128(x: f128) -> f128;
/// Raises an `f16` to an integer power.
///
@ -1566,6 +1578,12 @@ extern "rust-intrinsic" {
#[rustc_nounwind]
pub fn powif128(a: f128, x: i32) -> f128;
/// Returns the sine of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::sin`](../../std/primitive.f16.html#method.sin)
#[rustc_nounwind]
pub fn sinf16(x: f16) -> f16;
/// Returns the sine of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1578,7 +1596,19 @@ extern "rust-intrinsic" {
/// [`f64::sin`](../../std/primitive.f64.html#method.sin)
#[rustc_nounwind]
pub fn sinf64(x: f64) -> f64;
/// Returns the sine of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::sin`](../../std/primitive.f128.html#method.sin)
#[rustc_nounwind]
pub fn sinf128(x: f128) -> f128;
/// Returns the cosine of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::cos`](../../std/primitive.f16.html#method.cos)
#[rustc_nounwind]
pub fn cosf16(x: f16) -> f16;
/// Returns the cosine of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1591,7 +1621,19 @@ extern "rust-intrinsic" {
/// [`f64::cos`](../../std/primitive.f64.html#method.cos)
#[rustc_nounwind]
pub fn cosf64(x: f64) -> f64;
/// Returns the cosine of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::cos`](../../std/primitive.f128.html#method.cos)
#[rustc_nounwind]
pub fn cosf128(x: f128) -> f128;
/// Raises an `f16` to an `f16` power.
///
/// The stabilized version of this intrinsic is
/// [`f16::powf`](../../std/primitive.f16.html#method.powf)
#[rustc_nounwind]
pub fn powf16(a: f16, x: f16) -> f16;
/// Raises an `f32` to an `f32` power.
///
/// The stabilized version of this intrinsic is
@ -1604,7 +1646,19 @@ extern "rust-intrinsic" {
/// [`f64::powf`](../../std/primitive.f64.html#method.powf)
#[rustc_nounwind]
pub fn powf64(a: f64, x: f64) -> f64;
/// Raises an `f128` to an `f128` power.
///
/// The stabilized version of this intrinsic is
/// [`f128::powf`](../../std/primitive.f128.html#method.powf)
#[rustc_nounwind]
pub fn powf128(a: f128, x: f128) -> f128;
/// Returns the exponential of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::exp`](../../std/primitive.f16.html#method.exp)
#[rustc_nounwind]
pub fn expf16(x: f16) -> f16;
/// Returns the exponential of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1617,7 +1671,19 @@ extern "rust-intrinsic" {
/// [`f64::exp`](../../std/primitive.f64.html#method.exp)
#[rustc_nounwind]
pub fn expf64(x: f64) -> f64;
/// Returns the exponential of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::exp`](../../std/primitive.f128.html#method.exp)
#[rustc_nounwind]
pub fn expf128(x: f128) -> f128;
/// Returns 2 raised to the power of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
#[rustc_nounwind]
pub fn exp2f16(x: f16) -> f16;
/// Returns 2 raised to the power of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1630,7 +1696,19 @@ extern "rust-intrinsic" {
/// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
#[rustc_nounwind]
pub fn exp2f64(x: f64) -> f64;
/// Returns 2 raised to the power of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
#[rustc_nounwind]
pub fn exp2f128(x: f128) -> f128;
/// Returns the natural logarithm of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::ln`](../../std/primitive.f16.html#method.ln)
#[rustc_nounwind]
pub fn logf16(x: f16) -> f16;
/// Returns the natural logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1643,7 +1721,19 @@ extern "rust-intrinsic" {
/// [`f64::ln`](../../std/primitive.f64.html#method.ln)
#[rustc_nounwind]
pub fn logf64(x: f64) -> f64;
/// Returns the natural logarithm of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::ln`](../../std/primitive.f128.html#method.ln)
#[rustc_nounwind]
pub fn logf128(x: f128) -> f128;
/// Returns the base 10 logarithm of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::log10`](../../std/primitive.f16.html#method.log10)
#[rustc_nounwind]
pub fn log10f16(x: f16) -> f16;
/// Returns the base 10 logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1656,7 +1746,19 @@ extern "rust-intrinsic" {
/// [`f64::log10`](../../std/primitive.f64.html#method.log10)
#[rustc_nounwind]
pub fn log10f64(x: f64) -> f64;
/// Returns the base 10 logarithm of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::log10`](../../std/primitive.f128.html#method.log10)
#[rustc_nounwind]
pub fn log10f128(x: f128) -> f128;
/// Returns the base 2 logarithm of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::log2`](../../std/primitive.f16.html#method.log2)
#[rustc_nounwind]
pub fn log2f16(x: f16) -> f16;
/// Returns the base 2 logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1669,7 +1771,19 @@ extern "rust-intrinsic" {
/// [`f64::log2`](../../std/primitive.f64.html#method.log2)
#[rustc_nounwind]
pub fn log2f64(x: f64) -> f64;
/// Returns the base 2 logarithm of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::log2`](../../std/primitive.f128.html#method.log2)
#[rustc_nounwind]
pub fn log2f128(x: f128) -> f128;
/// Returns `a * b + c` for `f16` values.
///
/// The stabilized version of this intrinsic is
/// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
#[rustc_nounwind]
pub fn fmaf16(a: f16, b: f16, c: f16) -> f16;
/// Returns `a * b + c` for `f32` values.
///
/// The stabilized version of this intrinsic is
@ -1682,7 +1796,19 @@ extern "rust-intrinsic" {
/// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
#[rustc_nounwind]
pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
/// Returns `a * b + c` for `f128` values.
///
/// The stabilized version of this intrinsic is
/// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
#[rustc_nounwind]
pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
/// Returns the absolute value of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::abs`](../../std/primitive.f16.html#method.abs)
#[rustc_nounwind]
pub fn fabsf16(x: f16) -> f16;
/// Returns the absolute value of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1695,7 +1821,25 @@ extern "rust-intrinsic" {
/// [`f64::abs`](../../std/primitive.f64.html#method.abs)
#[rustc_nounwind]
pub fn fabsf64(x: f64) -> f64;
/// Returns the absolute value of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::abs`](../../std/primitive.f128.html#method.abs)
#[rustc_nounwind]
pub fn fabsf128(x: f128) -> f128;
/// Returns the minimum of two `f16` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
/// it does not require an `unsafe` block.
/// Therefore, implementations must not require the user to uphold
/// any safety invariants.
///
/// The stabilized version of this intrinsic is
/// [`f16::min`]
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn minnumf16(x: f16, y: f16) -> f16;
/// Returns the minimum of two `f32` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
@ -1720,6 +1864,31 @@ extern "rust-intrinsic" {
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn minnumf64(x: f64, y: f64) -> f64;
/// Returns the minimum of two `f128` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
/// it does not require an `unsafe` block.
/// Therefore, implementations must not require the user to uphold
/// any safety invariants.
///
/// The stabilized version of this intrinsic is
/// [`f128::min`]
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn minnumf128(x: f128, y: f128) -> f128;
/// Returns the maximum of two `f16` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
/// it does not require an `unsafe` block.
/// Therefore, implementations must not require the user to uphold
/// any safety invariants.
///
/// The stabilized version of this intrinsic is
/// [`f16::max`]
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn maxnumf16(x: f16, y: f16) -> f16;
/// Returns the maximum of two `f32` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
@ -1744,7 +1913,25 @@ extern "rust-intrinsic" {
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn maxnumf64(x: f64, y: f64) -> f64;
/// Returns the maximum of two `f128` values.
///
/// Note that, unlike most intrinsics, this is safe to call;
/// it does not require an `unsafe` block.
/// Therefore, implementations must not require the user to uphold
/// any safety invariants.
///
/// The stabilized version of this intrinsic is
/// [`f128::max`]
#[rustc_safe_intrinsic]
#[rustc_nounwind]
pub fn maxnumf128(x: f128, y: f128) -> f128;
/// Copies the sign from `y` to `x` for `f16` values.
///
/// The stabilized version of this intrinsic is
/// [`f16::copysign`](../../std/primitive.f16.html#method.copysign)
#[rustc_nounwind]
pub fn copysignf16(x: f16, y: f16) -> f16;
/// Copies the sign from `y` to `x` for `f32` values.
///
/// The stabilized version of this intrinsic is
@ -1757,7 +1944,19 @@ extern "rust-intrinsic" {
/// [`f64::copysign`](../../std/primitive.f64.html#method.copysign)
#[rustc_nounwind]
pub fn copysignf64(x: f64, y: f64) -> f64;
/// Copies the sign from `y` to `x` for `f128` values.
///
/// The stabilized version of this intrinsic is
/// [`f128::copysign`](../../std/primitive.f128.html#method.copysign)
#[rustc_nounwind]
pub fn copysignf128(x: f128, y: f128) -> f128;
/// Returns the largest integer less than or equal to an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::floor`](../../std/primitive.f16.html#method.floor)
#[rustc_nounwind]
pub fn floorf16(x: f16) -> f16;
/// Returns the largest integer less than or equal to an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1770,7 +1969,19 @@ extern "rust-intrinsic" {
/// [`f64::floor`](../../std/primitive.f64.html#method.floor)
#[rustc_nounwind]
pub fn floorf64(x: f64) -> f64;
/// Returns the largest integer less than or equal to an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::floor`](../../std/primitive.f128.html#method.floor)
#[rustc_nounwind]
pub fn floorf128(x: f128) -> f128;
/// Returns the smallest integer greater than or equal to an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
#[rustc_nounwind]
pub fn ceilf16(x: f16) -> f16;
/// Returns the smallest integer greater than or equal to an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1783,7 +1994,19 @@ extern "rust-intrinsic" {
/// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
#[rustc_nounwind]
pub fn ceilf64(x: f64) -> f64;
/// Returns the smallest integer greater than or equal to an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
#[rustc_nounwind]
pub fn ceilf128(x: f128) -> f128;
/// Returns the integer part of an `f16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
#[rustc_nounwind]
pub fn truncf16(x: f16) -> f16;
/// Returns the integer part of an `f32`.
///
/// The stabilized version of this intrinsic is
@ -1796,7 +2019,25 @@ extern "rust-intrinsic" {
/// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
#[rustc_nounwind]
pub fn truncf64(x: f64) -> f64;
/// Returns the integer part of an `f128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
#[rustc_nounwind]
pub fn truncf128(x: f128) -> f128;
/// Returns the nearest integer to an `f16`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
/// May raise an inexact floating-point exception if the argument is not an integer.
/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
/// cannot actually be utilized from Rust code.
/// In other words, this intrinsic is equivalent in behavior to `nearbyintf16` and `roundevenf16`.
///
/// The stabilized version of this intrinsic is
/// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
#[rustc_nounwind]
pub fn rintf16(x: f16) -> f16;
/// Returns the nearest integer to an `f32`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
@ -1821,7 +2062,25 @@ extern "rust-intrinsic" {
/// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
#[rustc_nounwind]
pub fn rintf64(x: f64) -> f64;
/// Returns the nearest integer to an `f128`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
/// May raise an inexact floating-point exception if the argument is not an integer.
/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
/// cannot actually be utilized from Rust code.
/// In other words, this intrinsic is equivalent in behavior to `nearbyintf128` and `roundevenf128`.
///
/// The stabilized version of this intrinsic is
/// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
#[rustc_nounwind]
pub fn rintf128(x: f128) -> f128;
/// Returns the nearest integer to an `f16`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn nearbyintf16(x: f16) -> f16;
/// Returns the nearest integer to an `f32`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
@ -1834,7 +2093,19 @@ extern "rust-intrinsic" {
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn nearbyintf64(x: f64) -> f64;
/// Returns the nearest integer to an `f128`. Changing the rounding mode is not possible in Rust,
/// so this rounds half-way cases to the number with an even least significant digit.
///
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn nearbyintf128(x: f128) -> f128;
/// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
///
/// The stabilized version of this intrinsic is
/// [`f16::round`](../../std/primitive.f16.html#method.round)
#[rustc_nounwind]
pub fn roundf16(x: f16) -> f16;
/// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
///
/// The stabilized version of this intrinsic is
@ -1847,7 +2118,19 @@ extern "rust-intrinsic" {
/// [`f64::round`](../../std/primitive.f64.html#method.round)
#[rustc_nounwind]
pub fn roundf64(x: f64) -> f64;
/// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
///
/// The stabilized version of this intrinsic is
/// [`f128::round`](../../std/primitive.f128.html#method.round)
#[rustc_nounwind]
pub fn roundf128(x: f128) -> f128;
/// Returns the nearest integer to an `f16`. Rounds half-way cases to the number
/// with an even least significant digit.
///
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn roundevenf16(x: f16) -> f16;
/// Returns the nearest integer to an `f32`. Rounds half-way cases to the number
/// with an even least significant digit.
///
@ -1860,6 +2143,12 @@ extern "rust-intrinsic" {
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn roundevenf64(x: f64) -> f64;
/// Returns the nearest integer to an `f128`. Rounds half-way cases to the number
/// with an even least significant digit.
///
/// This intrinsic does not have a stable counterpart.
#[rustc_nounwind]
pub fn roundevenf128(x: f128) -> f128;
/// Float addition that allows optimizations based on algebraic rules.
/// May assume inputs are finite.

176
library/core/src/num/f128.rs
View File

@ -686,6 +686,182 @@ impl f128 {
self * RADS_PER_DEG
}
/// Returns the maximum of the two numbers, ignoring NaN.
///
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE 754-2008 semantics for maxNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids maxNum's problems with associativity.
/// This also matches the behavior of libm’s fmax.
///
/// ```
/// #![feature(f128)]
/// # // Using aarch64 because `reliable_f128_math` is needed
/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {
///
/// let x = 1.0f128;
/// let y = 2.0f128;
///
/// assert_eq!(x.max(y), y);
/// # }
/// ```
#[inline]
#[unstable(feature = "f128", issue = "116909")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn max(self, other: f128) -> f128 {
intrinsics::maxnumf128(self, other)
}
/// Returns the minimum of the two numbers, ignoring NaN.
///
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE 754-2008 semantics for minNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids minNum's problems with associativity.
/// This also matches the behavior of libm’s fmin.
///
/// ```
/// #![feature(f128)]
/// # // Using aarch64 because `reliable_f128_math` is needed
/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {
///
/// let x = 1.0f128;
/// let y = 2.0f128;
///
/// assert_eq!(x.min(y), x);
/// # }
/// ```
#[inline]
#[unstable(feature = "f128", issue = "116909")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn min(self, other: f128) -> f128 {
intrinsics::minnumf128(self, other)
}
/// Returns the maximum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f128::max`] which only returns NaN when *both* arguments are NaN.
///
/// ```
/// #![feature(f128)]
/// #![feature(float_minimum_maximum)]
/// # // Using aarch64 because `reliable_f128_math` is needed
/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {
///
/// let x = 1.0f128;
/// let y = 2.0f128;
///
/// assert_eq!(x.maximum(y), y);
/// assert!(x.maximum(f128::NAN).is_nan());
/// # }
/// ```
///
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f128) for more info.
#[inline]
#[unstable(feature = "f128", issue = "116909")]
// #[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn maximum(self, other: f128) -> f128 {
if self > other {
self
} else if other > self {
other
} else if self == other {
if self.is_sign_positive() && other.is_sign_negative() { self } else { other }
} else {
self + other
}
}
/// Returns the minimum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f128::min`] which only returns NaN when *both* arguments are NaN.
///
/// ```
/// #![feature(f128)]
/// #![feature(float_minimum_maximum)]
/// # // Using aarch64 because `reliable_f128_math` is needed
/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {
///
/// let x = 1.0f128;
/// let y = 2.0f128;
///
/// assert_eq!(x.minimum(y), x);
/// assert!(x.minimum(f128::NAN).is_nan());
/// # }
/// ```
///
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f128) for more info.
#[inline]
#[unstable(feature = "f128", issue = "116909")]
// #[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn minimum(self, other: f128) -> f128 {
if self < other {
self
} else if other < self {
other
} else if self == other {
if self.is_sign_negative() && other.is_sign_positive() { self } else { other }
} else {
// At least one input is NaN. Use `+` to perform NaN propagation and quieting.
self + other
}
}
/// Calculates the middle point of `self` and `rhs`.
///
/// This returns NaN when *either* argument is NaN or if a combination of
/// +inf and -inf is provided as arguments.
///
/// # Examples
///
/// ```
/// #![feature(f128)]
/// #![feature(num_midpoint)]
/// # // Using aarch64 because `reliable_f128_math` is needed
/// # #[cfg(all(target_arch = "aarch64", target_os = "linux"))] {
///
/// assert_eq!(1f128.midpoint(4.0), 2.5);
/// assert_eq!((-5.5f128).midpoint(8.0), 1.25);
/// # }
/// ```
#[inline]
#[unstable(feature = "f128", issue = "116909")]
// #[unstable(feature = "num_midpoint", issue = "110840")]
pub fn midpoint(self, other: f128) -> f128 {
const LO: f128 = f128::MIN_POSITIVE * 2.;
const HI: f128 = f128::MAX / 2.;
let (a, b) = (self, other);
let abs_a = a.abs_private();
let abs_b = b.abs_private();
if abs_a <= HI && abs_b <= HI {
// Overflow is impossible
(a + b) / 2.
} else if abs_a < LO {
// Not safe to halve `a` (would underflow)
a + (b / 2.)
} else if abs_b < LO {
// Not safe to halve `b` (would underflow)
(a / 2.) + b
} else {
// Safe to halve `a` and `b`
(a / 2.) + (b / 2.)
}
}
/// Rounds toward zero and converts to any primitive integer type,
/// assuming that the value is finite and fits in that type.
///

171
library/core/src/num/f16.rs
View File

@ -720,6 +720,177 @@ impl f16 {
self * RADS_PER_DEG
}
/// Returns the maximum of the two numbers, ignoring NaN.
///
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE 754-2008 semantics for maxNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids maxNum's problems with associativity.
/// This also matches the behavior of libm’s fmax.
///
/// ```
/// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
///
/// let x = 1.0f16;
/// let y = 2.0f16;
///
/// assert_eq!(x.max(y), y);
/// # }
/// ```
#[inline]
#[unstable(feature = "f16", issue = "116909")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn max(self, other: f16) -> f16 {
intrinsics::maxnumf16(self, other)
}
/// Returns the minimum of the two numbers, ignoring NaN.
///
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE 754-2008 semantics for minNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids minNum's problems with associativity.
/// This also matches the behavior of libm’s fmin.
///
/// ```
/// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
///
/// let x = 1.0f16;
/// let y = 2.0f16;
///
/// assert_eq!(x.min(y), x);
/// # }
/// ```
#[inline]
#[unstable(feature = "f16", issue = "116909")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn min(self, other: f16) -> f16 {
intrinsics::minnumf16(self, other)
}
/// Returns the maximum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f16::max`] which only returns NaN when *both* arguments are NaN.
///
/// ```
/// #![feature(f16)]
/// #![feature(float_minimum_maximum)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
///
/// let x = 1.0f16;
/// let y = 2.0f16;
///
/// assert_eq!(x.maximum(y), y);
/// assert!(x.maximum(f16::NAN).is_nan());
/// # }
/// ```
///
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f16) for more info.
#[inline]
#[unstable(feature = "f16", issue = "116909")]
// #[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn maximum(self, other: f16) -> f16 {
if self > other {
self
} else if other > self {
other
} else if self == other {
if self.is_sign_positive() && other.is_sign_negative() { self } else { other }
} else {
self + other
}
}
/// Returns the minimum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f16::min`] which only returns NaN when *both* arguments are NaN.
///
/// ```
/// #![feature(f16)]
/// #![feature(float_minimum_maximum)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
///
/// let x = 1.0f16;
/// let y = 2.0f16;
///
/// assert_eq!(x.minimum(y), x);
/// assert!(x.minimum(f16::NAN).is_nan());
/// # }
/// ```
///
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f16) for more info.
#[inline]
#[unstable(feature = "f16", issue = "116909")]
// #[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[must_use = "this returns the result of the comparison, without modifying either input"]
pub fn minimum(self, other: f16) -> f16 {
if self < other {
self
} else if other < self {
other
} else if self == other {
if self.is_sign_negative() && other.is_sign_positive() { self } else { other }
} else {
// At least one input is NaN. Use `+` to perform NaN propagation and quieting.
self + other
}
}
/// Calculates the middle point of `self` and `rhs`.
///
/// This returns NaN when *either* argument is NaN or if a combination of
/// +inf and -inf is provided as arguments.
///
/// # Examples
///
/// ```
/// #![feature(f16)]
/// #![feature(num_midpoint)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
///
/// assert_eq!(1f16.midpoint(4.0), 2.5);
/// assert_eq!((-5.5f16).midpoint(8.0), 1.25);
/// # }
/// ```
#[inline]
#[unstable(feature = "f16", issue = "116909")]
// #[unstable(feature = "num_midpoint", issue = "110840")]
pub fn midpoint(self, other: f16) -> f16 {
const LO: f16 = f16::MIN_POSITIVE * 2.;
const HI: f16 = f16::MAX / 2.;
let (a, b) = (self, other);
let abs_a = a.abs_private();
let abs_b = b.abs_private();
if abs_a <= HI && abs_b <= HI {
// Overflow is impossible
(a + b) / 2.
} else if abs_a < LO {
// Not safe to halve `a` (would underflow)
a + (b / 2.)
} else if abs_b < LO {
// Not safe to halve `b` (would underflow)
(a / 2.) + b
} else {
// Safe to halve `a` and `b`
(a / 2.) + (b / 2.)
}
}
/// Rounds toward zero and converts to any primitive integer type,
/// assuming that the value is finite and fits in that type.
///

6
library/core/src/num/f32.rs
View File

@ -1070,13 +1070,13 @@ impl f32 {
// Overflow is impossible
(a + b) / 2.
} else if abs_a < LO {
// Not safe to halve a
// Not safe to halve `a` (would underflow)
a + (b / 2.)
} else if abs_b < LO {
// Not safe to halve b
// Not safe to halve `b` (would underflow)
(a / 2.) + b
} else {
// Not safe to halve a and b
// Safe to halve `a` and `b`
(a / 2.) + (b / 2.)
}
}

6
library/core/src/num/f64.rs
View File

@ -1064,13 +1064,13 @@ impl f64 {
// Overflow is impossible
(a + b) / 2.
} else if abs_a < LO {
// Not safe to halve a
// Not safe to halve `a` (would underflow)
a + (b / 2.)
} else if abs_b < LO {
// Not safe to halve b
// Not safe to halve `b` (would underflow)
(a / 2.) + b
} else {
// Not safe to halve a and b
// Safe to halve `a` and `b`
(a / 2.) + (b / 2.)
}
}

3
library/core/src/primitive_docs.rs
View File

@ -1244,6 +1244,9 @@ mod prim_f64 {}
/// actually implement it. For x86-64 and AArch64, ISA support is not even specified,
/// so it will always be a software implementation significantly slower than `f64`.
///
/// _Note: `f128` support is incomplete. Many platforms will not be able to link math functions. On
/// x86 in particular, these functions do link but their results are always incorrect._
///
/// *[See also the `std::f128::consts` module](crate::f128::consts).*
///
/// [wikipedia]: https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format

37
library/std/build.rs
View File

@ -85,6 +85,11 @@ fn main() {
println!("cargo:rustc-check-cfg=cfg(reliable_f16)");
println!("cargo:rustc-check-cfg=cfg(reliable_f128)");
// This is a step beyond only having the types and basic functions available. Math functions
// aren't consistently available or correct.
println!("cargo:rustc-check-cfg=cfg(reliable_f16_math)");
println!("cargo:rustc-check-cfg=cfg(reliable_f128_math)");
let has_reliable_f16 = match (target_arch.as_str(), target_os.as_str()) {
// Selection failure until recent LLVM <https://github.com/llvm/llvm-project/issues/93894>
// FIXME(llvm19): can probably be removed at the version bump
@ -130,10 +135,42 @@ fn main() {
_ => false,
};
// These are currently empty, but will fill up as some platforms move from completely
// unreliable to reliable basics but unreliable math.
// LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>
let has_reliable_f16_math = has_reliable_f16
&& match (target_arch.as_str(), target_os.as_str()) {
// Currently nothing special. Hooray!
// This will change as platforms gain better better support for standard ops but math
// lags behind.
_ => true,
};
let has_reliable_f128_math = has_reliable_f128
&& match (target_arch.as_str(), target_os.as_str()) {
// LLVM lowers `fp128` math to `long double` symbols even on platforms where
// `long double` is not IEEE binary128. See
// <https://github.com/llvm/llvm-project/issues/44744>.
//
// This rules out anything that doesn't have `long double` = `binary128`; <= 32 bits
// (ld is `f64`), anything other than Linux (Windows and MacOS use `f64`), and `x86`
// (ld is 80-bit extended precision).
("x86_64", _) => false,
(_, "linux") if target_pointer_width == 64 => true,
_ => false,
};
if has_reliable_f16 {
println!("cargo:rustc-cfg=reliable_f16");
}
if has_reliable_f128 {
println!("cargo:rustc-cfg=reliable_f128");
}
if has_reliable_f16_math {
println!("cargo:rustc-cfg=reliable_f16_math");
}
if has_reliable_f128_math {
println!("cargo:rustc-cfg=reliable_f128_math");
}
}

1300
library/std/src/f128.rs
View File

File diff suppressed because it is too large Load Diff

476
library/std/src/f128/tests.rs
View File

@ -4,6 +4,21 @@
use crate::f128::consts;
use crate::num::{FpCategory as Fp, *};
// Note these tolerances make sense around zero, but not for more extreme exponents.
/// For operations that are near exact, usually not involving math of different
/// signs.
const TOL_PRECISE: f128 = 1e-28;
/// Default tolerances. Works for values that should be near precise but not exact. Roughly
/// the precision carried by `100 * 100`.
const TOL: f128 = 1e-12;
/// Tolerances for math that is allowed to be imprecise, usually due to multiple chained
/// operations.
#[cfg(reliable_f128_math)]
const TOL_IMPR: f128 = 1e-10;
/// Smallest number
const TINY_BITS: u128 = 0x1;
@ -41,7 +56,33 @@ fn test_num_f128() {
test_num(10f128, 2f128);
}
// FIXME(f16_f128): add min and max tests when available
#[test]
#[cfg(reliable_f128_math)]
fn test_min_nan() {
assert_eq!(f128::NAN.min(2.0), 2.0);
assert_eq!(2.0f128.min(f128::NAN), 2.0);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_max_nan() {
assert_eq!(f128::NAN.max(2.0), 2.0);
assert_eq!(2.0f128.max(f128::NAN), 2.0);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_minimum() {
assert!(f128::NAN.minimum(2.0).is_nan());
assert!(2.0f128.minimum(f128::NAN).is_nan());
}
#[test]
#[cfg(reliable_f128_math)]
fn test_maximum() {
assert!(f128::NAN.maximum(2.0).is_nan());
assert!(2.0f128.maximum(f128::NAN).is_nan());
}
#[test]
fn test_nan() {
@ -191,9 +232,100 @@ fn test_classify() {
assert_eq!(1e-4932f128.classify(), Fp::Subnormal);
}
// FIXME(f16_f128): add missing math functions when available
#[test]
#[cfg(reliable_f128_math)]
fn test_floor() {
assert_approx_eq!(1.0f128.floor(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.floor(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.floor(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.floor(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.floor(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).floor(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).floor(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).floor(), -2.0f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).floor(), -2.0f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).floor(), -2.0f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_ceil() {
assert_approx_eq!(1.0f128.ceil(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.ceil(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.ceil(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.ceil(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.ceil(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).ceil(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).ceil(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).ceil(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).ceil(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).ceil(), -1.0f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_round() {
assert_approx_eq!(2.5f128.round(), 3.0f128, TOL_PRECISE);
assert_approx_eq!(1.0f128.round(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.round(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.round(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.round(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.round(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).round(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).round(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).round(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).round(), -2.0f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).round(), -2.0f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_round_ties_even() {
assert_approx_eq!(2.5f128.round_ties_even(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.0f128.round_ties_even(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.round_ties_even(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.round_ties_even(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.round_ties_even(), 2.0f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.round_ties_even(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).round_ties_even(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).round_ties_even(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).round_ties_even(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).round_ties_even(), -2.0f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).round_ties_even(), -2.0f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_trunc() {
assert_approx_eq!(1.0f128.trunc(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.trunc(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.trunc(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.trunc(), 1.0f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.trunc(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).trunc(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).trunc(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).trunc(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).trunc(), -1.0f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).trunc(), -1.0f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_fract() {
assert_approx_eq!(1.0f128.fract(), 0.0f128, TOL_PRECISE);
assert_approx_eq!(1.3f128.fract(), 0.3f128, TOL_PRECISE);
assert_approx_eq!(1.5f128.fract(), 0.5f128, TOL_PRECISE);
assert_approx_eq!(1.7f128.fract(), 0.7f128, TOL_PRECISE);
assert_approx_eq!(0.0f128.fract(), 0.0f128, TOL_PRECISE);
assert_approx_eq!((-0.0f128).fract(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.0f128).fract(), -0.0f128, TOL_PRECISE);
assert_approx_eq!((-1.3f128).fract(), -0.3f128, TOL_PRECISE);
assert_approx_eq!((-1.5f128).fract(), -0.5f128, TOL_PRECISE);
assert_approx_eq!((-1.7f128).fract(), -0.7f128, TOL_PRECISE);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_abs() {
assert_eq!(f128::INFINITY.abs(), f128::INFINITY);
assert_eq!(1f128.abs(), 1f128);
@ -293,6 +425,24 @@ fn test_next_down() {
}
#[test]
#[cfg(reliable_f128_math)]
fn test_mul_add() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_approx_eq!(12.3f128.mul_add(4.5, 6.7), 62.05, TOL_PRECISE);
assert_approx_eq!((-12.3f128).mul_add(-4.5, -6.7), 48.65, TOL_PRECISE);
assert_approx_eq!(0.0f128.mul_add(8.9, 1.2), 1.2, TOL_PRECISE);
assert_approx_eq!(3.4f128.mul_add(-0.0, 5.6), 5.6, TOL_PRECISE);
assert!(nan.mul_add(7.8, 9.0).is_nan());
assert_eq!(inf.mul_add(7.8, 9.0), inf);
assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
assert_eq!(8.9f128.mul_add(inf, 3.2), inf);
assert_eq!((-3.2f128).mul_add(2.4, neg_inf), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_recip() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
@ -301,11 +451,161 @@ fn test_recip() {
assert_eq!(2.0f128.recip(), 0.5);
assert_eq!((-0.4f128).recip(), -2.5);
assert_eq!(0.0f128.recip(), inf);
assert_approx_eq!(
f128::MAX.recip(),
8.40525785778023376565669454330438228902076605e-4933,
1e-4900
);
assert!(nan.recip().is_nan());
assert_eq!(inf.recip(), 0.0);
assert_eq!(neg_inf.recip(), 0.0);
}
// Many math functions allow for less accurate results, so the next tolerance up is used
#[test]
#[cfg(reliable_f128_math)]
fn test_powi() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(1.0f128.powi(1), 1.0);
assert_approx_eq!((-3.1f128).powi(2), 9.6100000000000005506706202140776519387, TOL);
assert_approx_eq!(5.9f128.powi(-2), 0.028727377190462507313100483690639638451, TOL);
assert_eq!(8.3f128.powi(0), 1.0);
assert!(nan.powi(2).is_nan());
assert_eq!(inf.powi(3), inf);
assert_eq!(neg_inf.powi(2), inf);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_powf() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(1.0f128.powf(1.0), 1.0);
assert_approx_eq!(3.4f128.powf(4.5), 246.40818323761892815995637964326426756, TOL_IMPR);
assert_approx_eq!(2.7f128.powf(-3.2), 0.041652009108526178281070304373500889273, TOL_IMPR);
assert_approx_eq!((-3.1f128).powf(2.0), 9.6100000000000005506706202140776519387, TOL_IMPR);
assert_approx_eq!(5.9f128.powf(-2.0), 0.028727377190462507313100483690639638451, TOL_IMPR);
assert_eq!(8.3f128.powf(0.0), 1.0);
assert!(nan.powf(2.0).is_nan());
assert_eq!(inf.powf(2.0), inf);
assert_eq!(neg_inf.powf(3.0), neg_inf);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_sqrt_domain() {
assert!(f128::NAN.sqrt().is_nan());
assert!(f128::NEG_INFINITY.sqrt().is_nan());
assert!((-1.0f128).sqrt().is_nan());
assert_eq!((-0.0f128).sqrt(), -0.0);
assert_eq!(0.0f128.sqrt(), 0.0);
assert_eq!(1.0f128.sqrt(), 1.0);
assert_eq!(f128::INFINITY.sqrt(), f128::INFINITY);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_exp() {
assert_eq!(1.0, 0.0f128.exp());
assert_approx_eq!(consts::E, 1.0f128.exp(), TOL);
assert_approx_eq!(148.41315910257660342111558004055227962348775, 5.0f128.exp(), TOL);
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
let nan: f128 = f128::NAN;
assert_eq!(inf, inf.exp());
assert_eq!(0.0, neg_inf.exp());
assert!(nan.exp().is_nan());
}
#[test]
#[cfg(reliable_f128_math)]
fn test_exp2() {
assert_eq!(32.0, 5.0f128.exp2());
assert_eq!(1.0, 0.0f128.exp2());
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
let nan: f128 = f128::NAN;
assert_eq!(inf, inf.exp2());
assert_eq!(0.0, neg_inf.exp2());
assert!(nan.exp2().is_nan());
}
#[test]
#[cfg(reliable_f128_math)]
fn test_ln() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_approx_eq!(1.0f128.exp().ln(), 1.0, TOL);
assert!(nan.ln().is_nan());
assert_eq!(inf.ln(), inf);
assert!(neg_inf.ln().is_nan());
assert!((-2.3f128).ln().is_nan());
assert_eq!((-0.0f128).ln(), neg_inf);
assert_eq!(0.0f128.ln(), neg_inf);
assert_approx_eq!(4.0f128.ln(), 1.3862943611198906188344642429163531366, TOL);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_log() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(10.0f128.log(10.0), 1.0);
assert_approx_eq!(2.3f128.log(3.5), 0.66485771361478710036766645911922010272, TOL);
assert_eq!(1.0f128.exp().log(1.0f128.exp()), 1.0);
assert!(1.0f128.log(1.0).is_nan());
assert!(1.0f128.log(-13.9).is_nan());
assert!(nan.log(2.3).is_nan());
assert_eq!(inf.log(10.0), inf);
assert!(neg_inf.log(8.8).is_nan());
assert!((-2.3f128).log(0.1).is_nan());
assert_eq!((-0.0f128).log(2.0), neg_inf);
assert_eq!(0.0f128.log(7.0), neg_inf);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_log2() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_approx_eq!(10.0f128.log2(), 3.32192809488736234787031942948939017, TOL);
assert_approx_eq!(2.3f128.log2(), 1.2016338611696504130002982471978765921, TOL);
assert_approx_eq!(1.0f128.exp().log2(), 1.4426950408889634073599246810018921381, TOL);
assert!(nan.log2().is_nan());
assert_eq!(inf.log2(), inf);
assert!(neg_inf.log2().is_nan());
assert!((-2.3f128).log2().is_nan());
assert_eq!((-0.0f128).log2(), neg_inf);
assert_eq!(0.0f128.log2(), neg_inf);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_log10() {
let nan: f128 = f128::NAN;
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(10.0f128.log10(), 1.0);
assert_approx_eq!(2.3f128.log10(), 0.36172783601759284532595218865859309898, TOL);
assert_approx_eq!(1.0f128.exp().log10(), 0.43429448190325182765112891891660508222, TOL);
assert_eq!(1.0f128.log10(), 0.0);
assert!(nan.log10().is_nan());
assert_eq!(inf.log10(), inf);
assert!(neg_inf.log10().is_nan());
assert!((-2.3f128).log10().is_nan());
assert_eq!((-0.0f128).log10(), neg_inf);
assert_eq!(0.0f128.log10(), neg_inf);
}
#[test]
fn test_to_degrees() {
let pi: f128 = consts::PI;
@ -313,8 +613,8 @@ fn test_to_degrees() {
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(0.0f128.to_degrees(), 0.0);
assert_approx_eq!((-5.8f128).to_degrees(), -332.315521);
assert_eq!(pi.to_degrees(), 180.0);
assert_approx_eq!((-5.8f128).to_degrees(), -332.31552117587745090765431723855668471, TOL);
assert_approx_eq!(pi.to_degrees(), 180.0, TOL);
assert!(nan.to_degrees().is_nan());
assert_eq!(inf.to_degrees(), inf);
assert_eq!(neg_inf.to_degrees(), neg_inf);
@ -328,19 +628,122 @@ fn test_to_radians() {
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
assert_eq!(0.0f128.to_radians(), 0.0);
assert_approx_eq!(154.6f128.to_radians(), 2.698279);
assert_approx_eq!((-332.31f128).to_radians(), -5.799903);
assert_approx_eq!(154.6f128.to_radians(), 2.6982790235832334267135442069489767804, TOL);
assert_approx_eq!((-332.31f128).to_radians(), -5.7999036373023566567593094812182763013, TOL);
// check approx rather than exact because round trip for pi doesn't fall on an exactly
// representable value (unlike `f32` and `f64`).
assert_approx_eq!(180.0f128.to_radians(), pi);
assert_approx_eq!(180.0f128.to_radians(), pi, TOL_PRECISE);
assert!(nan.to_radians().is_nan());
assert_eq!(inf.to_radians(), inf);
assert_eq!(neg_inf.to_radians(), neg_inf);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_asinh() {
// Lower accuracy results are allowed, use increased tolerances
assert_eq!(0.0f128.asinh(), 0.0f128);
assert_eq!((-0.0f128).asinh(), -0.0f128);
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
let nan: f128 = f128::NAN;
assert_eq!(inf.asinh(), inf);
assert_eq!(neg_inf.asinh(), neg_inf);
assert!(nan.asinh().is_nan());
assert!((-0.0f128).asinh().is_sign_negative());
// issue 63271
assert_approx_eq!(2.0f128.asinh(), 1.443635475178810342493276740273105f128, TOL_IMPR);
assert_approx_eq!((-2.0f128).asinh(), -1.443635475178810342493276740273105f128, TOL_IMPR);
// regression test for the catastrophic cancellation fixed in 72486
assert_approx_eq!(
(-67452098.07139316f128).asinh(),
-18.720075426274544393985484294000831757220,
TOL_IMPR
);
// test for low accuracy from issue 104548
assert_approx_eq!(60.0f128, 60.0f128.sinh().asinh(), TOL_IMPR);
// mul needed for approximate comparison to be meaningful
assert_approx_eq!(1.0f128, 1e-15f128.sinh().asinh() * 1e15f128, TOL_IMPR);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_acosh() {
assert_eq!(1.0f128.acosh(), 0.0f128);
assert!(0.999f128.acosh().is_nan());
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
let nan: f128 = f128::NAN;
assert_eq!(inf.acosh(), inf);
assert!(neg_inf.acosh().is_nan());
assert!(nan.acosh().is_nan());
assert_approx_eq!(2.0f128.acosh(), 1.31695789692481670862504634730796844f128, TOL_IMPR);
assert_approx_eq!(3.0f128.acosh(), 1.76274717403908605046521864995958461f128, TOL_IMPR);
// test for low accuracy from issue 104548
assert_approx_eq!(60.0f128, 60.0f128.cosh().acosh(), TOL_IMPR);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_atanh() {
assert_eq!(0.0f128.atanh(), 0.0f128);
assert_eq!((-0.0f128).atanh(), -0.0f128);
let inf: f128 = f128::INFINITY;
let neg_inf: f128 = f128::NEG_INFINITY;
let nan: f128 = f128::NAN;
assert_eq!(1.0f128.atanh(), inf);
assert_eq!((-1.0f128).atanh(), neg_inf);
assert!(2f128.atanh().atanh().is_nan());
assert!((-2f128).atanh().atanh().is_nan());
assert!(inf.atanh().is_nan());
assert!(neg_inf.atanh().is_nan());
assert!(nan.atanh().is_nan());
assert_approx_eq!(0.5f128.atanh(), 0.54930614433405484569762261846126285f128, TOL_IMPR);
assert_approx_eq!((-0.5f128).atanh(), -0.54930614433405484569762261846126285f128, TOL_IMPR);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_gamma() {
// precision can differ among platforms
assert_approx_eq!(1.0f128.gamma(), 1.0f128, TOL_IMPR);
assert_approx_eq!(2.0f128.gamma(), 1.0f128, TOL_IMPR);
assert_approx_eq!(3.0f128.gamma(), 2.0f128, TOL_IMPR);
assert_approx_eq!(4.0f128.gamma(), 6.0f128, TOL_IMPR);
assert_approx_eq!(5.0f128.gamma(), 24.0f128, TOL_IMPR);
assert_approx_eq!(0.5f128.gamma(), consts::PI.sqrt(), TOL_IMPR);
assert_approx_eq!((-0.5f128).gamma(), -2.0 * consts::PI.sqrt(), TOL_IMPR);
assert_eq!(0.0f128.gamma(), f128::INFINITY);
assert_eq!((-0.0f128).gamma(), f128::NEG_INFINITY);
assert!((-1.0f128).gamma().is_nan());
assert!((-2.0f128).gamma().is_nan());
assert!(f128::NAN.gamma().is_nan());
assert!(f128::NEG_INFINITY.gamma().is_nan());
assert_eq!(f128::INFINITY.gamma(), f128::INFINITY);
assert_eq!(1760.9f128.gamma(), f128::INFINITY);
}
#[test]
#[cfg(reliable_f128_math)]
fn test_ln_gamma() {
assert_approx_eq!(1.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
assert_eq!(1.0f128.ln_gamma().1, 1);
assert_approx_eq!(2.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
assert_eq!(2.0f128.ln_gamma().1, 1);
assert_approx_eq!(3.0f128.ln_gamma().0, 2.0f128.ln(), TOL_IMPR);
assert_eq!(3.0f128.ln_gamma().1, 1);
assert_approx_eq!((-0.5f128).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), TOL_IMPR);
assert_eq!((-0.5f128).ln_gamma().1, -1);
}
#[test]
fn test_real_consts() {
// FIXME(f16_f128): add math tests when available
use super::consts;
let pi: f128 = consts::PI;
@ -351,29 +754,34 @@ fn test_real_consts() {
let frac_pi_8: f128 = consts::FRAC_PI_8;
let frac_1_pi: f128 = consts::FRAC_1_PI;
let frac_2_pi: f128 = consts::FRAC_2_PI;
// let frac_2_sqrtpi: f128 = consts::FRAC_2_SQRT_PI;
// let sqrt2: f128 = consts::SQRT_2;
// let frac_1_sqrt2: f128 = consts::FRAC_1_SQRT_2;
// let e: f128 = consts::E;
// let log2_e: f128 = consts::LOG2_E;
// let log10_e: f128 = consts::LOG10_E;
// let ln_2: f128 = consts::LN_2;
// let ln_10: f128 = consts::LN_10;
assert_approx_eq!(frac_pi_2, pi / 2f128);
assert_approx_eq!(frac_pi_3, pi / 3f128);
assert_approx_eq!(frac_pi_4, pi / 4f128);
assert_approx_eq!(frac_pi_6, pi / 6f128);
assert_approx_eq!(frac_pi_8, pi / 8f128);
assert_approx_eq!(frac_1_pi, 1f128 / pi);
assert_approx_eq!(frac_2_pi, 2f128 / pi);
// assert_approx_eq!(frac_2_sqrtpi, 2f128 / pi.sqrt());
// assert_approx_eq!(sqrt2, 2f128.sqrt());
// assert_approx_eq!(frac_1_sqrt2, 1f128 / 2f128.sqrt());
// assert_approx_eq!(log2_e, e.log2());
// assert_approx_eq!(log10_e, e.log10());
// assert_approx_eq!(ln_2, 2f128.ln());
// assert_approx_eq!(ln_10, 10f128.ln());
assert_approx_eq!(frac_pi_2, pi / 2f128, TOL_PRECISE);
assert_approx_eq!(frac_pi_3, pi / 3f128, TOL_PRECISE);
assert_approx_eq!(frac_pi_4, pi / 4f128, TOL_PRECISE);
assert_approx_eq!(frac_pi_6, pi / 6f128, TOL_PRECISE);
assert_approx_eq!(frac_pi_8, pi / 8f128, TOL_PRECISE);
assert_approx_eq!(frac_1_pi, 1f128 / pi, TOL_PRECISE);
assert_approx_eq!(frac_2_pi, 2f128 / pi, TOL_PRECISE);
#[cfg(reliable_f128_math)]
{
let frac_2_sqrtpi: f128 = consts::FRAC_2_SQRT_PI;
let sqrt2: f128 = consts::SQRT_2;
let frac_1_sqrt2: f128 = consts::FRAC_1_SQRT_2;
let e: f128 = consts::E;
let log2_e: f128 = consts::LOG2_E;
let log10_e: f128 = consts::LOG10_E;
let ln_2: f128 = consts::LN_2;
let ln_10: f128 = consts::LN_10;
assert_approx_eq!(frac_2_sqrtpi, 2f128 / pi.sqrt(), TOL_PRECISE);
assert_approx_eq!(sqrt2, 2f128.sqrt(), TOL_PRECISE);
assert_approx_eq!(frac_1_sqrt2, 1f128 / 2f128.sqrt(), TOL_PRECISE);
assert_approx_eq!(log2_e, e.log2(), TOL_PRECISE);
assert_approx_eq!(log10_e, e.log10(), TOL_PRECISE);
assert_approx_eq!(ln_2, 2f128.ln(), TOL_PRECISE);
assert_approx_eq!(ln_10, 10f128.ln(), TOL_PRECISE);
}
}
#[test]
@ -382,10 +790,10 @@ fn test_float_bits_conv() {
assert_eq!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
assert_eq!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
assert_eq!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
assert_approx_eq!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
assert_approx_eq!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
assert_approx_eq!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
assert_approx_eq!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
assert_approx_eq!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0, TOL_PRECISE);
assert_approx_eq!(f128::from_bits(0x40029000000000000000000000000000), 12.5, TOL_PRECISE);
assert_approx_eq!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0, TOL_PRECISE);
assert_approx_eq!(f128::from_bits(0xc002c800000000000000000000000000), -14.25, TOL_PRECISE);
// Check that NaNs roundtrip their bits regardless of signaling-ness
// 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits

1296
library/std/src/f16.rs
View File

File diff suppressed because it is too large Load Diff

470
library/std/src/f16/tests.rs
View File

@ -4,11 +4,21 @@
use crate::f16::consts;
use crate::num::{FpCategory as Fp, *};
// We run out of precision pretty quickly with f16
// const F16_APPROX_L1: f16 = 0.001;
const F16_APPROX_L2: f16 = 0.01;
// const F16_APPROX_L3: f16 = 0.1;
const F16_APPROX_L4: f16 = 0.5;
/// Tolerance for results on the order of 10.0e-2;
#[cfg(reliable_f16_math)]
const TOL_N2: f16 = 0.0001;
/// Tolerance for results on the order of 10.0e+0
#[cfg(reliable_f16_math)]
const TOL_0: f16 = 0.01;
/// Tolerance for results on the order of 10.0e+2
#[cfg(reliable_f16_math)]
const TOL_P2: f16 = 0.5;
/// Tolerance for results on the order of 10.0e+4
#[cfg(reliable_f16_math)]
const TOL_P4: f16 = 10.0;
/// Smallest number
const TINY_BITS: u16 = 0x1;
@ -47,7 +57,33 @@ fn test_num_f16() {
test_num(10f16, 2f16);
}
// FIXME(f16_f128): add min and max tests when available
#[test]
#[cfg(reliable_f16_math)]
fn test_min_nan() {
assert_eq!(f16::NAN.min(2.0), 2.0);
assert_eq!(2.0f16.min(f16::NAN), 2.0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_max_nan() {
assert_eq!(f16::NAN.max(2.0), 2.0);
assert_eq!(2.0f16.max(f16::NAN), 2.0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_minimum() {
assert!(f16::NAN.minimum(2.0).is_nan());
assert!(2.0f16.minimum(f16::NAN).is_nan());
}
#[test]
#[cfg(reliable_f16_math)]
fn test_maximum() {
assert!(f16::NAN.maximum(2.0).is_nan());
assert!(2.0f16.maximum(f16::NAN).is_nan());
}
#[test]
fn test_nan() {
@ -197,9 +233,100 @@ fn test_classify() {
assert_eq!(1e-5f16.classify(), Fp::Subnormal);
}
// FIXME(f16_f128): add missing math functions when available
#[test]
#[cfg(reliable_f16_math)]
fn test_floor() {
assert_approx_eq!(1.0f16.floor(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.floor(), 1.0f16, TOL_0);
assert_approx_eq!(1.5f16.floor(), 1.0f16, TOL_0);
assert_approx_eq!(1.7f16.floor(), 1.0f16, TOL_0);
assert_approx_eq!(0.0f16.floor(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).floor(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).floor(), -1.0f16, TOL_0);
assert_approx_eq!((-1.3f16).floor(), -2.0f16, TOL_0);
assert_approx_eq!((-1.5f16).floor(), -2.0f16, TOL_0);
assert_approx_eq!((-1.7f16).floor(), -2.0f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_ceil() {
assert_approx_eq!(1.0f16.ceil(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.ceil(), 2.0f16, TOL_0);
assert_approx_eq!(1.5f16.ceil(), 2.0f16, TOL_0);
assert_approx_eq!(1.7f16.ceil(), 2.0f16, TOL_0);
assert_approx_eq!(0.0f16.ceil(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).ceil(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).ceil(), -1.0f16, TOL_0);
assert_approx_eq!((-1.3f16).ceil(), -1.0f16, TOL_0);
assert_approx_eq!((-1.5f16).ceil(), -1.0f16, TOL_0);
assert_approx_eq!((-1.7f16).ceil(), -1.0f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_round() {
assert_approx_eq!(2.5f16.round(), 3.0f16, TOL_0);
assert_approx_eq!(1.0f16.round(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.round(), 1.0f16, TOL_0);
assert_approx_eq!(1.5f16.round(), 2.0f16, TOL_0);
assert_approx_eq!(1.7f16.round(), 2.0f16, TOL_0);
assert_approx_eq!(0.0f16.round(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).round(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).round(), -1.0f16, TOL_0);
assert_approx_eq!((-1.3f16).round(), -1.0f16, TOL_0);
assert_approx_eq!((-1.5f16).round(), -2.0f16, TOL_0);
assert_approx_eq!((-1.7f16).round(), -2.0f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_round_ties_even() {
assert_approx_eq!(2.5f16.round_ties_even(), 2.0f16, TOL_0);
assert_approx_eq!(1.0f16.round_ties_even(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.round_ties_even(), 1.0f16, TOL_0);
assert_approx_eq!(1.5f16.round_ties_even(), 2.0f16, TOL_0);
assert_approx_eq!(1.7f16.round_ties_even(), 2.0f16, TOL_0);
assert_approx_eq!(0.0f16.round_ties_even(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).round_ties_even(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).round_ties_even(), -1.0f16, TOL_0);
assert_approx_eq!((-1.3f16).round_ties_even(), -1.0f16, TOL_0);
assert_approx_eq!((-1.5f16).round_ties_even(), -2.0f16, TOL_0);
assert_approx_eq!((-1.7f16).round_ties_even(), -2.0f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_trunc() {
assert_approx_eq!(1.0f16.trunc(), 1.0f16, TOL_0);
assert_approx_eq!(1.3f16.trunc(), 1.0f16, TOL_0);
assert_approx_eq!(1.5f16.trunc(), 1.0f16, TOL_0);
assert_approx_eq!(1.7f16.trunc(), 1.0f16, TOL_0);
assert_approx_eq!(0.0f16.trunc(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).trunc(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).trunc(), -1.0f16, TOL_0);
assert_approx_eq!((-1.3f16).trunc(), -1.0f16, TOL_0);
assert_approx_eq!((-1.5f16).trunc(), -1.0f16, TOL_0);
assert_approx_eq!((-1.7f16).trunc(), -1.0f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_fract() {
assert_approx_eq!(1.0f16.fract(), 0.0f16, TOL_0);
assert_approx_eq!(1.3f16.fract(), 0.3f16, TOL_0);
assert_approx_eq!(1.5f16.fract(), 0.5f16, TOL_0);
assert_approx_eq!(1.7f16.fract(), 0.7f16, TOL_0);
assert_approx_eq!(0.0f16.fract(), 0.0f16, TOL_0);
assert_approx_eq!((-0.0f16).fract(), -0.0f16, TOL_0);
assert_approx_eq!((-1.0f16).fract(), -0.0f16, TOL_0);
assert_approx_eq!((-1.3f16).fract(), -0.3f16, TOL_0);
assert_approx_eq!((-1.5f16).fract(), -0.5f16, TOL_0);
assert_approx_eq!((-1.7f16).fract(), -0.7f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_abs() {
assert_eq!(f16::INFINITY.abs(), f16::INFINITY);
assert_eq!(1f16.abs(), 1f16);
@ -299,6 +426,24 @@ fn test_next_down() {
}
#[test]
#[cfg(reliable_f16_math)]
fn test_mul_add() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_approx_eq!(12.3f16.mul_add(4.5, 6.7), 62.05, TOL_P2);
assert_approx_eq!((-12.3f16).mul_add(-4.5, -6.7), 48.65, TOL_P2);
assert_approx_eq!(0.0f16.mul_add(8.9, 1.2), 1.2, TOL_0);
assert_approx_eq!(3.4f16.mul_add(-0.0, 5.6), 5.6, TOL_0);
assert!(nan.mul_add(7.8, 9.0).is_nan());
assert_eq!(inf.mul_add(7.8, 9.0), inf);
assert_eq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
assert_eq!(8.9f16.mul_add(inf, 3.2), inf);
assert_eq!((-3.2f16).mul_add(2.4, neg_inf), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_recip() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
@ -307,11 +452,157 @@ fn test_recip() {
assert_eq!(2.0f16.recip(), 0.5);
assert_eq!((-0.4f16).recip(), -2.5);
assert_eq!(0.0f16.recip(), inf);
assert_approx_eq!(f16::MAX.recip(), 1.526624e-5f16, 1e-4);
assert!(nan.recip().is_nan());
assert_eq!(inf.recip(), 0.0);
assert_eq!(neg_inf.recip(), 0.0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_powi() {
// FIXME(llvm19): LLVM misoptimizes `powi.f16`
// <https://github.com/llvm/llvm-project/issues/98665>
// let nan: f16 = f16::NAN;
// let inf: f16 = f16::INFINITY;
// let neg_inf: f16 = f16::NEG_INFINITY;
// assert_eq!(1.0f16.powi(1), 1.0);
// assert_approx_eq!((-3.1f16).powi(2), 9.61, TOL_0);
// assert_approx_eq!(5.9f16.powi(-2), 0.028727, TOL_N2);
// assert_eq!(8.3f16.powi(0), 1.0);
// assert!(nan.powi(2).is_nan());
// assert_eq!(inf.powi(3), inf);
// assert_eq!(neg_inf.powi(2), inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_powf() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_eq!(1.0f16.powf(1.0), 1.0);
assert_approx_eq!(3.4f16.powf(4.5), 246.408183, TOL_P2);
assert_approx_eq!(2.7f16.powf(-3.2), 0.041652, TOL_N2);
assert_approx_eq!((-3.1f16).powf(2.0), 9.61, TOL_P2);
assert_approx_eq!(5.9f16.powf(-2.0), 0.028727, TOL_N2);
assert_eq!(8.3f16.powf(0.0), 1.0);
assert!(nan.powf(2.0).is_nan());
assert_eq!(inf.powf(2.0), inf);
assert_eq!(neg_inf.powf(3.0), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_sqrt_domain() {
assert!(f16::NAN.sqrt().is_nan());
assert!(f16::NEG_INFINITY.sqrt().is_nan());
assert!((-1.0f16).sqrt().is_nan());
assert_eq!((-0.0f16).sqrt(), -0.0);
assert_eq!(0.0f16.sqrt(), 0.0);
assert_eq!(1.0f16.sqrt(), 1.0);
assert_eq!(f16::INFINITY.sqrt(), f16::INFINITY);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_exp() {
assert_eq!(1.0, 0.0f16.exp());
assert_approx_eq!(2.718282, 1.0f16.exp(), TOL_0);
assert_approx_eq!(148.413159, 5.0f16.exp(), TOL_0);
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
let nan: f16 = f16::NAN;
assert_eq!(inf, inf.exp());
assert_eq!(0.0, neg_inf.exp());
assert!(nan.exp().is_nan());
}
#[test]
#[cfg(reliable_f16_math)]
fn test_exp2() {
assert_eq!(32.0, 5.0f16.exp2());
assert_eq!(1.0, 0.0f16.exp2());
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
let nan: f16 = f16::NAN;
assert_eq!(inf, inf.exp2());
assert_eq!(0.0, neg_inf.exp2());
assert!(nan.exp2().is_nan());
}
#[test]
#[cfg(reliable_f16_math)]
fn test_ln() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_approx_eq!(1.0f16.exp().ln(), 1.0, TOL_0);
assert!(nan.ln().is_nan());
assert_eq!(inf.ln(), inf);
assert!(neg_inf.ln().is_nan());
assert!((-2.3f16).ln().is_nan());
assert_eq!((-0.0f16).ln(), neg_inf);
assert_eq!(0.0f16.ln(), neg_inf);
assert_approx_eq!(4.0f16.ln(), 1.386294, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_log() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_eq!(10.0f16.log(10.0), 1.0);
assert_approx_eq!(2.3f16.log(3.5), 0.664858, TOL_0);
assert_eq!(1.0f16.exp().log(1.0f16.exp()), 1.0);
assert!(1.0f16.log(1.0).is_nan());
assert!(1.0f16.log(-13.9).is_nan());
assert!(nan.log(2.3).is_nan());
assert_eq!(inf.log(10.0), inf);
assert!(neg_inf.log(8.8).is_nan());
assert!((-2.3f16).log(0.1).is_nan());
assert_eq!((-0.0f16).log(2.0), neg_inf);
assert_eq!(0.0f16.log(7.0), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_log2() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_approx_eq!(10.0f16.log2(), 3.321928, TOL_0);
assert_approx_eq!(2.3f16.log2(), 1.201634, TOL_0);
assert_approx_eq!(1.0f16.exp().log2(), 1.442695, TOL_0);
assert!(nan.log2().is_nan());
assert_eq!(inf.log2(), inf);
assert!(neg_inf.log2().is_nan());
assert!((-2.3f16).log2().is_nan());
assert_eq!((-0.0f16).log2(), neg_inf);
assert_eq!(0.0f16.log2(), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_log10() {
let nan: f16 = f16::NAN;
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_eq!(10.0f16.log10(), 1.0);
assert_approx_eq!(2.3f16.log10(), 0.361728, TOL_0);
assert_approx_eq!(1.0f16.exp().log10(), 0.434294, TOL_0);
assert_eq!(1.0f16.log10(), 0.0);
assert!(nan.log10().is_nan());
assert_eq!(inf.log10(), inf);
assert!(neg_inf.log10().is_nan());
assert!((-2.3f16).log10().is_nan());
assert_eq!((-0.0f16).log10(), neg_inf);
assert_eq!(0.0f16.log10(), neg_inf);
}
#[test]
fn test_to_degrees() {
let pi: f16 = consts::PI;
@ -319,8 +610,8 @@ fn test_to_degrees() {
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_eq!(0.0f16.to_degrees(), 0.0);
assert_approx_eq!((-5.8f16).to_degrees(), -332.315521);
assert_approx_eq!(pi.to_degrees(), 180.0, F16_APPROX_L4);
assert_approx_eq!((-5.8f16).to_degrees(), -332.315521, TOL_P2);
assert_approx_eq!(pi.to_degrees(), 180.0, TOL_P2);
assert!(nan.to_degrees().is_nan());
assert_eq!(inf.to_degrees(), inf);
assert_eq!(neg_inf.to_degrees(), neg_inf);
@ -334,14 +625,112 @@ fn test_to_radians() {
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
assert_eq!(0.0f16.to_radians(), 0.0);
assert_approx_eq!(154.6f16.to_radians(), 2.698279);
assert_approx_eq!((-332.31f16).to_radians(), -5.799903);
assert_approx_eq!(180.0f16.to_radians(), pi, F16_APPROX_L2);
assert_approx_eq!(154.6f16.to_radians(), 2.698279, TOL_0);
assert_approx_eq!((-332.31f16).to_radians(), -5.799903, TOL_0);
assert_approx_eq!(180.0f16.to_radians(), pi, TOL_0);
assert!(nan.to_radians().is_nan());
assert_eq!(inf.to_radians(), inf);
assert_eq!(neg_inf.to_radians(), neg_inf);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_asinh() {
assert_eq!(0.0f16.asinh(), 0.0f16);
assert_eq!((-0.0f16).asinh(), -0.0f16);
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
let nan: f16 = f16::NAN;
assert_eq!(inf.asinh(), inf);
assert_eq!(neg_inf.asinh(), neg_inf);
assert!(nan.asinh().is_nan());
assert!((-0.0f16).asinh().is_sign_negative());
// issue 63271
assert_approx_eq!(2.0f16.asinh(), 1.443635475178810342493276740273105f16, TOL_0);
assert_approx_eq!((-2.0f16).asinh(), -1.443635475178810342493276740273105f16, TOL_0);
// regression test for the catastrophic cancellation fixed in 72486
assert_approx_eq!((-200.0f16).asinh(), -5.991470797049389, TOL_0);
// test for low accuracy from issue 104548
assert_approx_eq!(10.0f16, 10.0f16.sinh().asinh(), TOL_0);
// mul needed for approximate comparison to be meaningful
assert_approx_eq!(1.0f16, 1e-3f16.sinh().asinh() * 1e3f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_acosh() {
assert_eq!(1.0f16.acosh(), 0.0f16);
assert!(0.999f16.acosh().is_nan());
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
let nan: f16 = f16::NAN;
assert_eq!(inf.acosh(), inf);
assert!(neg_inf.acosh().is_nan());
assert!(nan.acosh().is_nan());
assert_approx_eq!(2.0f16.acosh(), 1.31695789692481670862504634730796844f16, TOL_0);
assert_approx_eq!(3.0f16.acosh(), 1.76274717403908605046521864995958461f16, TOL_0);
// test for low accuracy from issue 104548
assert_approx_eq!(10.0f16, 10.0f16.cosh().acosh(), TOL_P2);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_atanh() {
assert_eq!(0.0f16.atanh(), 0.0f16);
assert_eq!((-0.0f16).atanh(), -0.0f16);
let inf: f16 = f16::INFINITY;
let neg_inf: f16 = f16::NEG_INFINITY;
let nan: f16 = f16::NAN;
assert_eq!(1.0f16.atanh(), inf);
assert_eq!((-1.0f16).atanh(), neg_inf);
assert!(2f16.atanh().atanh().is_nan());
assert!((-2f16).atanh().atanh().is_nan());
assert!(inf.atanh().is_nan());
assert!(neg_inf.atanh().is_nan());
assert!(nan.atanh().is_nan());
assert_approx_eq!(0.5f16.atanh(), 0.54930614433405484569762261846126285f16, TOL_0);
assert_approx_eq!((-0.5f16).atanh(), -0.54930614433405484569762261846126285f16, TOL_0);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_gamma() {
// precision can differ among platforms
assert_approx_eq!(1.0f16.gamma(), 1.0f16, TOL_0);
assert_approx_eq!(2.0f16.gamma(), 1.0f16, TOL_0);
assert_approx_eq!(3.0f16.gamma(), 2.0f16, TOL_0);
assert_approx_eq!(4.0f16.gamma(), 6.0f16, TOL_0);
assert_approx_eq!(5.0f16.gamma(), 24.0f16, TOL_0);
assert_approx_eq!(0.5f16.gamma(), consts::PI.sqrt(), TOL_0);
assert_approx_eq!((-0.5f16).gamma(), -2.0 * consts::PI.sqrt(), TOL_0);
assert_eq!(0.0f16.gamma(), f16::INFINITY);
assert_eq!((-0.0f16).gamma(), f16::NEG_INFINITY);
assert!((-1.0f16).gamma().is_nan());
assert!((-2.0f16).gamma().is_nan());
assert!(f16::NAN.gamma().is_nan());
assert!(f16::NEG_INFINITY.gamma().is_nan());
assert_eq!(f16::INFINITY.gamma(), f16::INFINITY);
assert_eq!(171.71f16.gamma(), f16::INFINITY);
}
#[test]
#[cfg(reliable_f16_math)]
fn test_ln_gamma() {
assert_approx_eq!(1.0f16.ln_gamma().0, 0.0f16, TOL_0);
assert_eq!(1.0f16.ln_gamma().1, 1);
assert_approx_eq!(2.0f16.ln_gamma().0, 0.0f16, TOL_0);
assert_eq!(2.0f16.ln_gamma().1, 1);
assert_approx_eq!(3.0f16.ln_gamma().0, 2.0f16.ln(), TOL_0);
assert_eq!(3.0f16.ln_gamma().1, 1);
assert_approx_eq!((-0.5f16).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), TOL_0);
assert_eq!((-0.5f16).ln_gamma().1, -1);
}
#[test]
fn test_real_consts() {
// FIXME(f16_f128): add math tests when available
@ -355,29 +744,34 @@ fn test_real_consts() {
let frac_pi_8: f16 = consts::FRAC_PI_8;
let frac_1_pi: f16 = consts::FRAC_1_PI;
let frac_2_pi: f16 = consts::FRAC_2_PI;
// let frac_2_sqrtpi: f16 = consts::FRAC_2_SQRT_PI;
// let sqrt2: f16 = consts::SQRT_2;
// let frac_1_sqrt2: f16 = consts::FRAC_1_SQRT_2;
// let e: f16 = consts::E;
// let log2_e: f16 = consts::LOG2_E;
// let log10_e: f16 = consts::LOG10_E;
// let ln_2: f16 = consts::LN_2;
// let ln_10: f16 = consts::LN_10;
assert_approx_eq!(frac_pi_2, pi / 2f16);
assert_approx_eq!(frac_pi_3, pi / 3f16);
assert_approx_eq!(frac_pi_4, pi / 4f16);
assert_approx_eq!(frac_pi_6, pi / 6f16);
assert_approx_eq!(frac_pi_8, pi / 8f16);
assert_approx_eq!(frac_1_pi, 1f16 / pi);
assert_approx_eq!(frac_2_pi, 2f16 / pi);
// assert_approx_eq!(frac_2_sqrtpi, 2f16 / pi.sqrt());
// assert_approx_eq!(sqrt2, 2f16.sqrt());
// assert_approx_eq!(frac_1_sqrt2, 1f16 / 2f16.sqrt());
// assert_approx_eq!(log2_e, e.log2());
// assert_approx_eq!(log10_e, e.log10());
// assert_approx_eq!(ln_2, 2f16.ln());
// assert_approx_eq!(ln_10, 10f16.ln());
assert_approx_eq!(frac_pi_2, pi / 2f16, TOL_0);
assert_approx_eq!(frac_pi_3, pi / 3f16, TOL_0);
assert_approx_eq!(frac_pi_4, pi / 4f16, TOL_0);
assert_approx_eq!(frac_pi_6, pi / 6f16, TOL_0);
assert_approx_eq!(frac_pi_8, pi / 8f16, TOL_0);
assert_approx_eq!(frac_1_pi, 1f16 / pi, TOL_0);
assert_approx_eq!(frac_2_pi, 2f16 / pi, TOL_0);
#[cfg(reliable_f16_math)]
{
let frac_2_sqrtpi: f16 = consts::FRAC_2_SQRT_PI;
let sqrt2: f16 = consts::SQRT_2;
let frac_1_sqrt2: f16 = consts::FRAC_1_SQRT_2;
let e: f16 = consts::E;
let log2_e: f16 = consts::LOG2_E;
let log10_e: f16 = consts::LOG10_E;
let ln_2: f16 = consts::LN_2;
let ln_10: f16 = consts::LN_10;
assert_approx_eq!(frac_2_sqrtpi, 2f16 / pi.sqrt(), TOL_0);
assert_approx_eq!(sqrt2, 2f16.sqrt(), TOL_0);
assert_approx_eq!(frac_1_sqrt2, 1f16 / 2f16.sqrt(), TOL_0);
assert_approx_eq!(log2_e, e.log2(), TOL_0);
assert_approx_eq!(log10_e, e.log10(), TOL_0);
assert_approx_eq!(ln_2, 2f16.ln(), TOL_0);
assert_approx_eq!(ln_10, 10f16.ln(), TOL_0);
}
}
#[test]
@ -386,10 +780,10 @@ fn test_float_bits_conv() {
assert_eq!((12.5f16).to_bits(), 0x4a40);
assert_eq!((1337f16).to_bits(), 0x6539);
assert_eq!((-14.25f16).to_bits(), 0xcb20);
assert_approx_eq!(f16::from_bits(0x3c00), 1.0);
assert_approx_eq!(f16::from_bits(0x4a40), 12.5);
assert_approx_eq!(f16::from_bits(0x6539), 1337.0);
assert_approx_eq!(f16::from_bits(0xcb20), -14.25);
assert_approx_eq!(f16::from_bits(0x3c00), 1.0, TOL_0);
assert_approx_eq!(f16::from_bits(0x4a40), 12.5, TOL_0);
assert_approx_eq!(f16::from_bits(0x6539), 1337.0, TOL_P4);
assert_approx_eq!(f16::from_bits(0xcb20), -14.25, TOL_0);
// Check that NaNs roundtrip their bits regardless of signaling-ness
let masked_nan1 = f16::NAN.to_bits() ^ NAN_MASK1;

2
library/std/src/macros.rs
View File

@ -382,7 +382,7 @@ macro_rules! assert_approx_eq {
let diff = (*a - *b).abs();
assert!(
diff < $lim,
"{a:?} is not approximately equal to {b:?} (threshold {lim:?}, actual {diff:?})",
"{a:?} is not approximately equal to {b:?} (threshold {lim:?}, difference {diff:?})",
lim = $lim
);
}};

15
library/std/src/sys/cmath.rs
View File

@ -28,6 +28,21 @@ extern "C" {
pub fn lgamma_r(n: f64, s: &mut i32) -> f64;
pub fn lgammaf_r(n: f32, s: &mut i32) -> f32;
pub fn acosf128(n: f128) -> f128;
pub fn asinf128(n: f128) -> f128;
pub fn atanf128(n: f128) -> f128;
pub fn atan2f128(a: f128, b: f128) -> f128;
pub fn cbrtf128(n: f128) -> f128;
pub fn coshf128(n: f128) -> f128;
pub fn expm1f128(n: f128) -> f128;
pub fn hypotf128(x: f128, y: f128) -> f128;
pub fn log1pf128(n: f128) -> f128;
pub fn sinhf128(n: f128) -> f128;
pub fn tanf128(n: f128) -> f128;
pub fn tanhf128(n: f128) -> f128;
pub fn tgammaf128(n: f128) -> f128;
pub fn lgammaf128_r(n: f128, s: &mut i32) -> f128;
cfg_if::cfg_if! {
if #[cfg(not(all(target_os = "windows", target_env = "msvc", target_arch = "x86")))] {
pub fn acosf(n: f32) -> f32;