Как округлить число с плавающей точкой до указанного количества знаков в Rust?

Правильное округление чисел с плавающей точкой в Rust

Вы правы: в стандартной библиотеке Rust нет прямого аналога round(x, digits) из Python. Однако есть несколько надёжных способов решить вашу задачу. Главная проблема — бинарное представление чисел с плавающей точкой (f32/f64) не может точно представить некоторые десятичные дроби, поэтому "наивное" умножение/деление может давать неожиданные результаты.

Способ 1: Использование форматирования (для вывода)

Если вам нужно только отобразить число с определённым количеством знаков, используйте макрос форматирования:

fn main() {
    let price = 19.995;
    println!("{:.2}", price); // Выведет "20.00" (округление по математическим правилам)
    println!("{:.3}", 3.14159); // Выведет "3.142"
}

Метод format! также работает:

let formatted = format!("{:.2}", 19.995);
assert_eq!(formatted, "20.00");

Важно: это даёт строку, а не число f64. Для большинства задач отображения этого достаточно.

Способ 2: Крейт rust_decimal (для точных финансовых расчётов)

Если вам нужна идеальная точность (например, для денег), используйте крейт rust_decimal. Он хранит числа как десятичные дроби, избегая проблем с плавающей точкой:

use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use std::str::FromStr;

fn main() {
    // Создание Decimal из строки (самый безопасный способ)
    let price = Decimal::from_str("19.995").unwrap();
    let rounded = price.round_dp(2);
    println!("{}", rounded); // Выведет "19.99" (банковское округление по умолчанию)

    // Для математического округления (как в школе):
    use rust_decimal::prelude::*;
    let rounded_math = price.round_dp_with_strategy(2, RoundingStrategy::RoundHalfUp);
    println!("{}", rounded_math); // Выведет "20.00"
}

Добавьте в Cargo.toml:

[dependencies]
rust_decimal = "1.35"
rust_decimal_macros = "1.35"

Способ 3: Ручное округление с учётом погрешностей (для f64)

Если вы всё же хотите работать с f64, используйте round() с добавлением небольшой "дельта" (epsilon):

fn round_to(value: f64, decimals: u32) -> f64 {
    let multiplier = 10_f64.powi(decimals as i32);
    // Добавляем f64::EPSILON для компенсации ошибок округления
    (value * multiplier + 0.5 * f64::EPSILON).round() / multiplier
}

fn main() {
    let price = 19.995;
    let rounded = round_to(price, 2);
    println!("{:.2}", rounded); // Выведет "20.00"
    
    // Проверка на граничных случаях
    assert_eq!(round_to(3.14159, 2), 3.14);
    assert_eq!(round_to(2.675, 2), 2.68); // Известный проблемный случай
}

Предупреждение: этот метод всё равно не идеален для всех чисел из-за природы f64. Для серьёзных финансовых расчётов используйте rust_decimal.

Способ 4: Крейт ordered-float (для строгих сравнений)

Если вам нужно сравнить округлённые числа, используйте ordered-float:

use ordered_float::OrderedFloat;

fn main() {
    let a = OrderedFloat(19.995);
    let b = OrderedFloat(20.00);
    println!("{}", a.round()); // 20
}

Рекомендация

• Для отображения — используйте format!("{:.2}", value)
• Для точных денежных расчётов — rust_decimal
• Для научных/инженерных задач — ручная функция с epsilon (способ 3)

Помните: ни один метод с f64 не гарантирует 100% точности для всех десятичных дробей. Если вам нужно точное представление десятичных чисел (как в бухгалтерии), всегда используйте Decimal-типы.

use round::Round;

fn main() {
    let price = 19.995_f64;
    let rounded = price.round(2); // Округление до 2 знаков
    println!("{}", rounded); // Выведет "20.00" (математическое округление)
    
    // Другие стратегии округления:
    let floor_rounded = price.round_floor(2); // 19.99
    let ceil_rounded = price.round_ceil(2);   // 20.00
    let trunc_rounded = price.round_trunc(2); // 19.99
}

[dependencies]
round = "0.1.1"