How to Round a Floating-Point Number to a Specific Number of Decimal Places in Rust

By the end of this page, you will understand how rounding works for f64 values in Rust, how to round to a chosen number of decimal places, why scaling by powers of 10 is commonly used, and what floating-point limitations you need to watch out for in real code.

Rust provides built-in rounding methods such as .round(), but that method rounds to the nearest whole number only. If you want to round to a specific number of decimal places, the usual approach is:

1. Multiply the number by 10^n
2. Round the result
3. Divide by 10^n

Here, n is the number of decimal places you want to keep.

For example, to round 3.14159 to 2 decimal places:

• Multiply by 100 → 314.159
• Round → 314.0
• Divide by 100 → 3.14

In Rust, this is commonly written using 10f64.powi(n).

let n = 2;
let x = 3.14159;
let factor = 10f64.powi(n);
let rounded = (x * factor).round() / factor;

This matters because real programs often need to:

• display prices
• format measurements
• limit precision in reports
• normalize values before saving or comparing them

However, it is important to understand that f64 uses binary floating-point representation. That means some decimal values cannot be represented exactly. So rounding may sometimes produce results that look surprising, especially when printed with many digits.

Rounding a number for display is also different from rounding a number for computation. In many cases, formatting output is better than changing the stored value.

Think of decimal-place rounding like moving the decimal point temporarily.

If you want 2 decimal places:

• move the decimal point 2 places to the right
• round to a whole number
• move it back 2 places to the left

Example with 12.3456:

• move right: 1234.56
• round: 1235
• move left: 12.35

So the trick is not a special "round to 2 places" feature built into f64. Instead, you create that behavior by scaling the number up and down.

The basic Rust pattern is:

let factor = 10f64.powi(decimal_places);
let rounded = (value * factor).round() / factor;

Example: round to 2 decimal places

fn main() {
    let value = 3.14159;
    let decimal_places = 2;

    let factor = 10f64.powi(decimal_places);
    let rounded = (value * factor).round() / factor;

    println!("{}", rounded); // 3.14
}

What this does

• 10f64.powi(decimal_places) creates 100.0 when decimal_places is 2
• value * factor shifts the decimal point

Consider this code:

fn main() {
    let value = 5.6789;
    let places = 2;
    let factor = 10f64.powi(places);
    let rounded = (value * factor).round() / factor;

    println!("{}", rounded);
}

Step by step:

1. value is 5.6789
2. places is 2
3. factor = 10f64.powi(2) becomes 100.0
4. value * factor becomes 567.89
5. (567.89).round() becomes 568.0
6. 568.0 / 100.0 becomes 5.68

Rounding to a fixed number of decimal places appears in many practical situations.

Financial display

let price = 19.999;
println!("{:.2}", price); // 20.00

Used for:

• shopping carts
• invoices
• receipts
• dashboards

Measurement output

let temperature = 23.45678;
println!("{:.1}", temperature); // 23.5

Used for:

• sensor data
• scientific tools
• weather apps

Reporting and summaries

You may round values before presenting them in logs, CSV exports, or analytics results.

API responses

Some APIs return numeric values with controlled precision so clients get cleaner output.

Data normalization

Applications sometimes reduce precision before storing approximate values, especially when exact tiny differences are not useful.

Be careful: in finance or other exact-decimal domains, binary floating-point may not be the best storage type.

In real projects, developers usually use rounding in one of these ways:

1. Formatting for output instead of changing the value

This is common in UI, logs, and reports.

let total = 42.6789;
let display = format!("{:.2}", total);

This keeps the original numeric value unchanged.

2. Helper functions for repeated rounding

fn round_to(value: f64, places: i32) -> f64 {
    let factor = 10f64.powi(places);
    (value * factor).round() / factor
}

This avoids duplicated logic.

3. Validation and guard clauses

Developers often protect helper functions from invalid inputs.

fn round_to(value: f64, places: i32) -> f64 {
    if places < 0 {
         value;
    }

      = .(places);
    (value * factor).() / factor
}

Mistake 1: Using .round() directly and expecting decimal-place rounding

Broken example:

let value = 3.14159;
let rounded = value.round();
println!("{}", rounded); // 3

Why it happens:

• .round() rounds to the nearest whole number, not to 2 or 3 decimal places.

Fix:

let rounded = (value * 100.0).round() / 100.0;

Mistake 2: Confusing formatting with changing the actual value

let value = 3.14159;
println!("{:.2}", value); // prints 3.14
println!("{}", value);    // still 3.14159

Formatting affects output, not the stored number.

Mistake 3: Forgetting floating-point precision issues

// Round to nearest whole number
let x = 3.7;
let y = x.round(); // 4.0

// Round to N decimal places
fn round_to(value: f64, places: i32) -> f64 {
    let factor = 10f64.powi(places);
    (value * factor).round() / factor
}

let a = round_to(3.14159, 2); // 3.14
let b = round_to(3.14159, 3); // 3.142

// Format for display only
let s = format!("{:.2}", 3.14159); // "3.14"

Rules to remember

• .round() alone only rounds to a whole number.
• To round to decimal places, multiply, round, then divide.

How do I round an f64 to 2 decimal places in Rust?

Use scaling with round():

let rounded = (value * 100.0).round() / 100.0;

Does Rust have a built-in function to round to a specific number of decimal places?

Not directly for f64. Rust provides .round() for whole-number rounding. To round to decimal places, you usually scale the number first.

Should I use round() or format!() in Rust?

Use round() when you need a numeric result. Use format!() when you only need to display a value with fewer decimal places.

Why does rounding sometimes give unexpected results in Rust?

Because f64 uses binary floating-point, many decimal values cannot be represented exactly. Small precision errors can affect rounding.

Is f64 safe for money calculations?

Usually not for exact financial rules. It is often better to store money as integer cents or use a decimal type.

• f64 in Rust — important because rounding depends on floating-point behavior.
• Floating-point precision — explains why some decimal values are not represented exactly.
• round, floor, ceil, and trunc — related numeric methods with different behavior.
• Number formatting in Rust — useful when you want display precision without changing the value.
• Functions in Rust — helpful for creating a reusable round_to helper.
• Integer arithmetic — often a better choice for exact values like money.
• Type conversion in Rust — useful when working with numeric methods and exponents.