Primitive Type f64

1.0.0 ·
Expand description

64 位浮点类型 (特别是 IEEE 754-2008 中定义的 “binary64” 类型)。

此类型与 f32 非常相似,但是通过使用两倍的位来提高精度。 请参见 f32 的文档或关于双精度值的 维基百科 了解更多信息。

See also the std::f64::consts module.

Implementations§

source§

impl f64

1.43.0 · source

pub const RADIX: u32 = 2u32

f64 内部表示形式的基数或基数。

1.43.0 · source

pub const MANTISSA_DIGITS: u32 = 53u32

基数中的有效位数 2.

1.43.0 · source

pub const DIGITS: u32 = 15u32

以 10 为基数的有效位数的大概数字。

1.43.0 · source

pub const EPSILON: f64 = 2.2204460492503131E-16f64

f64机器精度 值。

这是 1.0 与下一个较大的可表示数字之间的差异。

1.43.0 · source

pub const MIN: f64 = -1.7976931348623157E+308f64

最小的 f64 有限值。

1.43.0 · source

pub const MIN_POSITIVE: f64 = 2.2250738585072014E-308f64

最小正 f64 正值。

1.43.0 · source

pub const MAX: f64 = 1.7976931348623157E+308f64

最大的有限 f64 值。

1.43.0 · source

pub const MIN_EXP: i32 = -1_021i32

比 2 的最小可能标准幂大一。

1.43.0 · source

pub const MAX_EXP: i32 = 1_024i32

2 指数的最大可能乘方。

1.43.0 · source

pub const MIN_10_EXP: i32 = -307i32

最小可能的标准幂为 10 指数。

1.43.0 · source

pub const MAX_10_EXP: i32 = 308i32

最大可能功效为 10 指数。

1.43.0 · source

pub const NAN: f64 = NaNf64

不是数字 (NaN)。

请注意,IEEE 754 不只定义一个 NaN 值; 过多的位模式被认为是 NaN。 此外,该标准区分了 “signaling” 和 “quiet” NaN,并允许检查其 “payload” (位模式中未指定的位)。 不保证此特性等于任何特定的 NaN 位模式,并且不保证其表示在 Rust 版本和目标平台上的稳定性。

1.43.0 · source

pub const INFINITY: f64 = +Inff64

无限 (∞)。

1.43.0 · source

pub const NEG_INFINITY: f64 = -Inff64

负无穷大 (−∞)。

const: unstable · source

pub fn is_nan(self) -> bool

如果此值为 NaN,则返回 true

let nan = f64::NAN;
let f = 7.0_f64;

assert!(nan.is_nan());
assert!(!f.is_nan());
Run
const: unstable · source

pub fn is_infinite(self) -> bool

如果此值是正无穷大或负无穷大,则返回 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());
Run
const: unstable · source

pub fn is_finite(self) -> bool

如果此数字既不是无穷大也不是 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());
Run
1.53.0 (const: unstable) · source

pub fn is_subnormal(self) -> bool

如果数字为 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());
Run
const: unstable · source

pub fn is_normal(self) -> bool

如果数字既不是零、无穷大、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());
Run
const: unstable · source

pub fn classify(self) -> FpCategory

返回数字的浮点类别。 如果仅要测试一个属性,则通常使用特定谓词会更快。

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);
Run
const: unstable · source

pub fn is_sign_positive(self) -> bool

如果 self 有正号,则返回 true,包括 +0.0、带正号位的 NaN 和正无穷大。 请注意,在 NaN 的情况下,IEEE 754 不会为符号位分配任何含义,并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变,因此 is_sign_positive 对 NaN 的结果可能会产生意外在某些情况下导致。

有关详细信息,请参见 将 NaN 解释为特殊值

let f = 7.0_f64;
let g = -7.0_f64;

assert!(f.is_sign_positive());
assert!(!g.is_sign_positive());
Run
const: unstable · source

pub fn is_sign_negative(self) -> bool

如果 self 具有 negative 符号,则返回 true,包括 -0.0、具有 negative 符号位的 NaN 和 negative 无穷大。 请注意,在 NaN 的情况下,IEEE 754 不会为符号位分配任何含义,并且由于 Rust 不保证 NaN 的位模式在算术运算中保持不变,因此 is_sign_negative 对 NaN 的结果可能会产生意外在某些情况下导致。

有关详细信息,请参见 将 NaN 解释为特殊值

let f = 7.0_f64;
let g = -7.0_f64;

assert!(!f.is_sign_negative());
assert!(g.is_sign_negative());
Run
const: unstable · source

pub fn next_up(self) -> Self

🔬This is a nightly-only experimental API. (float_next_up_down #91399)

返回大于 self 的最小数字。

TINY 为可表示的最小正 f64。 Then,

  • 如果是 self.is_nan(),则返回 self;
  • 如果 selfNEG_INFINITY,则返回 MIN;
  • 如果 self-TINY,则返回 - 0.0;
  • 如果 self 为 - 0.0 或 + 0.0,则返回 TINY;
  • 如果 selfMAXINFINITY,则返回 INFINITY;
  • 否则返回大于 self 的唯一最小值。

恒等式 x.next_up() == -(-x).next_down() 适用于所有非 NaN x。当 x 为有限时,x == x.next_up().next_down() 也成立。

#![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);
Run
const: unstable · source

pub fn next_down(self) -> Self

🔬This is a nightly-only experimental API. (float_next_up_down #91399)

返回小于 self 的最大数。

TINY 为可表示的最小正 f64。 Then,

  • 如果是 self.is_nan(),则返回 self;
  • 如果 selfINFINITY,则返回 MAX;
  • 如果 selfTINY,则返回 0.0;
  • 如果 self 为 - 0.0 或 + 0.0,则返回 -TINY;
  • 如果 selfMINNEG_INFINITY,则返回 NEG_INFINITY;
  • 否则返回小于 self 的唯一最大值。

恒等式 x.next_down() == -(-x).next_up() 适用于所有非 NaN x。当 x 为有限时,x == x.next_down().next_up() 也成立。

#![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);
Run
source

pub fn recip(self) -> f64

取一个数 1/x 的倒数 (inverse)。

let x = 2.0_f64;
let abs_difference = (x.recip() - (1.0 / x)).abs();

assert!(abs_difference < 1e-10);
Run
source

pub fn to_degrees(self) -> f64

将弧度转换为度数。

let angle = std::f64::consts::PI;

let abs_difference = (angle.to_degrees() - 180.0).abs();

assert!(abs_difference < 1e-10);
Run
source

pub fn to_radians(self) -> f64

将度数转换为弧度。

let angle = 180.0_f64;

let abs_difference = (angle.to_radians() - std::f64::consts::PI).abs();

assert!(abs_difference < 1e-10);
Run
source

pub fn max(self, other: f64) -> f64

返回两个数字中的最大值,忽略 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);
Run
source

pub fn min(self, other: f64) -> f64

返回两个数字中的最小值,忽略 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);
Run
source

pub fn maximum(self, other: f64) -> f64

🔬This is a nightly-only experimental API. (float_minimum_maximum #91079)

返回两个数字中的最大值,传播 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());
Run

如果参数之一是 NaN,则返回 NaN。否则,这将返回两个数字中较大的一个。对于此操作,-0.0 被认为小于 +0.0。 请注意,这遵循 IEEE 754-2019 中指定的语义。

另请注意,此处 NaN 的 “propagation” 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息,请参见 将 NaN 解释为特殊值

source

pub fn minimum(self, other: f64) -> f64

🔬This is a nightly-only experimental API. (float_minimum_maximum #91079)

返回两个数字中的最小值,传播 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());
Run

如果参数之一是 NaN,则返回 NaN。否则,这将返回两个数字中的较小者。对于此操作,-0.0 被认为小于 +0.0。 请注意,这遵循 IEEE 754-2019 中指定的语义。

另请注意,此处 NaN 的 “propagation” 并不一定意味着 NaN 操作数的位模式是守恒的; 有关详细信息,请参见 将 NaN 解释为特殊值

source

pub fn midpoint(self, other: f64) -> f64

🔬This is a nightly-only experimental API. (num_midpoint #110840)

计算 selfrhs 的中点。

当 * 参数为 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);
Run
1.44.0 · source

pub unsafe fn to_int_unchecked<Int>(self) -> Intwhere Self: FloatToInt<Int>,

舍入为零并转换为任何原始整数类型,前提是该值是有限的并且适合该类型。

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);
Run
Safety

该值必须:

  • 不是 NaN
  • 不是无限的
  • 截断小数部分后,可以在返回类型 Int 中表示
1.20.0 (const: unstable) · source

pub fn to_bits(self) -> u64

原始 trans 变为 u64

当前,这与所有平台上的 transmute::<f64, u64>(self) 相同。

有关此操作的可移植性的一些讨论,请参见 from_bits (几乎没有问题)。

请注意,此函数与 as 强制转换不同,后者试图保留 数字 值,而不是按位值。

Examples
assert!((1f64).to_bits() != 1f64 as u64); // to_bits() 不是 casting!
assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
Run
1.20.0 (const: unstable) · source

pub fn from_bits(v: u64) -> Self

来自 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);
Run
1.40.0 (const: unstable) · source

pub fn to_be_bytes(self) -> [u8; 8]

以大端 (网络) 字节顺序的字节数组形式返回此浮点数的内存表示形式。

有关此操作的可移植性的一些讨论,请参见 from_bits (几乎没有问题)。

Examples
let bytes = 12.5f64.to_be_bytes();
assert_eq!(bytes, [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
Run
1.40.0 (const: unstable) · source

pub fn to_le_bytes(self) -> [u8; 8]

以小字节序字节顺序将浮点数的内存表示形式返回为字节数组。

有关此操作的可移植性的一些讨论,请参见 from_bits (几乎没有问题)。

Examples
let bytes = 12.5f64.to_le_bytes();
assert_eq!(bytes, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
Run
1.40.0 (const: unstable) · source

pub fn to_ne_bytes(self) -> [u8; 8]

返回此浮点数的内存表示形式,以原生字节顺序的字节数组形式。

由于使用了目标平台的原生字节序,因此,可移植代码应酌情使用 to_be_bytesto_le_bytes

有关此操作的可移植性的一些讨论,请参见 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]
    }
);
Run
1.40.0 (const: unstable) · source

pub fn from_be_bytes(bytes: [u8; 8]) -> Self

从其表示形式以 big endian 的字节数组创建一个浮点值。

有关此操作的可移植性的一些讨论,请参见 from_bits (几乎没有问题)。

Examples
let value = f64::from_be_bytes([0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
assert_eq!(value, 12.5);
Run
1.40.0 (const: unstable) · source

pub fn from_le_bytes(bytes: [u8; 8]) -> Self

从它的表示形式以 Little Endian 的字节数组创建一个浮点值。

有关此操作的可移植性的一些讨论,请参见 from_bits (几乎没有问题)。

Examples
let value = f64::from_le_bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
assert_eq!(value, 12.5);
Run
1.40.0 (const: unstable) · source

pub fn from_ne_bytes(bytes: [u8; 8]) -> Self

从其表示形式 (以原生字节序形式的字节数组形式) 创建浮点值。

由于使用了目标平台的原生字节序,因此可移植代码可能希望酌情使用 from_be_bytesfrom_le_bytes

有关此操作的可移植性的一些讨论,请参见 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);
Run
1.62.0 · source

pub fn total_cmp(&self, other: &Self) -> Ordering

返回 selfother 之间的顺序。

与浮点数之间的标准部分比较不同,此比较始终根据 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.

这个函数建立的顺序并不总是与 f64PartialOrdPartialEq 实现一致。 例如,他们认为负零和正零相等,而 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));
Run
1.50.0 · source

pub fn clamp(self, min: f64, max: f64) -> f64

除非是 NaN,否则将值限制为一定的时间间隔。

如果 self 大于 max,则返回 max; 如果 self 小于 min,则返回 min。 否则,将返回 self

请注意,如果初始值也为 NaN,则此函数将返回 NaN。

Panics

如果 min > maxmin 为 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());
Run

Trait Implementations§

source§

impl Add<&f64> for &f64

§

type Output = <f64 as Add<f64>>::Output

应用 + 运算符后的结果类型。
source§

fn add(self, other: &f64) -> <f64 as Add<f64>>::Output

执行 + 操作。 Read more
source§

impl Add<&f64> for f64

§

type Output = <f64 as Add<f64>>::Output

应用 + 运算符后的结果类型。
source§

fn add(self, other: &f64) -> <f64 as Add<f64>>::Output

执行 + 操作。 Read more
source§

impl<'a> Add<f64> for &'a f64

§

type Output = <f64 as Add<f64>>::Output

应用 + 运算符后的结果类型。
source§

fn add(self, other: f64) -> <f64 as Add<f64>>::Output

执行 + 操作。 Read more
source§

impl Add<f64> for f64

§

type Output = f64

应用 + 运算符后的结果类型。
source§

fn add(self, other: f64) -> f64

执行 + 操作。 Read more
1.22.0 · source§

impl AddAssign<&f64> for f64

source§

fn add_assign(&mut self, other: &f64)

执行 += 操作。 Read more
1.8.0 · source§

impl AddAssign<f64> for f64

source§

fn add_assign(&mut self, other: f64)

执行 += 操作。 Read more
source§

impl Clone for f64

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, source: &Self)

source 执行复制分配。 Read more
source§

impl Debug for f64

source§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
source§

impl Default for f64

source§

fn default() -> f64

Returns the default value of 0.0

source§

impl Display for f64

source§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
source§

impl Div<&f64> for &f64

§

type Output = <f64 as Div<f64>>::Output

应用 / 运算符后的结果类型。
source§

fn div(self, other: &f64) -> <f64 as Div<f64>>::Output

执行 / 操作。 Read more
source§

impl Div<&f64> for f64

§

type Output = <f64 as Div<f64>>::Output

应用 / 运算符后的结果类型。
source§

fn div(self, other: &f64) -> <f64 as Div<f64>>::Output

执行 / 操作。 Read more
source§

impl<'a> Div<f64> for &'a f64

§

type Output = <f64 as Div<f64>>::Output

应用 / 运算符后的结果类型。
source§

fn div(self, other: f64) -> <f64 as Div<f64>>::Output

执行 / 操作。 Read more
source§

impl Div<f64> for f64

§

type Output = f64

应用 / 运算符后的结果类型。
source§

fn div(self, other: f64) -> f64

执行 / 操作。 Read more
1.22.0 · source§

impl DivAssign<&f64> for f64

source§

fn div_assign(&mut self, other: &f64)

执行 /= 操作。 Read more
1.8.0 · source§

impl DivAssign<f64> for f64

source§

fn div_assign(&mut self, other: f64)

执行 /= 操作。 Read more
1.68.0 · source§

impl From<bool> for f64

source§

fn from(small: bool) -> Self

无损地将 bool 转换为 f64false 的结果值为正 0.0true 值为 1.0

Examples
let x: f64 = false.into();
assert_eq!(x, 0.0);
assert!(x.is_sign_positive());

let y: f64 = true.into();
assert_eq!(y, 1.0);
Run
1.6.0 · source§

impl From<f32> for f64

source§

fn from(small: f32) -> Self

Converts f32 to f64 losslessly.

1.6.0 · source§

impl From<i16> for f64

source§

fn from(small: i16) -> Self

Converts i16 to f64 losslessly.

1.6.0 · source§

impl From<i32> for f64

source§

fn from(small: i32) -> Self

Converts i32 to f64 losslessly.

1.6.0 · source§

impl From<i8> for f64

source§

fn from(small: i8) -> Self

Converts i8 to f64 losslessly.

1.6.0 · source§

impl From<u16> for f64

source§

fn from(small: u16) -> Self

Converts u16 to f64 losslessly.

1.6.0 · source§

impl From<u32> for f64

source§

fn from(small: u32) -> Self

Converts u32 to f64 losslessly.

1.6.0 · source§

impl From<u8> for f64

source§

fn from(small: u8) -> Self

Converts u8 to f64 losslessly.

source§

impl FromStr for f64

source§

fn from_str(src: &str) -> Result<Self, ParseFloatError>

将以 10 为底的字符串转换为浮点数。 接受可选的十进制指数。

该函数接受诸如以下的字符串

  • ‘3.14’
  • ‘-3.14’
  • ‘2.5E10’,或等效的 ‘2.5e10’
  • ‘2.5E-10’
  • ‘5.’
  • ‘.5’,或等效地,‘0.5’
  • ‘inf’, ‘-inf’, ‘+infinity’, ‘NaN’

请注意,字母字符不区分大小写。

前导和尾随空格表示错误。

Grammar

小写时遵循以下 EBNF 语法的所有字符串都将返回 Ok:

Float  ::= Sign? ( 'inf' | 'infinity' | 'nan' | Number )
Number ::= ( Digit+ |
             Digit+ '.' Digit* |
             Digit* '.' Digit+ ) Exp?
Exp    ::= 'e' Sign? Digit+
Sign   ::= [+-]
Digit  ::= [0-9]
Arguments
  • src - 字符串
返回值

Err(ParseFloatError) 如果字符串不代表有效数字。 否则,Ok(n),其中 n 是与 src 表示的数字最接近的可表示浮点数 (遵循与原始运算结果相同的舍入规则)。

§

type Err = ParseFloatError

可以从解析中返回的相关错误。
source§

impl LowerExp for f64

source§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。
source§

impl Mul<&f64> for &f64

§

type Output = <f64 as Mul<f64>>::Output

应用 * 运算符后的结果类型。
source§

fn mul(self, other: &f64) -> <f64 as Mul<f64>>::Output

执行 * 操作。 Read more
source§

impl Mul<&f64> for f64

§

type Output = <f64 as Mul<f64>>::Output

应用 * 运算符后的结果类型。
source§

fn mul(self, other: &f64) -> <f64 as Mul<f64>>::Output

执行 * 操作。 Read more
source§

impl<'a> Mul<f64> for &'a f64

§

type Output = <f64 as Mul<f64>>::Output

应用 * 运算符后的结果类型。
source§

fn mul(self, other: f64) -> <f64 as Mul<f64>>::Output

执行 * 操作。 Read more
source§

impl Mul<f64> for f64

§

type Output = f64

应用 * 运算符后的结果类型。
source§

fn mul(self, other: f64) -> f64

执行 * 操作。 Read more
1.22.0 · source§

impl MulAssign<&f64> for f64

source§

fn mul_assign(&mut self, other: &f64)

执行 *= 操作。 Read more
1.8.0 · source§

impl MulAssign<f64> for f64

source§

fn mul_assign(&mut self, other: f64)

执行 *= 操作。 Read more
source§

impl Neg for &f64

§

type Output = <f64 as Neg>::Output

应用 - 运算符后的结果类型。
source§

fn neg(self) -> <f64 as Neg>::Output

执行一元 - 运算。 Read more
source§

impl Neg for f64

§

type Output = f64

应用 - 运算符后的结果类型。
source§

fn neg(self) -> f64

执行一元 - 运算。 Read more
source§

impl PartialEq<f64> for f64

source§

fn eq(&self, other: &f64) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &f64) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialOrd<f64> for f64

source§

fn partial_cmp(&self, other: &f64) -> Option<Ordering>

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

fn lt(&self, other: &f64) -> bool

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

fn le(&self, other: &f64) -> bool

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

fn ge(&self, other: &f64) -> bool

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
source§

fn gt(&self, other: &f64) -> bool

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
1.12.0 · source§

impl<'a> Product<&'a f64> for f64

source§

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self
1.12.0 · source§

impl Product<f64> for f64

source§

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self
source§

impl Rem<&f64> for &f64

§

type Output = <f64 as Rem<f64>>::Output

应用 % 运算符后的结果类型。
source§

fn rem(self, other: &f64) -> <f64 as Rem<f64>>::Output

执行 % 操作。 Read more
source§

impl Rem<&f64> for f64

§

type Output = <f64 as Rem<f64>>::Output

应用 % 运算符后的结果类型。
source§

fn rem(self, other: &f64) -> <f64 as Rem<f64>>::Output

执行 % 操作。 Read more
source§

impl<'a> Rem<f64> for &'a f64

§

type Output = <f64 as Rem<f64>>::Output

应用 % 运算符后的结果类型。
source§

fn rem(self, other: f64) -> <f64 as Rem<f64>>::Output

执行 % 操作。 Read more
source§

impl Rem<f64> for f64

其余部分来自两个彩车的划分。

余数与被除数同号,计算公式为: x - (x / y).trunc() * y

Examples

let x: f32 = 50.50;
let y: f32 = 8.125;
let remainder = x - (x / y).trunc() * y;

// 这两种操作的答案都是 1.75
assert_eq!(x % y, remainder);
Run
§

type Output = f64

应用 % 运算符后的结果类型。
source§

fn rem(self, other: f64) -> f64

执行 % 操作。 Read more
1.22.0 · source§

impl RemAssign<&f64> for f64

source§

fn rem_assign(&mut self, other: &f64)

执行 %= 操作。 Read more
1.8.0 · source§

impl RemAssign<f64> for f64

source§

fn rem_assign(&mut self, other: f64)

执行 %= 操作。 Read more
source§

impl SimdElement for f64

§

type Mask = i64

🔬This is a nightly-only experimental API. (portable_simd #86656)
此元素类型对应的掩码元素类型。
source§

impl Sub<&f64> for &f64

§

type Output = <f64 as Sub<f64>>::Output

应用 - 运算符后的结果类型。
source§

fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output

执行 - 操作。 Read more
source§

impl Sub<&f64> for f64

§

type Output = <f64 as Sub<f64>>::Output

应用 - 运算符后的结果类型。
source§

fn sub(self, other: &f64) -> <f64 as Sub<f64>>::Output

执行 - 操作。 Read more
source§

impl<'a> Sub<f64> for &'a f64

§

type Output = <f64 as Sub<f64>>::Output

应用 - 运算符后的结果类型。
source§

fn sub(self, other: f64) -> <f64 as Sub<f64>>::Output

执行 - 操作。 Read more
source§

impl Sub<f64> for f64

§

type Output = f64

应用 - 运算符后的结果类型。
source§

fn sub(self, other: f64) -> f64

执行 - 操作。 Read more
1.22.0 · source§

impl SubAssign<&f64> for f64

source§

fn sub_assign(&mut self, other: &f64)

执行 -= 操作。 Read more
1.8.0 · source§

impl SubAssign<f64> for f64

source§

fn sub_assign(&mut self, other: f64)

执行 -= 操作。 Read more
1.12.0 · source§

impl<'a> Sum<&'a f64> for f64

source§

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
1.12.0 · source§

impl Sum<f64> for f64

source§

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。
source§

impl UpperExp for f64

source§

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。
source§

impl Copy for f64

source§

impl FloatToInt<i128> for f64

source§

impl FloatToInt<i16> for f64

source§

impl FloatToInt<i32> for f64

source§

impl FloatToInt<i64> for f64

source§

impl FloatToInt<i8> for f64

source§

impl FloatToInt<isize> for f64

source§

impl FloatToInt<u128> for f64

source§

impl FloatToInt<u16> for f64

source§

impl FloatToInt<u32> for f64

source§

impl FloatToInt<u64> for f64

source§

impl FloatToInt<u8> for f64

source§

impl FloatToInt<usize> for f64

source§

impl SimdCast for f64

Auto Trait Implementations§

§

impl RefUnwindSafe for f64

§

impl Send for f64

§

impl Sync for f64

§

impl Unpin for f64

§

impl UnwindSafe for f64

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。