How does one round a floating point number to a specified number of digits?

If you want this just for display purposes, use the formatting syntax built into println!(). For example, to print a number rounded to 2 decimal places use the {:.2} format specifier:

fn main() {
    let x = 12.34567;
    println!("{:.2}", x);
}

If you want to put the rounded number in a string, use the format!() macro.

If you want to round a number and get the result back as another number, then multiply the number by the given power of 10, call round, and divide by the same power, e.g. to round to 2 decimal places, use 10² = 100.

fn main() {
    let x = 12.34567_f64;
    let y = (x * 100.0).round() / 100.0;

    println!("{:.5} {:.5}", x, y);
}

playground

This prints 12.34567 12.35000.

If the number of decimal places isn't known at compile time, one could use powi to efficiently compute the relevant power.

Note that this will breakdown for very large numbers; specifically, numbers larger than std::f64::MAX / power (where power is the power of ten, e.g. 100 in the example above) will become infinity in the multiplication, and remain infinity after. However, f64 cannot represent any fractional places for numbers larger than 2⁵³ (i.e. they're always integers), so one can special case such large numbers to just return themselves.

To add to @huon's great answer, if you want to round a floating point number for display purposes, but you don't know the precision at compile time, you can use the precision formatting syntax as follows:

fn main() {
    let precision = 3;
    let x = 12.34567;
    println!("{:.1$}", x, precision); // prints 12.346 and works with `format!` as well
}

The documentation of std::fmt has more examples on the syntax.

Example round function with decimal count as a parameter:

fn round(x: f32, decimals: u32) -> f32 {
    let y = 10i32.pow(decimals) as f32;
    (x * y).round() / y
}