How does Rust handle rounding in conversion of f64 to i64?

Question

I've done a little testing of currency-handling in eg. Go and Dart. Basically, I think the best way to handle currencies is to convert doubles to integer in order that all calculations are made using integers, and I think that is the accepted way. However, different languages treat the conversion to integer differently. For example Go truncates doubles therefore, it is I believe necessary to add a rounding factor to compensate. Using Rust, I have found that doing a straight conversion (see below) appears to work, but I'm unsure how Rust actually handles the conversion using what appear to be two alternatives for handling the conversion.

How does Rust handle the rounding of f64 to i64 and what is the best method to use - "as i64" or "to_i64()"?

Based on timings that I did, the two methods here don't appear identical, however the results may be. ("as i64" appeared marginally faster).

Example (simplified to use only 2 decimal places - single currency):

fn fCcyDblToInt(dCcyAmt: f64) -> i64 {
 //  return (dCcyAmt * 100.0).to_i64(); 
 return (dCcyAmt * 100.0) as i64;
}

Edited 14 hours after initial post:

After doing some more testing, the following appears to me to be the way to handle conversion of float to integer using Rust:

fn fCcyDblToInt(dCcyAmt:f64) -> i64 {
  let dRound: f64 = if dCcyAmt > 0.0 { 0.5 } else if dCcyAmt < 0.0 {-0.5 } else {0.0};
 // return ((dCcyAmt * 100.0) +dRound).to_i64();
  return ((dCcyAmt * 100.0) +dRound) as i64;      
}

I'm fairly comfortable with that, because it's how I've handled it elsewhere, however I'll test some more.

Answer 1

f64 has a round method 😊 Therefore you can do this:

fn currency_double_to_int(amount: f64) -> i64 {
    (amount * 100.0).round() as i64
}

That way you should get the standard rounding every time instead of the truncation. The rounding, I suspect, is the same as the libc rounding. See also this playpen for a little demonstration.