Code change:
/// /// # NaN bit patterns /// <del> /// This section defines the possible NaN bit patterns returned by non-"bitwise" floating point /// operations. The bitwise operations are unary `-`, `abs`, `copysign`; those are guaranteed to /// exactly preserve the bit pattern of their input except for possibly changing the sign bit. </del> <ins> /// This section defines the possible NaN bit patterns returned by floating-point operations. </ins> /// <del> /// A floating-point NaN value consists of: /// - a sign bit /// - a quiet/signaling bit </del> <ins> /// The bit pattern of a floating-point NaN value is defined by: /// - a sign bit. /// - a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to `1` indicates a ///   quiet NaN (QNaN), and a value of `0` indicates a signaling NaN (SNaN). In the following we ///   will hence just call it the "quiet bit". </ins> /// - a payload, which makes up the rest of the significand (i.e., the mantissa) except for the <del> ///   quiet/signaling bit. /// /// Rust assumes that the quiet/signaling bit being set to `1` indicates a quiet NaN (QNaN), and a /// value of `0` indicates a signaling NaN (SNaN). In the following we will hence just call it the /// "quiet bit". /// /// The following rules apply when a NaN value is returned: the result has a non-deterministic sign. /// The quiet bit and payload are non-deterministically chosen from the following set of options: /// /// - **Preferred NaN**: The quiet bit is set and the payload is all-zero. /// - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input ///   operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for ///   `as` casts), then ///   - If the output is smaller than the input, low-order bits of the payload get dropped. ///   - If the output is larger than the input, the payload gets filled up with 0s in the low-order ///     bits. /// - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand ///   that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the ///   same rules as for "quieting NaN propagation" apply, with one caveat: if the output is smaller ///   than the input, droppig the low-order bits may result in a payload of 0; a payload of 0 is not ///   possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN ///   propagation cannot occur with some inputs. /// - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific ///   set of "extra" possible NaN payloads. The set can depend on the input operand values. ///   See the table below for the concrete NaNs this set contains on various targets. </del> <ins> ///   quiet bit. /// /// The rules for NaN values differ between *arithmetic* and *non-arithmetic* (or "bitwise") /// operations. The non-arithmetic operations are unary `-`, `abs`, `copysign`, `signum`, /// `{to,from}_bits`, `{to,from}_{be,le,ne}_bytes` and `is_sign_{positive,negative}`. These /// operations are guaranteed to exactly preserve the bit pattern of their input except for possibly /// changing the sign bit. /// /// The following rules apply when a NaN value is returned from an arithmetic operation: /// - The result has a non-deterministic sign. /// - The quiet bit and payload are non-deterministically chosen from ///   the following set of options: /// ///   - **Preferred NaN**: The quiet bit is set and the payload is all-zero. ///   - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input ///     operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for ///     `as` casts), then ///     - If the output is smaller than the input, low-order bits of the payload get dropped. ///     - If the output is larger than the input, the payload gets filled up with 0s in the low-order ///       bits. ///   - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand ///     that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the ///     same rules as for "quieting NaN propagation" apply, with one caveat: if the output is smaller ///     than the input, droppig the low-order bits may result in a payload of 0; a payload of 0 is not ///     possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN ///     propagation cannot occur with some inputs. ///   - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific ///     set of "extra" possible NaN payloads. The set can depend on the input operand values. ///     See the table below for the concrete NaNs this set contains on various targets. </ins> /// /// In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN /// is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input

Related discussion:
text: Pointed out by in the float docs are using the term "arithmetic" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of "non-bitwise floating point operations" which they use currently). By "arithmetic operations", the docs likely mean all operations except for unary , , , , , and .