mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

variable-precision float operations behave non-deterministically

Browse Source
This commit is contained in:
Ralf Jung 2024-05-02 09:14:39 +02:00
parent fcc06c894b
commit ff2ff97904
2 changed files with 174 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
library/std/src/f32.rs
View File

@ -371,9 +371,10 @@ pub fn rem_euclid(self, rhs: f32) -> f32 {
/// It might have a different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -393,9 +394,10 @@ pub fn powi(self, n: i32) -> f32 {
/// Raises a number to a floating point power.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -444,9 +446,10 @@ pub fn sqrt(self) -> f32 {
/// Returns `e^(self)`, (the exponential function).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -470,9 +473,10 @@ pub fn exp(self) -> f32 {
/// Returns `2^(self)`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -494,9 +498,10 @@ pub fn exp2(self) -> f32 {
/// Returns the natural logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -524,9 +529,10 @@ pub fn ln(self) -> f32 {
/// `self.log2()` can produce more accurate results for base 2, and
/// `self.log10()` can produce more accurate results for base 10.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -548,9 +554,10 @@ pub fn log(self, base: f32) -> f32 {
/// Returns the base 2 logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -572,9 +579,10 @@ pub fn log2(self) -> f32 {
/// Returns the base 10 logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -599,9 +607,10 @@ pub fn log10(self) -> f32 {
/// * If `self <= other`: `0.0`
/// * Else: `self - other`
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
@ -637,9 +646,10 @@ pub fn abs_sub(self, other: f32) -> f32 {
/// Returns the cube root of a number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `cbrtf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -666,9 +676,10 @@ pub fn cbrt(self) -> f32 {
/// right-angle triangle with other sides having length `x.abs()` and
/// `y.abs()`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `hypotf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -693,9 +704,10 @@ pub fn hypot(self, other: f32) -> f32 {
/// Computes the sine of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -716,9 +728,10 @@ pub fn sin(self) -> f32 {
/// Computes the cosine of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -739,9 +752,10 @@ pub fn cos(self) -> f32 {
/// Computes the tangent of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tanf` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -765,9 +779,10 @@ pub fn tan(self) -> f32 {
/// the range [-pi/2, pi/2] or NaN if the number is outside the range
/// [-1, 1].
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `asinf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -794,9 +809,10 @@ pub fn asin(self) -> f32 {
/// the range [0, pi] or NaN if the number is outside the range
/// [-1, 1].
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `acosf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -822,9 +838,10 @@ pub fn acos(self) -> f32 {
/// Computes the arctangent of a number. Return value is in radians in the
/// range [-pi/2, pi/2];
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `atanf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -854,9 +871,10 @@ pub fn atan(self) -> f32 {
/// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `atan2f` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -890,9 +908,10 @@ pub fn atan2(self, other: f32) -> f32 {
/// Simultaneously computes the sine and cosine of the number, `x`. Returns
/// `(sin(x), cos(x))`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `(f32::sin(x),
/// f32::cos(x))`. Note that this might change in the future.
///
@ -919,9 +938,10 @@ pub fn sin_cos(self) -> (f32, f32) {
/// Returns `e^(self) - 1` in a way that is accurate even if the
/// number is close to zero.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `expm1f` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -947,9 +967,10 @@ pub fn exp_m1(self) -> f32 {
/// Returns `ln(1+n)` (natural logarithm) more accurately than if
/// the operations were performed separately.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `log1pf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -975,9 +996,10 @@ pub fn ln_1p(self) -> f32 {
/// Hyperbolic sine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `sinhf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1004,9 +1026,10 @@ pub fn sinh(self) -> f32 {
/// Hyperbolic cosine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `coshf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1033,9 +1056,10 @@ pub fn cosh(self) -> f32 {
/// Hyperbolic tangent function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tanhf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1062,9 +1086,10 @@ pub fn tanh(self) -> f32 {
/// Inverse hyperbolic sine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1089,9 +1114,10 @@ pub fn asinh(self) -> f32 {
/// Inverse hyperbolic cosine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1118,9 +1144,10 @@ pub fn acosh(self) -> f32 {
/// Inverse hyperbolic tangent function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1143,9 +1170,10 @@ pub fn atanh(self) -> f32 {
/// Gamma function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tgammaf` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1171,9 +1199,10 @@ pub fn gamma(self) -> f32 {
///
/// The integer part of the tuple indicates the sign of the gamma function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `lgamma_r` from libc on Unix
/// and Windows. Note that this might change in the future.
///

145
library/std/src/f64.rs
View File

@ -371,9 +371,10 @@ pub fn rem_euclid(self, rhs: f64) -> f64 {
/// It might have a different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -393,9 +394,10 @@ pub fn powi(self, n: i32) -> f64 {
/// Raises a number to a floating point power.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -444,9 +446,10 @@ pub fn sqrt(self) -> f64 {
/// Returns `e^(self)`, (the exponential function).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -470,9 +473,10 @@ pub fn exp(self) -> f64 {
/// Returns `2^(self)`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -494,9 +498,10 @@ pub fn exp2(self) -> f64 {
/// Returns the natural logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -524,9 +529,10 @@ pub fn ln(self) -> f64 {
/// `self.log2()` can produce more accurate results for base 2, and
/// `self.log10()` can produce more accurate results for base 10.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -548,9 +554,10 @@ pub fn log(self, base: f64) -> f64 {
/// Returns the base 2 logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -572,9 +579,10 @@ pub fn log2(self) -> f64 {
/// Returns the base 10 logarithm of the number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -599,9 +607,10 @@ pub fn log10(self) -> f64 {
/// * If `self <= other`: `0.0`
/// * Else: `self - other`
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `fdim` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -637,9 +646,10 @@ pub fn abs_sub(self, other: f64) -> f64 {
/// Returns the cube root of a number.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `cbrt` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -666,9 +676,10 @@ pub fn cbrt(self) -> f64 {
/// right-angle triangle with other sides having length `x.abs()` and
/// `y.abs()`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `hypot` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -693,9 +704,10 @@ pub fn hypot(self, other: f64) -> f64 {
/// Computes the sine of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -716,9 +728,10 @@ pub fn sin(self) -> f64 {
/// Computes the cosine of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -739,9 +752,10 @@ pub fn cos(self) -> f64 {
/// Computes the tangent of a number (in radians).
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tan` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -765,9 +779,10 @@ pub fn tan(self) -> f64 {
/// the range [-pi/2, pi/2] or NaN if the number is outside the range
/// [-1, 1].
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `asin` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -794,9 +809,10 @@ pub fn asin(self) -> f64 {
/// the range [0, pi] or NaN if the number is outside the range
/// [-1, 1].
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `acos` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -822,9 +838,10 @@ pub fn acos(self) -> f64 {
/// Computes the arctangent of a number. Return value is in radians in the
/// range [-pi/2, pi/2];
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `atan` from libc on Unix and
/// Windows. Note that this might change in the future.
///
@ -854,9 +871,10 @@ pub fn atan(self) -> f64 {
/// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `atan2` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -890,9 +908,10 @@ pub fn atan2(self, other: f64) -> f64 {
/// Simultaneously computes the sine and cosine of the number, `x`. Returns
/// `(sin(x), cos(x))`.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `(f64::sin(x),
/// f64::cos(x))`. Note that this might change in the future.
///
@ -919,9 +938,10 @@ pub fn sin_cos(self) -> (f64, f64) {
/// Returns `e^(self) - 1` in a way that is accurate even if the
/// number is close to zero.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `expm1` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -947,9 +967,10 @@ pub fn exp_m1(self) -> f64 {
/// Returns `ln(1+n)` (natural logarithm) more accurately than if
/// the operations were performed separately.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `log1p` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -975,9 +996,10 @@ pub fn ln_1p(self) -> f64 {
/// Hyperbolic sine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `sinh` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1004,9 +1026,10 @@ pub fn sinh(self) -> f64 {
/// Hyperbolic cosine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `cosh` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1033,9 +1056,10 @@ pub fn cosh(self) -> f64 {
/// Hyperbolic tangent function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tanh` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1062,9 +1086,10 @@ pub fn tanh(self) -> f64 {
/// Inverse hyperbolic sine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1089,9 +1114,10 @@ pub fn asinh(self) -> f64 {
/// Inverse hyperbolic cosine function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1118,9 +1144,10 @@ pub fn acosh(self) -> f64 {
/// Inverse hyperbolic tangent function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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.
///
/// # Examples
///
@ -1143,9 +1170,10 @@ pub fn atanh(self) -> f64 {
/// Gamma function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `tgamma` from libc on Unix
/// and Windows. Note that this might change in the future.
///
@ -1171,9 +1199,10 @@ pub fn gamma(self) -> f64 {
///
/// The integer part of the tuple indicates the sign of the gamma function.
///
/// # Platform-specific precision
/// # Unspecified precision
///
/// The precision of this function varies by platform and Rust version.
/// 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 `lgamma_r` from libc on Unix
/// and Windows. Note that this might change in the future.
///