user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improve floating point documentation:

Browse source 
- Refine the "NaN as a special value" top level explanation of f32
- Refine `const NAN` docstring.
- Refine `fn is_sign_positive` and `fn is_sign_negative` docstrings.
- Refine `fn min` and `fn max` docstrings.
- Refine `fn trunc` docstrings.
- Refine `fn powi` docstrings.
- Refine `fn copysign` docstrings.
- Reword `NaN` and `NAN` as plain "NaN", unless they refer to the specific `const NAN`.
- Reword "a number" to `self` in function docstrings to clarify.
- Remove "Returns NAN if the number is NAN" as this is told to be the default behavior in the top explanation.
- Remove "propagating NaNs", as full propagation (preservation of payloads) is not guaranteed.
This commit is contained in:
Pyry Kontio 2022-03-31 00:58:43 +09:00
parent 3e7514670d
commit 3561187221
6 changed files with 126 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

51
library/core/src/num/f32.rs
View file

@ -418,6 +418,15 @@ impl f32 {
pub const MAX_10_EXP: i32 = 38;
/// Not a Number (NaN).
///
/// Note that IEEE-745 doesn't define just a single NaN value;
/// a plethora of bit patterns are considered to be NaN.
/// Furthermore, the standard makes a difference
/// between a "signaling" and a "quiet" NaN,
/// and allows inspecting its "payload" (the unspecified bits in the bit pattern).
/// This constant isn't guaranteed to equal to any specific NaN bitpattern,
/// and the stability of its representation over Rust versions
/// and target platforms isn't guaranteed.
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NAN: f32 = 0.0_f32 / 0.0_f32;
/// Infinity (∞).
@ -427,7 +436,7 @@ impl f32 {
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NEG_INFINITY: f32 = -1.0_f32 / 0.0_f32;
/// Returns `true` if this value is `NaN`.
/// Returns `true` if this value is NaN.
///
/// ```
/// let nan = f32::NAN;
@ -476,7 +485,7 @@ impl f32 {
self.abs_private() == Self::INFINITY
}
/// Returns `true` if this number is neither infinite nor `NaN`.
/// Returns `true` if this number is neither infinite nor NaN.
///
/// ```
/// let f = 7.0f32;
@ -527,7 +536,7 @@ impl f32 {
}
/// Returns `true` if the number is neither zero, infinite,
/// [subnormal], or `NaN`.
/// [subnormal], or NaN.
///
/// ```
/// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
@ -582,8 +591,12 @@ impl f32 {
}
}
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
/// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
/// positive sign bit and positive infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f32;
@ -600,8 +613,12 @@ impl f32 {
!self.is_sign_negative()
}
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
/// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
/// negative sign bit and negative infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0f32;
@ -674,8 +691,10 @@ impl f32 {
/// Returns the maximum of the two numbers.
///
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmax.
/// 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.
///
/// ```
/// let x = 1.0f32;
@ -683,8 +702,6 @@ impl f32 {
///
/// assert_eq!(x.max(y), y);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -694,8 +711,10 @@ impl f32 {
/// Returns the minimum of the two numbers.
///
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmin.
/// 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.
///
/// ```
/// let x = 1.0f32;
@ -703,8 +722,6 @@ impl f32 {
///
/// assert_eq!(x.min(y), x);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -712,7 +729,7 @@ impl f32 {
intrinsics::minnumf32(self, other)
}
/// Returns the maximum of the two numbers, propagating NaNs.
/// Returns the maximum of the two numbers.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f32::max`] which only returns NaN when *both* arguments are NaN.
@ -744,7 +761,7 @@ impl f32 {
}
}
/// Returns the minimum of the two numbers, propagating NaNs.
/// Returns the minimum of the two numbers.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f32::min`] which only returns NaN when *both* arguments are NaN.

51
library/core/src/num/f64.rs
View file

@ -417,6 +417,15 @@ impl f64 {
pub const MAX_10_EXP: i32 = 308;
/// Not a Number (NaN).
///
/// Note that IEEE-745 doesn't define just a single NaN value;
/// a plethora of bit patterns are considered to be NaN.
/// Furthermore, the standard makes a difference
/// between a "signaling" and a "quiet" NaN,
/// and allows inspecting its "payload" (the unspecified bits in the bit pattern).
/// This constant isn't guaranteed to equal to any specific NaN bitpattern,
/// and the stability of its representation over Rust versions
/// and target platforms isn't guaranteed.
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NAN: f64 = 0.0_f64 / 0.0_f64;
/// Infinity (∞).
@ -426,7 +435,7 @@ impl f64 {
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;
/// Returns `true` if this value is `NaN`.
/// Returns `true` if this value is NaN.
///
/// ```
/// let nan = f64::NAN;
@ -475,7 +484,7 @@ impl f64 {
self.abs_private() == Self::INFINITY
}
/// Returns `true` if this number is neither infinite nor `NaN`.
/// Returns `true` if this number is neither infinite nor NaN.
///
/// ```
/// let f = 7.0f64;
@ -526,7 +535,7 @@ impl f64 {
}
/// Returns `true` if the number is neither zero, infinite,
/// [subnormal], or `NaN`.
/// [subnormal], or NaN.
///
/// ```
/// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
@ -581,8 +590,12 @@ impl f64 {
}
}
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
/// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
/// positive sign bit and positive infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f64;
@ -608,8 +621,12 @@ impl f64 {
self.is_sign_positive()
}
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
/// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
/// negative sign bit and negative infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f64;
@ -690,8 +707,10 @@ impl f64 {
/// Returns the maximum of the two numbers.
///
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmax.
/// 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.
///
/// ```
/// let x = 1.0_f64;
@ -699,8 +718,6 @@ impl f64 {
///
/// assert_eq!(x.max(y), y);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -710,8 +727,10 @@ impl f64 {
/// Returns the minimum of the two numbers.
///
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmin.
/// 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.
///
/// ```
/// let x = 1.0_f64;
@ -719,8 +738,6 @@ impl f64 {
///
/// assert_eq!(x.min(y), x);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -728,7 +745,7 @@ impl f64 {
intrinsics::minnumf64(self, other)
}
/// Returns the maximum of the two numbers, propagating NaNs.
/// Returns the maximum of the two numbers.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f64::max`] which only returns NaN when *both* arguments are NaN.
@ -760,7 +777,7 @@ impl f64 {
}
}
/// Returns the minimum of the two numbers, propagating NaNs.
/// Returns the minimum of the two numbers.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f64::min`] which only returns NaN when *both* arguments are NaN.

18
library/core/src/primitive_docs.rs
View file

@ -977,10 +977,20 @@ mod prim_tuple {}
/// like `1.0 / 0.0`.
/// - [NaN (not a number)](#associatedconstant.NAN): this value results from
/// calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected
/// behavior: it is unequal to any float, including itself! It is also neither
/// smaller nor greater than any float, making it impossible to sort. Lastly,
/// it is considered infectious as almost all calculations where one of the
/// operands is NaN will also result in NaN.
/// behavior:
/// - It is unequal to any float, including itself!
/// - It is also neither smaller nor greater than any float, making it
/// impossible to sort by the default comparison operation. This is the
/// reason `f32` doesn't implement the `Ord` and `Eq` traits.
/// - It is also considered *infectious* as almost all calculations where one
/// of the operands is NaN will also result in NaN. The explanations on this
/// page only explicitly document behavior on NaN operands if this default
/// is *not* observed by the operation.
/// - Lastly, there are multiple bit patterns that are considered NaN.
/// Rust does not currently guarantee that the bit patterns of NaN are
/// preserved over arithmetic operations,
/// so there may be some surprising results upon inspecting the bit patterns,
/// as the same calculations might produce NaNs with different bit patterns.
///
/// For more information on floating point numbers, see [Wikipedia][wikipedia].
///

26
library/std/src/f32.rs
View file

@ -30,7 +30,7 @@ pub use core::f32::{
#[cfg(not(test))]
#[cfg_attr(bootstrap, lang = "f32_runtime")]
impl f32 {
/// Returns the largest integer less than or equal to a number.
/// Returns the largest integer less than or equal to `self`.
///
/// # Examples
///
@ -51,7 +51,7 @@ impl f32 {
unsafe { intrinsics::floorf32(self) }
}
/// Returns the smallest integer greater than or equal to a number.
/// Returns the smallest integer greater than or equal to `self`.
///
/// # Examples
///
@ -70,7 +70,7 @@ impl f32 {
unsafe { intrinsics::ceilf32(self) }
}
/// Returns the nearest integer to a number. Round half-way cases away from
/// Returns the nearest integer to `self`. Round half-way cases away from
/// `0.0`.
///
/// # Examples
@ -90,7 +90,8 @@ impl f32 {
unsafe { intrinsics::roundf32(self) }
}
/// Returns the integer part of a number.
/// Returns the integer part of `self`.
/// This means that non-integer numbers are always truncated towards zero.
///
/// # Examples
///
@ -111,7 +112,7 @@ impl f32 {
unsafe { intrinsics::truncf32(self) }
}
/// Returns the fractional part of a number.
/// Returns the fractional part of `self`.
///
/// # Examples
///
@ -132,8 +133,7 @@ impl f32 {
self - self.trunc()
}
/// Computes the absolute value of `self`. Returns `NAN` if the
/// number is `NAN`.
/// Computes the absolute value of `self`.
///
/// # Examples
///
@ -161,7 +161,7 @@ impl f32 {
///
/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
/// - `NAN` if the number is `NAN`
/// - NaN if the number is NaN
///
/// # Examples
///
@ -185,8 +185,10 @@ impl f32 {
/// `sign`.
///
/// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
/// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
/// `sign` is returned.
/// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
/// `sign` is returned. Note, however, that conserving the sign bit on NaN
/// across arithmetical operations is not generally guaranteed.
/// See [explanation of NaN as a special value](primitive@f32) for more info.
///
/// # Examples
///
@ -299,7 +301,9 @@ impl f32 {
/// Raises a number to an integer power.
///
/// Using this function is generally faster than using `powf`
/// Using this function is generally faster than using `powf`.
/// It might have different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Examples
///

26
library/std/src/f64.rs
View file

@ -30,7 +30,7 @@ pub use core::f64::{
#[cfg(not(test))]
#[cfg_attr(bootstrap, lang = "f64_runtime")]
impl f64 {
/// Returns the largest integer less than or equal to a number.
/// Returns the largest integer less than or equal to `self`.
///
/// # Examples
///
@ -51,7 +51,7 @@ impl f64 {
unsafe { intrinsics::floorf64(self) }
}
/// Returns the smallest integer greater than or equal to a number.
/// Returns the smallest integer greater than or equal to `self`.
///
/// # Examples
///
@ -70,7 +70,7 @@ impl f64 {
unsafe { intrinsics::ceilf64(self) }
}
/// Returns the nearest integer to a number. Round half-way cases away from
/// Returns the nearest integer to `self`. Round half-way cases away from
/// `0.0`.
///
/// # Examples
@ -90,7 +90,8 @@ impl f64 {
unsafe { intrinsics::roundf64(self) }
}
/// Returns the integer part of a number.
/// Returns the integer part of `self`.
/// This means that non-integer numbers are always truncated towards zero.
///
/// # Examples
///
@ -111,7 +112,7 @@ impl f64 {
unsafe { intrinsics::truncf64(self) }
}
/// Returns the fractional part of a number.
/// Returns the fractional part of `self`.
///
/// # Examples
///
@ -132,8 +133,7 @@ impl f64 {
self - self.trunc()
}
/// Computes the absolute value of `self`. Returns `NAN` if the
/// number is `NAN`.
/// Computes the absolute value of `self`.
///
/// # Examples
///
@ -161,7 +161,7 @@ impl f64 {
///
/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
/// - `NAN` if the number is `NAN`
/// - NaN if the number is NaN
///
/// # Examples
///
@ -185,8 +185,10 @@ impl f64 {
/// `sign`.
///
/// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
/// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
/// `sign` is returned.
/// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
/// `sign` is returned. Note, however, that conserving the sign bit on NaN
/// across arithmetical operations is not generally guaranteed.
/// See [explanation of NaN as a special value](primitive@f32) for more info.
///
/// # Examples
///
@ -299,7 +301,9 @@ impl f64 {
/// Raises a number to an integer power.
///
/// Using this function is generally faster than using `powf`
/// Using this function is generally faster than using `powf`.
/// It might have different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Examples
///

18
library/std/src/primitive_docs.rs
View file

@ -977,10 +977,20 @@ mod prim_tuple {}
/// like `1.0 / 0.0`.
/// - [NaN (not a number)](#associatedconstant.NAN): this value results from
/// calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected
/// behavior: it is unequal to any float, including itself! It is also neither
/// smaller nor greater than any float, making it impossible to sort. Lastly,
/// it is considered infectious as almost all calculations where one of the
/// operands is NaN will also result in NaN.
/// behavior:
/// - It is unequal to any float, including itself!
/// - It is also neither smaller nor greater than any float, making it
/// impossible to sort by the default comparison operation. This is the
/// reason `f32` doesn't implement the `Ord` and `Eq` traits.
/// - It is also considered *infectious* as almost all calculations where one
/// of the operands is NaN will also result in NaN. The explanations on this
/// page only explicitly document behavior on NaN operands if this default
/// is *not* observed by the operation.
/// - Lastly, there are multiple bit patterns that are considered NaN.
/// Rust does not currently guarantee that the bit patterns of NaN are
/// preserved over arithmetic operations,
/// so there may be some surprising results upon inspecting the bit patterns,
/// as the same calculations might produce NaNs with different bit patterns.
///
/// For more information on floating point numbers, see [Wikipedia][wikipedia].
///