Примитивный тип f64
64-битный тип с плавающей запятой (конкретно тип "binary64", определённый в IEEE 754-2008).
Этот тип очень похож на f32, но имеет повышенную точность за счёт использования вдвое большего количества битов.
Константы
| Константа | Значение | Описание |
|---|---|---|
RADIX | 2u32 | Основание системы счисления внутреннего представления. |
MANTISSA_DIGITS | 53u32 | Количество значащих цифр в системе счисления с основанием 2. |
DIGITS | 15u32 | Приблизительное количество значащих цифр в десятичной системе счисления. |
EPSILON | 2.2204460492503131E-16f64 | Машинное эпсилон для f64. |
MIN | -1.7976931348623157E+308f64 | Наименьшее конечное значение f64. |
MIN_POSITIVE | 2.2250738585072014E-308f64 | Наименьшее положительное нормализованное значение f64. |
MAX | 1.7976931348623157E+308f64 | Наибольшее конечное значение f64. |
MIN_EXP | -1021i32 | Минимальная возможная нормальная степень двойки. |
MAX_EXP | 1024i32 | Максимальная возможная степень двойки. |
MIN_10_EXP | -307i32 | Минимальный x, для которого 10^x является нормальным. |
MAX_10_EXP | 308i32 | Максимальный x, для которого 10^x является нормальным. |
NAN | NaN_f64 | Не число (NaN). |
INFINITY | +Inf_f64 | Бесконечность (∞). |
NEG_INFINITY | -Inf_f64 | Отрицательная бесконечность (−∞). |
Методы
Основные математические операции
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
floor(self) -> f64 | Возвращает наибольшее целое число, меньшее или равное self. | 1.90.0 | 1.0.0 | assert_eq!(3.7_f64.floor(), 3.0); |
ceil(self) -> f64 | Возвращает наименьшее целое число, большее или равное self. | 1.90.0 | 1.0.0 | assert_eq!(3.01_f64.ceil(), 4.0); |
round(self) -> f64 | Возвращает ближайшее целое число к self. | 1.90.0 | 1.0.0 | assert_eq!(3.3_f64.round(), 3.0); |
round_ties_even(self) -> f64 | Возвращает ближайшее целое число к числу. Половинные случаи округляются к числу с чётной младшей цифрой. | 1.90.0 | 1.77.0 | assert_eq!(3.5_f64.round_ties_even(), 4.0); |
trunc(self) -> f64 | Возвращает целую часть self. | 1.90.0 | 1.0.0 | assert_eq!(3.7_f64.trunc(), 3.0); |
fract(self) -> f64 | Возвращает дробную часть self. | 1.90.0 | 1.0.0 | let x = 3.6_f64; assert!(x.fract() - 0.6).abs() < 1e-10); |
mul_add(self, a: f64, b: f64) -> f64 | Точное умножение-сложение. Вычисляет (self * a) + b с одной ошибкой округления. | - | 1.0.0 | assert_eq!(10.0_f64.mul_add(4.0, 60.0), 100.0); |
div_euclid(self, rhs: f64) -> f64 | Вычисляет евклидово деление. | - | 1.38.0 | assert_eq!(7.0_f64.div_euclid(4.0), 1.0); |
rem_euclid(self, rhs: f64) -> f64 | Вычисляет наименьший неотрицательный остаток от деления self на rhs. | - | 1.38.0 | assert_eq!(7.0_f64.rem_euclid(4.0), 3.0); |
powi(self, n: i32) -> f64 | Возводит число в целую степень. | - | 1.0.0 | assert_eq!(2.0_f64.powi(2), 4.0); |
powf(self, n: f64) -> f64 | Возводит число в степень с плавающей запятой. | - | 1.0.0 | assert_eq!(2.0_f64.powf(2.0), 4.0); |
sqrt(self) -> f64 | Возвращает квадратный корень числа. | - | 1.0.0 | assert_eq!(4.0_f64.sqrt(), 2.0); |
exp(self) -> f64 | Возвращает e^(self) (экспоненциальная функция). | - | 1.0.0 | let e = 1.0_f64.exp(); |
exp2(self) -> f64 | Возвращает 2^(self). | - | 1.0.0 | assert_eq!(2.0_f64.exp2(), 4.0); |
ln(self) -> f64 | Возвращает натуральный логарифм числа. | - | 1.0.0 | let e = 1.0_f64.exp(); assert!(e.ln() - 1.0).abs() < 1e-10); |
log(self, base: f64) -> f64 | Возвращает логарифм числа по произвольному основанию. | - | 1.0.0 | assert_eq!(25.0_f64.log(5.0), 2.0); |
log2(self) -> f64 | Возвращает логарифм числа по основанию 2. | - | 1.0.0 | assert_eq!(4.0_f64.log2(), 2.0); |
log10(self) -> f64 | Возвращает логарифм числа по основанию 10. | - | 1.0.0 | assert_eq!(100.0_f64.log10(), 2.0); |
cbrt(self) -> f64 | Возвращает кубический корень числа. | - | 1.0.0 | assert_eq!(8.0_f64.cbrt(), 2.0); |
hypot(self, other: f64) -> f64 | Вычисляет расстояние между началом координат и точкой (x, y) на евклидовой плоскости. | - | 1.0.0 | assert_eq!(3.0_f64.hypot(4.0), 5.0); |
sin(self) -> f64 | Вычисляет синус числа (в радианах). | - | 1.0.0 | assert_eq!(std::f64::consts::FRAC_PI_2.sin(), 1.0); |
cos(self) -> f64 | Вычисляет косинус числа (в радианах). | - | 1.0.0 | assert_eq!((2.0 * std::f64::consts::PI).cos(), 1.0); |
tan(self) -> f64 | Вычисляет тангенс числа (в радианах). | - | 1.0.0 | assert_eq!(std::f64::consts::FRAC_PI_4.tan(), 1.0); |
asin(self) -> f64 | Вычисляет арксинус числа. Возвращаемое значение в радианах в диапазоне [-π/2, π/2]. | - | 1.0.0 | assert_eq!(1.0_f64.asin(), std::f64::consts::FRAC_PI_2); |
acos(self) -> f64 | Вычисляет арккосинус числа. Возвращаемое значение в радианах в диапазоне [0, π]. | - | 1.0.0 | assert_eq!(1.0_f64.acos(), 0.0); |
atan(self) -> f64 | Вычисляет арктангенс числа. Возвращаемое значение в радианах в диапазоне [-π/2, π/2]. | - | 1.0.0 | assert_eq!(1.0_f64.atan(), std::f64::consts::FRAC_PI_4); |
atan2(self, other: f64) -> f64 | Вычисляет арктангенс self (y) и other (x) в радианах с учётом квадранта. | - | 1.0.0 | assert_eq!(1.0_f64.atan2(1.0), std::f64::consts::FRAC_PI_4); |
sin_cos(self) -> (f64, f64) | Одновременно вычисляет синус и косинус числа. | - | 1.0.0 | let (sin, cos) = std::f64::consts::FRAC_PI_4.sin_cos(); |
exp_m1(self) -> f64 | Возвращает e^(self) - 1 точно даже для чисел, близких к нулю. | - | 1.0.0 | let x = 1e-16_f64; let approx = x + x * x / 2.0; |
ln_1p(self) -> f64 | Возвращает ln(1+n) (натуральный логарифм) точнее, чем при раздельном выполнении операций. | - | 1.0.0 | let x = 1e-16_f64; let approx = x - x * x / 2.0; |
sinh(self) -> f64 | Гиперболический синус. | - | 1.0.0 | let e = std::f64::consts::E; let x = 1.0_f64; |
cosh(self) -> f64 | Гиперболический косинус. | - | 1.0.0 | let e = std::f64::consts::E; let x = 1.0_f64; |
tanh(self) -> f64 | Гиперболический тангенс. | - | 1.0.0 | let e = std::f64::consts::E; let x = 1.0_f64; |
asinh(self) -> f64 | Обратный гиперболический синус. | - | 1.0.0 | assert_eq!(1.0_f64.sinh().asinh(), 1.0); |
acosh(self) -> f64 | Обратный гиперболический косинус. | - | 1.0.0 | assert_eq!(1.0_f64.cosh().acosh(), 1.0); |
atanh(self) -> f64 | Обратный гиперболический тангенс. | - | 1.0.0 | assert_eq!(std::f64::consts::FRAC_PI_6.tanh().atanh(), std::f64::consts::FRAC_PI_6); |
gamma(self) -> f64 | Гамма-функция. (экспериментальный) | - | Nightly | assert_eq!(5.0f64.gamma(), 24.0); |
ln_gamma(self) -> (f64, i32) | Натуральный логарифм абсолютного значения гамма-функции. (экспериментальный) | - | Nightly | assert_eq!(2.0f64.ln_gamma().0, 0.0); |
erf(self) -> f64 | Функция ошибок. (экспериментальный) | - | Nightly | let erf = (1.0 * std::f64::consts::FRAC_1_SQRT_2).erf(); |
erfc(self) -> f64 | Дополнительная функция ошибок. (экспериментальный) | - | Nightly | let x: f64 = 0.123; let one = x.erf() + x.erfc(); |
Проверка свойств чисел
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
is_nan(self) -> bool | Возвращает true, если значение равно NaN. | 1.83.0 | 1.0.0 | assert!(f64::NAN.is_nan()); |
is_infinite(self) -> bool | Возвращает true, если значение является положительной или отрицательной бесконечностью. | 1.83.0 | 1.0.0 | assert!(f64::INFINITY.is_infinite()); |
is_finite(self) -> bool | Возвращает true, если число не является ни бесконечностью, ни NaN. | 1.83.0 | 1.0.0 | assert!(7.0f64.is_finite()); |
is_subnormal(self) -> bool | Возвращает true, если число субнормальное. | 1.83.0 | 1.53.0 | assert!(1.0e-308_f64.is_subnormal()); |
is_normal(self) -> bool | Возвращает true, если число не является ни нулём, ни бесконечностью, ни субнормальным, ни NaN. | 1.83.0 | 1.0.0 | assert!(f64::MIN_POSITIVE.is_normal()); |
classify(self) -> FpCategory | Возвращает категорию числа с плавающей запятой. | 1.83.0 | 1.0.0 | assert_eq!(12.4_f64.classify(), FpCategory::Normal); |
is_sign_positive(self) -> bool | Возвращает true, если self имеет положительный знак. | 1.83.0 | 1.0.0 | assert!(7.0_f64.is_sign_positive()); |
is_sign_negative(self) -> bool | Возвращает true, если self имеет отрицательный знак. | 1.83.0 | 1.0.0 | assert!((-7.0_f64).is_sign_negative()); |
Соседние значения и преобразования
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
next_up(self) -> f64 | Возвращает наименьшее число, большее self. | 1.86.0 | 1.86.0 | assert_eq!(1.0f64.next_up(), 1.0 + f64::EPSILON); |
next_down(self) -> f64 | Возвращает наибольшее число, меньшее self. | 1.86.0 | 1.86.0 | assert_eq!(1.0f64.next_down(), 1.0 - f64::EPSILON); |
recip(self) -> f64 | Вычисляет обратное значение числа, 1/x. | 1.85.0 | 1.0.0 | assert_eq!(2.0_f64.recip(), 0.5); |
to_degrees(self) -> f64 | Преобразует радианы в градусы. | 1.85.0 | 1.0.0 | assert_eq!(std::f64::consts::PI.to_degrees(), 180.0); |
to_radians(self) -> f64 | Преобразует градусы в радианы. | 1.85.0 | 1.0.0 | assert_eq!(180.0_f64.to_radians(), std::f64::consts::PI); |
max(self, other: f64) -> f64 | Возвращает максимум двух чисел, игнорируя NaN. | 1.85.0 | 1.0.0 | assert_eq!(1.0_f64.max(2.0), 2.0); |
min(self, other: f64) -> f64 | Возвращает минимум двух чисел, игнорируя NaN. | 1.85.0 | 1.0.0 | assert_eq!(1.0_f64.min(2.0), 1.0); |
maximum(self, other: f64) -> f64 | Возвращает максимум двух чисел, распространяя NaN. (экспериментальный) | - | Nightly | assert_eq!(1.0_f64.maximum(2.0), 2.0); |
minimum(self, other: f64) -> f64 | Возвращает минимум двух чисел, распространяя NaN. (экспериментальный) | - | Nightly | assert_eq!(1.0_f64.minimum(2.0), 1.0); |
midpoint(self, other: f64) -> f64 | Вычисляет среднюю точку (среднее арифметическое) между self и rhs. | 1.85.0 | 1.85.0 | assert_eq!(1.0f64.midpoint(4.0), 2.5); |
to_int_unchecked<Int>(self) -> Int | Округляет к нулю и преобразует в любой примитивный целочисленный тип. | - | 1.44.0 | unsafe { assert_eq!(4.6_f64.to_int_unchecked::<u16>(), 4); } |
Работа с битовым представлением
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
to_bits(self) -> u64 | Прямое преобразование в u64. | 1.83.0 | 1.20.0 | assert_eq!((12.5f64).to_bits(), 0x4029000000000000); |
from_bits(v: u64) -> f64 | Прямое преобразование из u64. | 1.83.0 | 1.20.0 | assert_eq!(f64::from_bits(0x4029000000000000), 12.5); |
to_be_bytes(self) -> [u8; 8] | Возвращает представление числа в памяти в виде массива байтов в порядке big-endian. | 1.83.0 | 1.40.0 | let bytes = 12.5f64.to_be_bytes(); |
to_le_bytes(self) -> [u8; 8] | Возвращает представление числа в памяти в виде массива байтов в порядке little-endian. | 1.83.0 | 1.40.0 | let bytes = 12.5f64.to_le_bytes(); |
to_ne_bytes(self) -> [u8; 8] | Возвращает представление числа в памяти в виде массива байтов в порядке байтов целевой платформы. | 1.83.0 | 1.40.0 | let bytes = 12.5f64.to_ne_bytes(); |
from_be_bytes(bytes: [u8; 8]) -> f64 | Создаёт число из его представления в виде массива байтов в порядке big-endian. | 1.83.0 | 1.40.0 | let value = f64::from_be_bytes([0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]); |
from_le_bytes(bytes: [u8; 8]) -> f64 | Создаёт число из его представления в виде массива байтов в порядке little-endian. | 1.83.0 | 1.40.0 | let value = f64::from_le_bytes([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]); |
from_ne_bytes(bytes: [u8; 8]) -> f64 | Создаёт число из его представления в памяти в виде массива байтов в порядке байтов целевой платформы. | 1.83.0 | 1.40.0 | let value = f64::from_ne_bytes(...); |
Сравнение и ограничение
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
total_cmp(&self, other: &f64) -> Ordering | Возвращает упорядочение между self и other в соответствии с предикатом totalOrder из IEEE 754. | - | 1.62.0 | assert!(1.0_f64.total_cmp(&2.0).is_lt()); |
clamp(self, min: f64, max: f64) -> f64 | Ограничивает значение определённым интервалом, если оно не равно NaN. | 1.85.0 | 1.50.0 | assert_eq!((-3.0f64).clamp(-2.0, 1.0), -2.0); |
abs(self) -> f64 | Вычисляет абсолютное значение self. | 1.85.0 | 1.0.0 | assert_eq!((-3.5_f64).abs(), 3.5); |
signum(self) -> f64 | Возвращает число, представляющее знак self. | 1.85.0 | 1.0.0 | assert_eq!(3.5_f64.signum(), 1.0); |
copysign(self, sign: f64) -> f64 | Возвращает число, состоящее из величины self и знака sign. | 1.85.0 | 1.35.0 | assert_eq!(3.5_f64.copysign(-0.42), -3.5_f64); |
Алгебраические операции (экспериментальные)
| Метод | Описание | Константность | Версия | Пример |
|---|---|---|---|---|
algebraic_add(self, rhs: f64) -> f64 | Сложение чисел с плавающей запятой, позволяющее оптимизации на основе алгебраических правил. (экспериментальный) | - | Nightly | - |
algebraic_sub(self, rhs: f64) -> f64 | Вычитание чисел с плавающей запятой, позволяющее оптимизации на основе алгебраических правил. (экспериментальный) | - | Nightly | - |
algebraic_mul(self, rhs: f64) -> f64 | Умножение чисел с плавающей запятой, позволяющее оптимизации на основе алгебраических правил. (экспериментальный) | - | Nightly | - |
algebraic_div(self, rhs: f64) -> f64 | Деление чисел с плавающей запятой, позволяющее оптимизации на основе алгебраических правил. (экспериментальный) | - | Nightly | - |
algebraic_rem(self, rhs: f64) -> f64 | Остаток от деления чисел с плавающей запятой, позволяющий оптимизации на основе алгебраических правил. (экспериментальный) | - | Nightly | - |
Устаревшие методы
| Метод | Описание | Версия | Статус | Примечание |
|---|---|---|---|---|
abs_sub(self, other: f64) -> f64 | Положительная разность двух чисел. | 1.0.0 | Устарело с 1.10.0 | Вероятно, вы имели в виду (self - other).abs() |
Примечания о точности
Многие функции помечены как имеющие неопределённую точность - это означает, что их точность может варьироваться в зависимости от платформы, версии Rust и даже между вызовами в одном исполнении.
Некоторые функции (например, sqrt, mul_add) гарантируют точность в соответствии со стандартом IEEE 754.