//! `f64` 双精度浮点类型的常量。
//!
//! *[See also the `f64` primitive type][f64].*
//!
//! `consts` 子模块中提供了数学上有效的数字。
//!
//! 对于直接在此模块中定义的常量 (不同于 `consts` 子模块中定义的常量)，新代码应改为使用直接在 `f64` 类型上定义的关联常量。
//!
//!
//!

#![stable(feature = "rust1", since = "1.0.0")]

use crate::convert::FloatToInt;
#[cfg(not(test))]
use crate::intrinsics;
use crate::mem;
use crate::num::FpCategory;

/// `f64` 内部表示形式的基数或基数。
/// 请改用 [`f64::RADIX`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let r = std::f64::RADIX;
///
/// // 预期的方式
/// let r = f64::RADIX;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `RADIX` associated constant on `f64`")]
pub const RADIX: u32 = f64::RADIX;

/// 基数中的有效位数 2.
/// 请改用 [`f64::MANTISSA_DIGITS`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let d = std::f64::MANTISSA_DIGITS;
///
/// // 预期的方式
/// let d = f64::MANTISSA_DIGITS;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(
    since = "TBD",
    note = "replaced by the `MANTISSA_DIGITS` associated constant on `f64`"
)]
pub const MANTISSA_DIGITS: u32 = f64::MANTISSA_DIGITS;

/// 以 10 为基数的有效位数的大概数字。
/// 请改用 [`f64::DIGITS`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let d = std::f64::DIGITS;
///
/// // 预期的方式
/// let d = f64::DIGITS;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `DIGITS` associated constant on `f64`")]
pub const DIGITS: u32 = f64::DIGITS;

/// `f64` 的 [机器精度][Machine epsilon] 值。
/// 请改用 [`f64::EPSILON`]。
///
/// 这是 `1.0` 与下一个较大的可表示数字之间的差异。
///
/// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let e = std::f64::EPSILON;
///
/// // 预期的方式
/// let e = f64::EPSILON;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `EPSILON` associated constant on `f64`")]
pub const EPSILON: f64 = f64::EPSILON;

/// 最小的 `f64` 有限值。
/// 请改用 [`f64::MIN`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN;
///
/// // 预期的方式
/// let min = f64::MIN;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN` associated constant on `f64`")]
pub const MIN: f64 = f64::MIN;

/// 最小正 `f64` 正值。
/// 请改用 [`f64::MIN_POSITIVE`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_POSITIVE;
///
/// // 预期的方式
/// let min = f64::MIN_POSITIVE;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_POSITIVE` associated constant on `f64`")]
pub const MIN_POSITIVE: f64 = f64::MIN_POSITIVE;

/// 最大的有限 `f64` 值。
/// 请改用 [`f64::MAX`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX;
///
/// // 预期的方式
/// let max = f64::MAX;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX` associated constant on `f64`")]
pub const MAX: f64 = f64::MAX;

/// 比 2 的最小可能标准幂大一。
/// 请改用 [`f64::MIN_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_EXP;
///
/// // 预期的方式
/// let min = f64::MIN_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_EXP` associated constant on `f64`")]
pub const MIN_EXP: i32 = f64::MIN_EXP;

/// 2 指数的最大可能乘方。
/// 请改用 [`f64::MAX_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX_EXP;
///
/// // 预期的方式
/// let max = f64::MAX_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX_EXP` associated constant on `f64`")]
pub const MAX_EXP: i32 = f64::MAX_EXP;

/// 最小可能的标准幂为 10 指数。
/// 请改用 [`f64::MIN_10_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let min = std::f64::MIN_10_EXP;
///
/// // 预期的方式
/// let min = f64::MIN_10_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MIN_10_EXP` associated constant on `f64`")]
pub const MIN_10_EXP: i32 = f64::MIN_10_EXP;

/// 最大可能功效为 10 指数。
/// 请改用 [`f64::MAX_10_EXP`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let max = std::f64::MAX_10_EXP;
///
/// // 预期的方式
/// let max = f64::MAX_10_EXP;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `MAX_10_EXP` associated constant on `f64`")]
pub const MAX_10_EXP: i32 = f64::MAX_10_EXP;

/// 不是数字 (NaN)。
/// 请改用 [`f64::NAN`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let nan = std::f64::NAN;
///
/// // 预期的方式
/// let nan = f64::NAN;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `NAN` associated constant on `f64`")]
pub const NAN: f64 = f64::NAN;

/// 无限 (∞)。
/// 请改用 [`f64::INFINITY`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let inf = std::f64::INFINITY;
///
/// // 预期的方式
/// let inf = f64::INFINITY;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `INFINITY` associated constant on `f64`")]
pub const INFINITY: f64 = f64::INFINITY;

/// 负无穷大 (−∞)。
/// 请改用 [`f64::NEG_INFINITY`]。
///
/// # Examples
///
/// ```rust
/// // 弃用的方式
/// # #[allow(deprecated, deprecated_in_future)]
/// let ninf = std::f64::NEG_INFINITY;
///
/// // 预期的方式
/// let ninf = f64::NEG_INFINITY;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[deprecated(since = "TBD", note = "replaced by the `NEG_INFINITY` associated constant on `f64`")]
pub const NEG_INFINITY: f64 = f64::NEG_INFINITY;

/// 基本数学常量。
#[stable(feature = "rust1", since = "1.0.0")]
pub mod consts {
    // FIXME: 用 cmath 中的数学常量替换。

    /// 阿基米德的恒定 (π)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const PI: f64 = 3.14159265358979323846264338327950288_f64;

    /// 整圈常量 (τ)
    ///
    /// 等于 2π。
    #[stable(feature = "tau_constant", since = "1.47.0")]
    pub const TAU: f64 = 6.28318530717958647692528676655900577_f64;

    /// π/2
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64;

    /// π/3
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64;

    /// π/4
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64;

    /// π/6
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64;

    /// π/8
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64;

    /// 1/π
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;

    /// 2/π
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64;

    /// 2/sqrt(π)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;

    /// sqrt(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;

    /// 1/sqrt(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;

    /// 欧拉数 (e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const E: f64 = 2.71828182845904523536028747135266250_f64;

    /// log<sub>2</sub>(10)
    #[stable(feature = "extra_log_consts", since = "1.43.0")]
    pub const LOG2_10: f64 = 3.32192809488736234787031942948939018_f64;

    /// log<sub>2</sub>(e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64;

    /// log<sub>10</sub>(2)
    #[stable(feature = "extra_log_consts", since = "1.43.0")]
    pub const LOG10_2: f64 = 0.301029995663981195213738894724493027_f64;

    /// log<sub>10</sub>(e)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64;

    /// ln(2)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64;

    /// ln(10)
    #[stable(feature = "rust1", since = "1.0.0")]
    pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}

#[cfg(not(test))]
impl f64 {
    /// `f64` 内部表示形式的基数或基数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const RADIX: u32 = 2;

    /// 基数中的有效位数 2.
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MANTISSA_DIGITS: u32 = 53;
    /// 以 10 为基数的有效位数的大概数字。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const DIGITS: u32 = 15;

    /// `f64` 的 [机器精度][Machine epsilon] 值。
    ///
    /// 这是 `1.0` 与下一个较大的可表示数字之间的差异。
    ///
    /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const EPSILON: f64 = 2.2204460492503131e-16_f64;

    /// 最小的 `f64` 有限值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN: f64 = -1.7976931348623157e+308_f64;
    /// 最小正 `f64` 正值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64;
    /// 最大的有限 `f64` 值。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX: f64 = 1.7976931348623157e+308_f64;

    /// 比 2 的最小可能标准幂大一。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_EXP: i32 = -1021;
    /// 2 指数的最大可能乘方。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX_EXP: i32 = 1024;

    /// 最小可能的标准幂为 10 指数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MIN_10_EXP: i32 = -307;
    /// 最大可能功效为 10 指数。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const MAX_10_EXP: i32 = 308;

    /// 不是数字 (NaN)。
    ///
    /// 请注意，IEEE 754 不只定义一个 NaN 值;
    /// 过多的位模式被认为是 NaN。
    /// 此外，该标准区分了 "signaling" 和 "quiet" NaN，并允许检查其 "payload" (位模式中未指定的位)。
    /// 不保证此特性等于任何特定的 NaN 位模式，并且不保证其表示在 Rust 版本和目标平台上的稳定性。
    ///
    ///
    ///
    ///
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const NAN: f64 = 0.0_f64 / 0.0_f64;
    /// 无限 (∞)。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const INFINITY: f64 = 1.0_f64 / 0.0_f64;
    /// 负无穷大 (−∞)。
    #[stable(feature = "assoc_int_consts", since = "1.43.0")]
    pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;

    /// 如果此值为 NaN，则返回 `true`。
    ///
    /// ```
    /// let nan = f64::NAN;
    /// let f = 7.0_f64;
    ///
    /// assert!(nan.is_nan());
    /// assert!(!f.is_nan());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_nan(self) -> bool {
        self != self
    }

    // FIXME(#50145): 由于对可移植性的担忧，`abs` 在核心中是公开不可用的，所以这个实现是供内部 private 使用的。
    //
    //
    #[inline]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    pub(crate) const fn abs_private(self) -> f64 {
        // SAFETY: 这个转变很好。大概吧。可能因为 std 使用它的原因。
        unsafe {
            mem::transmute::<u64, f64>(mem::transmute::<f64, u64>(self) & 0x7fff_ffff_ffff_ffff)
        }
    }

    /// 如果此值是正无穷大或负无穷大，则返回 `true`，否则返回 `false`。
    ///
    ///
    /// ```
    /// let f = 7.0f64;
    /// let inf = f64::INFINITY;
    /// let neg_inf = f64::NEG_INFINITY;
    /// let nan = f64::NAN;
    ///
    /// assert!(!f.is_infinite());
    /// assert!(!nan.is_infinite());
    ///
    /// assert!(inf.is_infinite());
    /// assert!(neg_inf.is_infinite());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_infinite(self) -> bool {
        // 使用转变可能会导致某些 FPU 的错误答复
        // FIXME: 改变 Rust <-> Rust 调用约定来防止这个问题。
        // See https://github.com/rust-lang/rust/issues/72327
        (self == f64::INFINITY) | (self == f64::NEG_INFINITY)
    }

    /// 如果此数字既不是无穷大也不是 NaN，则返回 `true`。
    ///
    /// ```
    /// let f = 7.0f64;
    /// let inf: f64 = f64::INFINITY;
    /// let neg_inf: f64 = f64::NEG_INFINITY;
    /// let nan: f64 = f64::NAN;
    ///
    /// assert!(f.is_finite());
    ///
    /// assert!(!nan.is_finite());
    /// assert!(!inf.is_finite());
    /// assert!(!neg_inf.is_finite());
    /// ```
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_finite(self) -> bool {
        // 无需单独处理 NaN: 如果 self 是 NaN，则比较不完全正确。
        //
        self.abs_private() < Self::INFINITY
    }

    /// 如果数字为 [subnormal]，则返回 `true`。
    ///
    /// ```
    /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308_f64
    /// let max = f64::MAX;
    /// let lower_than_min = 1.0e-308_f64;
    /// let zero = 0.0_f64;
    ///
    /// assert!(!min.is_subnormal());
    /// assert!(!max.is_subnormal());
    ///
    /// assert!(!zero.is_subnormal());
    /// assert!(!f64::NAN.is_subnormal());
    /// assert!(!f64::INFINITY.is_subnormal());
    /// // `0` 和 `min` 之间的值是次标准的。
    /// assert!(lower_than_min.is_subnormal());
    /// ```
    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
    #[must_use]
    #[stable(feature = "is_subnormal", since = "1.53.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_subnormal(self) -> bool {
        matches!(self.classify(), FpCategory::Subnormal)
    }

    /// 如果数字既不是零、无穷大、[subnormal] 或 NaN，则返回 `true`。
    ///
    ///
    /// ```
    /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
    /// let max = f64::MAX;
    /// let lower_than_min = 1.0e-308_f64;
    /// let zero = 0.0f64;
    ///
    /// assert!(min.is_normal());
    /// assert!(max.is_normal());
    ///
    /// assert!(!zero.is_normal());
    /// assert!(!f64::NAN.is_normal());
    /// assert!(!f64::INFINITY.is_normal());
    /// // `0` 和 `min` 之间的值是次标准的。
    /// assert!(!lower_than_min.is_normal());
    /// ```
    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_normal(self) -> bool {
        matches!(self.classify(), FpCategory::Normal)
    }

    /// 返回数字的浮点类别。
    /// 如果仅要测试一个属性，则通常使用特定谓词会更快。
    ///
    ///
    /// ```
    /// use std::num::FpCategory;
    ///
    /// let num = 12.4_f64;
    /// let inf = f64::INFINITY;
    ///
    /// assert_eq!(num.classify(), FpCategory::Normal);
    /// assert_eq!(inf.classify(), FpCategory::Infinite);
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    pub const fn classify(self) -> FpCategory {
        // 以前的实现尝试仅使用基于位掩码的检查，使用 f64::to_bits 将浮点数转换为它的位 repr 并在其上进行匹配。
        // 不幸的是，浮点数可能比这更糟糕。
        // 这也不需要导致对 f64::to_bits 的递归计算。
        //
        // 在某些处理器上，在某些情况下，LLVM 将有益地降低浮点运算，尽管要求它们使用 f32 和 f64，但对 x87 运算之类的操作。
        //
        // 它们有一个 f64 的尾数，但可以具有比正常指数更大的指数。
        // FIXME(jubilee): 为了在 x86 处理器上进行 Rust 到 Rust 的调用，永远不需要使用 x87 操作，所以不应该发生这个问题。
        // 应调整代码生成以使用非 C 调用约定，从而避免这种情况。
        //
        // 因此，一个值可能比较不等于无穷大，尽管具有 "full" 指数掩码。
        // 它可能不是 NaN，因为它可以简单地是一个 "overextended" 有限值。
        //
        //
        if self.is_nan() {
            FpCategory::Nan
        } else {
            // 但是，std 也不能简单地与零比较来检查是否为零，因为正确性需要避免可能是 Subnormal == -0.0 的相等测试，因为它在 "denormals are zero" 和 "flush to zero" 模式下可能是错误的。
            //
            // 大多数 std 的目标不使用这些，但它们用于 thumbv7neon。
            // 因此，这确实使用了其余部分的位模式匹配。
            //

            // SAFETY: f64 到 u64 没问题。Usually.
            // 如果控制流已经走到了这一步，那么该值肯定属于 f64::partial_classify 可以正确分析的类别之一。
            //
            unsafe { f64::partial_classify(self) }
        }
    }

    // 这实际上并没有故意返回 NaN 的正确答案，因为它无法正确区分浮点 NaN 和从 x87 FPU 截断的一些正常浮点数。
    //
    //
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    const unsafe fn partial_classify(self) -> FpCategory {
        const EXP_MASK: u64 = 0x7ff0000000000000;
        const MAN_MASK: u64 = 0x000fffffffffffff;

        // SAFETY: 调用者不会问这样会说谎的问题。
        let b = unsafe { mem::transmute::<f64, u64>(self) };
        match (b & MAN_MASK, b & EXP_MASK) {
            (0, EXP_MASK) => FpCategory::Infinite,
            (0, 0) => FpCategory::Zero,
            (_, 0) => FpCategory::Subnormal,
            _ => FpCategory::Normal,
        }
    }

    // 它对位进行操作，并且仅对位进行操作，因此它可以忽略对奇怪 FPU 的担忧。
    // FIXME(jubilee): 在一个公正的世界里，这将是分类的整个 impl，加上一个 transmute。
    // 我们并不生活在一个公正的世界里，但我们可以让它变得更加公正。
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    const fn classify_bits(b: u64) -> FpCategory {
        const EXP_MASK: u64 = 0x7ff0000000000000;
        const MAN_MASK: u64 = 0x000fffffffffffff;

        match (b & MAN_MASK, b & EXP_MASK) {
            (0, EXP_MASK) => FpCategory::Infinite,
            (_, EXP_MASK) => FpCategory::Nan,
            (0, 0) => FpCategory::Zero,
            (_, 0) => FpCategory::Subnormal,
            _ => FpCategory::Normal,
        }
    }

    /// 如果 `self` 有正号，则返回 `true`，包括 `+0.0`、带正号位的 NaN 和正无穷大。
    /// 请注意，在 NaN 的情况下，IEEE 754 不会为符号位分配任何含义，并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变，因此 `is_sign_positive` 对 NaN 的结果可能会产生意外在某些情况下导致。
    ///
    /// 有关详细信息，请参见 [将 NaN 解释为特殊值](f32)。
    ///
    /// ```
    /// let f = 7.0_f64;
    /// let g = -7.0_f64;
    ///
    /// assert!(f.is_sign_positive());
    /// assert!(!g.is_sign_positive());
    /// ```
    ///
    ///
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_sign_positive(self) -> bool {
        !self.is_sign_negative()
    }

    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[deprecated(since = "1.0.0", note = "renamed to is_sign_positive")]
    #[inline]
    #[doc(hidden)]
    pub fn is_positive(self) -> bool {
        self.is_sign_positive()
    }

    /// 如果 `self` 具有 negative 符号，则返回 `true`，包括 `-0.0`、具有 negative 符号位的 NaN 和 negative 无穷大。
    /// 请注意，在 NaN 的情况下，IEEE 754 不会为符号位分配任何含义，并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变，因此 `is_sign_negative` 对 NaN 的结果可能会产生意外在某些情况下导致。
    ///
    /// 有关详细信息，请参见 [将 NaN 解释为特殊值](f32)。
    ///
    /// ```
    /// let f = 7.0_f64;
    /// let g = -7.0_f64;
    ///
    /// assert!(!f.is_sign_negative());
    /// assert!(g.is_sign_negative());
    /// ```
    ///
    ///
    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
    #[inline]
    pub const fn is_sign_negative(self) -> bool {
        // IEEE754 说：当且仅当 x 具有负号时，isSignMinus(x) 才为 true。
        // isSignMinus 也适用于零和 NaN。
        // SAFETY: 这只是为了得到符号位而转换，没关系。
        unsafe { mem::transmute::<f64, u64>(self) & 0x8000_0000_0000_0000 != 0 }
    }

    #[must_use]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[deprecated(since = "1.0.0", note = "renamed to is_sign_negative")]
    #[inline]
    #[doc(hidden)]
    pub fn is_negative(self) -> bool {
        self.is_sign_negative()
    }

    /// 返回大于 `self` 的最小数字。
    ///
    /// 令 `TINY` 为可表示的最小正 `f64`。
    /// Then,
    ///  - 如果是 `self.is_nan()`，则返回 `self`;
    ///  - 如果 `self` 是 [`NEG_INFINITY`]，则返回 [`MIN`];
    ///  - 如果 `self` 是 `-TINY`，则返回 - 0.0;
    ///  - 如果 `self` 为 - 0.0 或 + 0.0，则返回 `TINY`;
    ///  - 如果 `self` 是 [`MAX`] 或 [`INFINITY`]，则返回 [`INFINITY`];
    ///  - 否则返回大于 `self` 的唯一最小值。
    ///
    /// 恒等式 `x.next_up() == -(-x).next_down()` 适用于所有非 NaN `x`。当 `x` 为有限时，`x == x.next_up().next_down()` 也成立。
    ///
    /// ```rust
    /// #![feature(float_next_up_down)]
    /// // f64::EPSILON 是 1.0 和下一个数字之间的差。
    /// assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON);
    /// // 但不适用于大多数数字。
    /// assert!(0.1f64.next_up() < 0.1 + f64::EPSILON);
    /// assert_eq!(9007199254740992f64.next_up(), 9007199254740994.0);
    /// ```
    ///
    /// [`NEG_INFINITY`]: Self::NEG_INFINITY
    /// [`INFINITY`]: Self::INFINITY
    /// [`MIN`]: Self::MIN
    /// [`MAX`]: Self::MAX
    #[unstable(feature = "float_next_up_down", issue = "91399")]
    #[rustc_const_unstable(feature = "float_next_up_down", issue = "91399")]
    pub const fn next_up(self) -> Self {
        // 我们必须使用严格的整数算术来防止非正规在某些平台上的算术运算后刷新为零。
        //
        const TINY_BITS: u64 = 0x1; // 最小正 f64。
        const CLEAR_SIGN_MASK: u64 = 0x7fff_ffff_ffff_ffff;

        let bits = self.to_bits();
        if self.is_nan() || bits == Self::INFINITY.to_bits() {
            return self;
        }

        let abs = bits & CLEAR_SIGN_MASK;
        let next_bits = if abs == 0 {
            TINY_BITS
        } else if bits == abs {
            bits + 1
        } else {
            bits - 1
        };
        Self::from_bits(next_bits)
    }

    /// 返回小于 `self` 的最大数。
    ///
    /// 令 `TINY` 为可表示的最小正 `f64`。
    /// Then,
    ///  - 如果是 `self.is_nan()`，则返回 `self`;
    ///  - 如果 `self` 是 [`INFINITY`]，则返回 [`MAX`];
    ///  - 如果 `self` 是 `TINY`，则返回 0.0;
    ///  - 如果 `self` 为 - 0.0 或 + 0.0，则返回 `-TINY`;
    ///  - 如果 `self` 是 [`MIN`] 或 [`NEG_INFINITY`]，则返回 [`NEG_INFINITY`];
    ///  - 否则返回小于 `self` 的唯一最大值。
    ///
    /// 恒等式 `x.next_down() == -(-x).next_up()` 适用于所有非 NaN `x`。当 `x` 为有限时，`x == x.next_down().next_up()` 也成立。
    ///
    /// ```rust
    /// #![feature(float_next_up_down)]
    /// let x = 1.0f64;
    /// // 将值限制在 [0, 1) 范围内。
    /// let clamped = x.clamp(0.0, 1.0f64.next_down());
    /// assert!(clamped < 1.0);
    /// assert_eq!(clamped.next_up(), 1.0);
    /// ```
    ///
    /// [`NEG_INFINITY`]: Self::NEG_INFINITY
    /// [`INFINITY`]: Self::INFINITY
    /// [`MIN`]: Self::MIN
    /// [`MAX`]: Self::MAX
    #[unstable(feature = "float_next_up_down", issue = "91399")]
    #[rustc_const_unstable(feature = "float_next_up_down", issue = "91399")]
    pub const fn next_down(self) -> Self {
        // 我们必须使用严格的整数算术来防止非正规在某些平台上的算术运算后刷新为零。
        //
        const NEG_TINY_BITS: u64 = 0x8000_0000_0000_0001; // 最小 (幅度) negative f64。
        const CLEAR_SIGN_MASK: u64 = 0x7fff_ffff_ffff_ffff;

        let bits = self.to_bits();
        if self.is_nan() || bits == Self::NEG_INFINITY.to_bits() {
            return self;
        }

        let abs = bits & CLEAR_SIGN_MASK;
        let next_bits = if abs == 0 {
            NEG_TINY_BITS
        } else if bits == abs {
            bits - 1
        } else {
            bits + 1
        };
        Self::from_bits(next_bits)
    }

    /// 取一个数 `1/x` 的倒数 (inverse)。
    ///
    /// ```
    /// let x = 2.0_f64;
    /// let abs_difference = (x.recip() - (1.0 / x)).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn recip(self) -> f64 {
        1.0 / self
    }

    /// 将弧度转换为度数。
    ///
    /// ```
    /// let angle = std::f64::consts::PI;
    ///
    /// let abs_difference = (angle.to_degrees() - 180.0).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn to_degrees(self) -> f64 {
        // 此处的除法相对于 180/π 的真实值正确取整。
        // (这与 f32 不同，在 f32 中，必须使用常量来确保正确舍入结果。)
        //
        self * (180.0f64 / consts::PI)
    }

    /// 将度数转换为弧度。
    ///
    /// ```
    /// let angle = 180.0_f64;
    ///
    /// let abs_difference = (angle.to_radians() - std::f64::consts::PI).abs();
    ///
    /// assert!(abs_difference < 1e-10);
    /// ```
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn to_radians(self) -> f64 {
        let value: f64 = consts::PI;
        self * (value / 180.0)
    }

    /// 返回两个数字中的最大值，忽略 NaN。
    ///
    /// 如果参数之一是 NaN，则返回另一个参数。
    /// 这遵循 maxNum 的 IEEE 754-2008 语义，除了处理信令 NaN;
    /// 这个函数以相同的方式处理所有的 NaN，并避免了 maxNum 的关联性问题。
    /// 这也符合 libm 的 fmax 的行为。
    ///
    /// ```
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.max(y), y);
    /// ```
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn max(self, other: f64) -> f64 {
        intrinsics::maxnumf64(self, other)
    }

    /// 返回两个数字中的最小值，忽略 NaN。
    ///
    /// 如果参数之一是 NaN，则返回另一个参数。
    /// 这遵循 minNum 的 IEEE 754-2008 语义，除了处理信令 NaN;
    /// 这个函数以相同的方式处理所有的 NaN，并避免了 minNum 的关联性问题。
    /// 这也符合 libm 的 fmin 的行为。
    ///
    /// ```
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.min(y), x);
    /// ```
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn min(self, other: f64) -> f64 {
        intrinsics::minnumf64(self, other)
    }

    /// 返回两个数字中的最大值，传播 NaN。
    ///
    /// 当任一参数为 NaN 时，这将返回 NaN，而 [`f64::max`] 仅当两个参数都为 NaN 时才返回 NaN。
    ///
    /// ```
    /// #![feature(float_minimum_maximum)]
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.maximum(y), y);
    /// assert!(x.maximum(f64::NAN).is_nan());
    /// ```
    ///
    /// 如果参数之一是 NaN，则返回 NaN。否则，这将返回两个数字中较大的一个。对于此操作，`-0.0` 被认为小于 `+0.0`。
    /// 请注意，这遵循 IEEE 754-2019 中指定的语义。
    ///
    /// 另请注意，此处 NaN 的 "propagation" 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息，请参见 [将 NaN 解释为特殊值](f32)。
    ///
    ///
    ///
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[unstable(feature = "float_minimum_maximum", issue = "91079")]
    #[inline]
    pub fn maximum(self, other: f64) -> f64 {
        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
        }
    }

    /// 返回两个数字中的最小值，传播 NaN。
    ///
    /// 当任一参数为 NaN 时返回 NaN，而 [`f64::min`] 仅当两个参数都为 NaN 时才返回 NaN。
    ///
    /// ```
    /// #![feature(float_minimum_maximum)]
    /// let x = 1.0_f64;
    /// let y = 2.0_f64;
    ///
    /// assert_eq!(x.minimum(y), x);
    /// assert!(x.minimum(f64::NAN).is_nan());
    /// ```
    ///
    /// 如果参数之一是 NaN，则返回 NaN。否则，这将返回两个数字中的较小者。对于此操作，`-0.0` 被认为小于 `+0.0`。
    /// 请注意，这遵循 IEEE 754-2019 中指定的语义。
    ///
    /// 另请注意，此处 NaN 的 "propagation" 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息，请参见 [将 NaN 解释为特殊值](f32)。
    ///
    ///
    ///
    #[must_use = "this returns the result of the comparison, without modifying either input"]
    #[unstable(feature = "float_minimum_maximum", issue = "91079")]
    #[inline]
    pub fn minimum(self, other: f64) -> f64 {
        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 {
            self + other
        }
    }

    /// 计算 `self` 和 `rhs` 的中点。
    ///
    /// 当 * 参数为 NaN 或者 + inf 和 -inf 的组合作为参数提供时，这将返回 NaN。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(num_midpoint)]
    /// assert_eq!(1f64.midpoint(4.0), 2.5);
    /// assert_eq!((-5.5f64).midpoint(8.0), 1.25);
    /// ```
    #[unstable(feature = "num_midpoint", issue = "110840")]
    pub fn midpoint(self, other: f64) -> f64 {
        const LO: f64 = f64::MIN_POSITIVE * 2.;
        const HI: f64 = f64::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 {
            // 溢出是不可能的
            (a + b) / 2.
        } else if abs_a < LO {
            // 减半不安全
            a + (b / 2.)
        } else if abs_b < LO {
            // 减半 b 不安全
            (a / 2.) + b
        } else {
            // 将 a 和 b 减半不安全
            (a / 2.) + (b / 2.)
        }
    }

    /// 舍入为零并转换为任何原始整数类型，前提是该值是有限的并且适合该类型。
    ///
    ///
    /// ```
    /// let value = 4.6_f64;
    /// let rounded = unsafe { value.to_int_unchecked::<u16>() };
    /// assert_eq!(rounded, 4);
    ///
    /// let value = -128.9_f64;
    /// let rounded = unsafe { value.to_int_unchecked::<i8>() };
    /// assert_eq!(rounded, i8::MIN);
    /// ```
    ///
    /// # Safety
    ///
    /// 该值必须：
    ///
    /// * 不是 `NaN`
    /// * 不是无限的
    /// * 截断小数部分后，可以在返回类型 `Int` 中表示
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_approx_unchecked_to", since = "1.44.0")]
    #[inline]
    pub unsafe fn to_int_unchecked<Int>(self) -> Int
    where
        Self: FloatToInt<Int>,
    {
        // SAFETY: 调用者必须遵守 `FloatToInt::to_int_unchecked` 的安全保证。
        //
        unsafe { FloatToInt::<Int>::to_int_unchecked(self) }
    }

    /// 原始 trans 变为 `u64`。
    ///
    /// 当前，这与所有平台上的 `transmute::<f64, u64>(self)` 相同。
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// 请注意，此函数与 `as` 强制转换不同，后者试图保留 *数字* 值，而不是按位值。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// assert!((1f64).to_bits() != 1f64 as u64); // to_bits() 不是 casting!
    /// assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
    ///
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_bits_conv", since = "1.20.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_bits(self) -> u64 {
        // SAFETY: `u64` 是一个普通的旧数据类型，所以我们总是可以转换成它。
        // ...sorta.
        //
        // 有关更多信息，请参见 f64::from_bits 中的 SAFETY 注释。
        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
        const fn ct_f64_to_u64(ct: f64) -> u64 {
            match ct.classify() {
                FpCategory::Nan => {
                    panic!("const-eval error: cannot use f64::to_bits on a NaN")
                }
                FpCategory::Subnormal => {
                    panic!("const-eval error: cannot use f64::to_bits on a subnormal number")
                }
                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
                    // SAFETY: 我们有一个普通的浮点数。现在我们进行转换，即进行位复制。
                    unsafe { mem::transmute::<f64, u64>(ct) }
                }
            }
        }

        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
        fn rt_f64_to_u64(rt: f64) -> u64 {
            // SAFETY: `u64` 是一个普通的旧数据类型，所以我们总是可以...... uh ...
            // ...看，假装您忘记了刚刚读到的内容。
            // 稳定性问题。
            unsafe { mem::transmute::<f64, u64>(rt) }
        }
        // SAFETY: 我们使用在编译时要么总是工作要么失败的内部实现。
        unsafe { intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f64_to_u64) }
    }

    /// 来自 `u64` 的原始 mut 变。
    ///
    /// 当前，这与所有平台上的 `transmute::<u64, f64>(v)` 相同。
    /// 事实证明，此方法具有很高的可移植性，其原因有两个：
    ///
    /// * 浮点数和整数在所有受支持的平台上具有相同的字节序。
    /// * IEEE 754 非常精确地指定了浮点数的位布局。
    ///
    /// 但是有一个警告: 在 2008 年版本的 IEEE 754 之前，实际上并未指定如何解释 NaN 信号位。
    /// 大多数平台 (特别是 x86 和 ARM) 采用了最终在 2008 年标准化的解释，但有些则没有 (特别是 MIPS)。
    /// 结果，MIPS 上的所有信令 NaN 都是 x86 上的安静 NaN，反之亦然。
    ///
    /// 该实现方式不是尝试保留跨信令的信令，而是倾向于保留确切的位。
    /// 这意味着，即使此方法的结果通过网络从 x86 机器发送到 MIPS 机器，任何以 NaN 编码的有效载荷也将被保留。
    ///
    ///
    /// 如果这个方法的结果只由产生它们的同一个架构操纵，那么就没有可移植性的问题。
    ///
    /// 如果输入的不是 NaN，则不存在可移植性问题。
    ///
    /// 如果您不太在意信号传递性，那么就不必担心可移植性。
    ///
    /// 请注意，此函数与 `as` 强制转换不同，后者试图保留 *数字* 值，而不是按位值。
    ///
    /// # Examples
    ///
    /// ```
    /// let v = f64::from_bits(0x4029000000000000);
    /// assert_eq!(v, 12.5);
    /// ```
    ///
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "float_bits_conv", since = "1.20.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_bits(v: u64) -> Self {
        // 事实证明，sNaN 的安全问题被夸大了! Hooray!
        // SAFETY: `u64` 是一个普通的旧数据类型，所以我们总是可以从它变形...... 排序。
        //
        // 事实证明，在运行时，浮点数可能会受到浮点模式的影响，这些模式在读取和写入时将非零 subnormal 数更改为零，即 "denormals are zero" 和 "flush to zero"。
        // 这通常不是问题，但 Rust 的至少一个 tier2 平台实际上默认表现出 FTZ 行为: thumbv7neon aka "the Neon FPU in AArch32 state"
        //
        // 即使这样，并非所有指令都在 thumbv7neon 上表现出 FTZ 行为，因此如果 LLVM 发出 "correct" 指令，这应该加载相同的位，但 LLVM 有时会做出有趣的浮点优化选择，其他 FPU 可能会做类似的事情。
        //
        // 因此，谨慎地放纵奢华是明智的。
        //
        // 此外，在禁用 SSE 或 SSE2 并启用 x87 FPU 的 x86 目标上，即
        // 不是软浮点，Rust 进行参数传递的方式实际上可以以稍微不可预测的方式将 "not infinity" 的数字更改为具有与无穷大相同的指数。
        //
        // 而且，当然评估到 NaN 值是相当不确定的。
        // 更准确地说: 什么时候应该返回 NaN 是可知的，但是哪个 NaN 呢?
        // 到目前为止，这是由 LLVM 和 CPU 的组合定义的，而不是 Rust。
        // 然而，这个函数允许观察 NaN 的位串，从而对 CTFE 进行内省。
        //
        // 为了至少暂时保持 const 到运行时的等价性，拒绝任何这些可能的情况发生。
        //
        //
        //
        //
        //
        //
        //
        //
        //
        //
        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
        const fn ct_u64_to_f64(ct: u64) -> f64 {
            match f64::classify_bits(ct) {
                FpCategory::Subnormal => {
                    panic!("const-eval error: cannot use f64::from_bits on a subnormal number")
                }
                FpCategory::Nan => {
                    panic!("const-eval error: cannot use f64::from_bits on NaN")
                }
                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
                    // SAFETY: 这不是一个有趣的数字
                    unsafe { mem::transmute::<u64, f64>(ct) }
                }
            }
        }

        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
        fn rt_u64_to_f64(rt: u64) -> f64 {
            // SAFETY: `u64` 是一个普通的旧数据类型，所以我们总是可以...... uh ...
            // ...看，假装您忘记了刚刚读到的内容。
            // 稳定性问题。
            unsafe { mem::transmute::<u64, f64>(rt) }
        }
        // SAFETY: 我们使用在编译时要么总是工作要么失败的内部实现。
        unsafe { intrinsics::const_eval_select((v,), ct_u64_to_f64, rt_u64_to_f64) }
    }

    /// 以大端 (网络) 字节顺序的字节数组形式返回此浮点数的内存表示形式。
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_be_bytes();
    /// assert_eq!(bytes, [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_be_bytes(self) -> [u8; 8] {
        self.to_bits().to_be_bytes()
    }

    /// 以小字节序字节顺序将浮点数的内存表示形式返回为字节数组。
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_le_bytes();
    /// assert_eq!(bytes, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
    /// ```
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_le_bytes(self) -> [u8; 8] {
        self.to_bits().to_le_bytes()
    }

    /// 返回此浮点数的内存表示形式，以原生字节顺序的字节数组形式。
    ///
    /// 由于使用了目标平台的原生字节序，因此，可移植代码应酌情使用 [`to_be_bytes`] 或 [`to_le_bytes`]。
    ///
    ///
    /// [`to_be_bytes`]: f64::to_be_bytes
    /// [`to_le_bytes`]: f64::to_le_bytes
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// # Examples
    ///
    /// ```
    /// let bytes = 12.5f64.to_ne_bytes();
    /// assert_eq!(
    ///     bytes,
    ///     if cfg!(target_endian = "big") {
    ///         [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    ///     } else {
    ///         [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
    ///     }
    /// );
    /// ```
    ///
    ///
    #[must_use = "this returns the result of the operation, \
                  without modifying the original"]
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[inline]
    pub const fn to_ne_bytes(self) -> [u8; 8] {
        self.to_bits().to_ne_bytes()
    }

    /// 从其表示形式以 big endian 的字节数组创建一个浮点值。
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_be_bytes([0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    /// assert_eq!(value, 12.5);
    /// ```
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_be_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_be_bytes(bytes))
    }

    /// 从它的表示形式以 Little Endian 的字节数组创建一个浮点值。
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_le_bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
    /// assert_eq!(value, 12.5);
    /// ```
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_le_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_le_bytes(bytes))
    }

    /// 从其表示形式 (以原生字节序形式的字节数组形式) 创建浮点值。
    ///
    /// 由于使用了目标平台的原生字节序，因此可移植代码可能希望酌情使用 [`from_be_bytes`] 或 [`from_le_bytes`]。
    ///
    ///
    /// [`from_be_bytes`]: f64::from_be_bytes
    /// [`from_le_bytes`]: f64::from_le_bytes
    ///
    /// 有关此操作的可移植性的一些讨论，请参见 [`from_bits`](Self::from_bits) (几乎没有问题)。
    ///
    /// # Examples
    ///
    /// ```
    /// let value = f64::from_ne_bytes(if cfg!(target_endian = "big") {
    ///     [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    /// } else {
    ///     [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
    /// });
    /// assert_eq!(value, 12.5);
    /// ```
    ///
    ///
    #[stable(feature = "float_to_from_bytes", since = "1.40.0")]
    #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
    #[must_use]
    #[inline]
    pub const fn from_ne_bytes(bytes: [u8; 8]) -> Self {
        Self::from_bits(u64::from_ne_bytes(bytes))
    }

    /// 返回 `self` 和 `other` 之间的顺序。
    ///
    /// 与浮点数之间的标准部分比较不同，此比较始终根据 IEEE 754 (2008 修订版) 浮点标准中定义的 `totalOrder` 谓词生成排序。
    /// 这些值按以下顺序排序:
    ///
    /// - negative quiet NaN
    /// - negative signaling NaN
    /// - negative infinity
    /// - negative numbers
    /// - negative subnormal numbers
    /// - negative zero
    /// - positive zero
    /// - positive subnormal numbers
    /// - positive numbers
    /// - positive infinity
    /// - positive signaling NaN
    /// - positive quiet NaN.
    ///
    /// 这个函数建立的顺序并不总是与 `f64` 的 [`PartialOrd`] 和 [`PartialEq`] 实现一致。
    /// 例如，他们认为负零和正零相等，而 `total_cmp`
    /// doesn't.
    ///
    /// 信令 NaN 位的解释遵循 IEEE 754 标准中的定义，这可能与一些旧的、不符合标准的 (例如 MIPS) 硬件实现的解释不匹配。
    ///
    /// # Example
    ///
    /// ```
    /// struct GoodBoy {
    ///     name: String,
    ///     weight: f64,
    /// }
    ///
    /// let mut bois = vec![
    ///     GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    ///     GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    ///     GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    ///     GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },
    ///     GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },
    ///     GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
    /// ];
    ///
    /// bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));
    /// # assert!(bois.into_iter().map(|b| b.weight)
    /// #     .zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())
    /// #     .all(|(a, b)| a.to_bits() == b.to_bits()))
    /// ```
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "total_cmp", since = "1.62.0")]
    #[must_use]
    #[inline]
    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
        let mut left = self.to_bits() as i64;
        let mut right = other.to_bits() as i64;

        // 如果是负数，将除符号外的所有位翻转以实现与二进制补码整数相似的布局
        //
        // 为什么这样做？ IEEE 754 浮点数包含三个字段：
        // 符号位，指数和尾数。整个指数和尾数字段具有以下属性：它们的按位顺序等于定义大小的数字大小。
        // 幅度通常不是在 NaN 值上定义的，但是 IEEE 754 totalOrder 将 NaN 值也定义为遵循位顺序。这导致了文档注释中解释的顺序。
        // 但是，对于负数和正数，幅值的表示是相同的 - 仅符号位不同。
        // 为了轻松地将浮点数与带符号整数进行比较，在负数的情况下，我们需要翻转指数位和尾数位。
        // 我们将数字有效地转换为 "二进制补码" 的形式。
        //
        // 为了进行翻转，我们构造了一个掩码并对它进行 XOR。
        // 我们从负号值无分支地计算 "除符号位之外的全 1" 掩码: 右移符号以扩展整数，因此我们用符号位 "fill" 掩码，然后转换为无符号以压入另一个零位。
        //
        // 如果为正值，则掩码全为零，因此是空操作。
        //
        //
        //
        //
        //
        //
        //
        //
        //
        left ^= (((left >> 63) as u64) >> 1) as i64;
        right ^= (((right >> 63) as u64) >> 1) as i64;

        left.cmp(&right)
    }

    /// 除非是 NaN，否则将值限制为一定的时间间隔。
    ///
    /// 如果 `self` 大于 `max`，则返回 `max`; 如果 `self` 小于 `min`，则返回 `min`。
    /// 否则，将返回 `self`。
    ///
    /// 请注意，如果初始值也为 NaN，则此函数将返回 NaN。
    ///
    /// # Panics
    ///
    /// 如果 `min > max`，`min` 为 NaN 或 `max` 为 NaN，就会出现 panics。
    ///
    /// # Examples
    ///
    /// ```
    /// assert!((-3.0f64).clamp(-2.0, 1.0) == -2.0);
    /// assert!((0.0f64).clamp(-2.0, 1.0) == 0.0);
    /// assert!((2.0f64).clamp(-2.0, 1.0) == 1.0);
    /// assert!((f64::NAN).clamp(-2.0, 1.0).is_nan());
    /// ```
    ///
    #[must_use = "method returns a new number and does not mutate the original value"]
    #[stable(feature = "clamp", since = "1.50.0")]
    #[inline]
    pub fn clamp(mut self, min: f64, max: f64) -> f64 {
        assert!(min <= max, "min > max, or either was NaN. min = {min:?}, max = {max:?}");
        if self < min {
            self = min;
        }
        if self > max {
            self = max;
        }
        self
    }
}