How to convert f32 to String with dynamic precision?

Question

In my rust code I have a function which takes a float and precision as args. The function should return the formatted string. However, I am not sure how I can format with dynamic precision,

fn convert(val: f32, precision: i16) -> String {
    format!("{:.2}", val) // The 2 should be replaced with precision
}
// convert(1.2345, 1) -> 1.2
// convert(1.2345, 2) -> 1.23

Use the [precision formatting](https://doc.rust-lang.org/stable/std/fmt/index.html#precision) syntax. — E_net4, May 22 '20 at 11:39
I would say this is not a duplicate because I was not able to find the dynamic precision. I saw that answer but it is not answering mine — Selva, May 22 '20 at 12:34
@Selva there are two answers to that question. The less-voted one is what you want. — mcarton, May 22 '20 at 12:36

score 7 · Accepted Answer · edited Jun 20 '20 at 09:12

According to the documentation:

There are three possible ways to specify the desired precision:

An integer .N:

the integer N itself is the precision.

An integer or name followed by dollar sign .N$:

use format argument N (which must be a usize) as the precision.

An asterisk .*:

.* means that this {...} is associated with two format inputs rather than one: the first input holds the usize precision, and the second holds the value to print. Note that in this case, if one uses the format string {<arg>:<spec>.*}, then the <arg> part refers to the value to print, and the precision must come in the input preceding <arg>.

That is, you can use:

fn convert(val: f32, precision: usize) -> String {
    format!("{:.prec$}", val, prec = precision)
}

fn main() {
    println!("{}", convert(3.14, 0));
    println!("{}", convert(3.14, 1));
    println!("{}", convert(3.14, 2));
    println!("{}", convert(3.14, 3));
}

(Permalink to the playground)

I looked into the document but didn't find it. May be it was not easy to identify — Selva, May 22 '20 at 12:35

How to convert f32 to String with dynamic precision?

1 Answers1