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
• .round() rounds to the nearest integer
• dividing by factor shifts the decimal point back

Example: round to 3 decimal places

fn main() {
    let value = 9.87654;
    let rounded = (value * 1000.0).round() / 1000.0;

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

Reusable function

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

fn main() {
    println!("{}", round_to(2.71828, 2)); // 2.72
    println!("{}", round_to(2.71828, 4)); // 2.7183
}

If you only need formatted output

Sometimes you do not need to change the actual number at all. You only want to display fewer digits.

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

This is often the best option for user-facing output.

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
7. println! outputs 5.68

Another trace with a negative number

let value = -1.234;
let places = 2;
let factor = 10f64.powi(places);
let rounded = (value * factor).round() / factor;

Execution:

1. factor is 100.0
2. value * factor is -123.4
3. .round() makes it -123.0
4. divide by 100.0 gives -1.23

The same pattern works for positive and negative values.

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 {
        return value;
    }

    let factor = 10f64.powi(places);
    (value * factor).round() / factor
}

4. Rounding at boundaries

A common pattern is to keep full precision during calculations and round only when:

• displaying the result
• exporting data
• sending API responses
• storing human-readable summaries

5. Error handling and domain choice

In production code, teams often ask:

• Should this be rounded for display only?
• Should we use f64 here at all?
• Would an integer number of cents be safer?

That design decision matters more than the rounding formula itself.

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

let value = 2.675;
let rounded = (value * 100.0).round() / 100.0;
println!("{}", rounded);

You might expect 2.68, but floating-point representation can produce unexpected results in some cases.

Avoid this by:

• understanding that f64 is approximate
• using formatting for display when possible
• using decimal-safe approaches for exact financial logic

Mistake 4: Using the wrong integer type with powi

Broken example:

let places: u32 = 2;
let factor = 10f64.powi(places);

powi expects an i32, not a u32.

Fix:

let places: i32 = 2;
let factor = 10f64.powi(places);

Mistake 5: Rounding too early in a calculation

Broken idea:

• round after every intermediate step
• then continue calculating

This can accumulate error.

Better approach:

• compute with full precision
• round only at the final display or output stage

.round() vs formatting

f64 vs exact decimal approaches

// 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.
• powi takes an i32 exponent.
• f64 is approximate, not exact decimal math.
• For display, formatting is often better than changing the number.
• For exact money logic, prefer integer units or a decimal type.

Quick formula

(value * 10f64.powi(places)).round() / 10f64.powi(places)

Common display syntax

println!("{:.2}", value);

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.

Can I round to 0 decimal places with the same technique?

Yes. Using places = 0 makes the factor 1.0, which behaves like normal rounding.

Can I round negative numbers the same way?

Yes. The multiply-round-divide pattern works for negative values too.

• 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.