尝试使用std :: round（）时，我应该添加少量吗？

Question

Here is a situation where a round_to_2_digits() function is rounding down when we expected it to round up. This turned out to be the case where a number cannot be represented exactly in a double. I don't remember the exact value, but say this:

double value = 1.155;
double value_rounded = round_to_2_digits( value );

The value was the output of a function, and instead of being exactly 1.155 like the code above, it actually was returning something like 1.15499999999999999. So calling std::round() on it would result in 1.15 instead of 1.16 like we thought.

Questions:

I'm thinking it may be wise to add a tiny value in round_to_2_digits() prior to calling std::round() .

• Is this standard practice, or acceptable? For example, adding the 0.0005 to the value being rounded.
• Is there a mathematical term for this kind of "fudge factor"?
  • EDIT: "epsilon" was the term I was looking for.
• And since the function rounds to only 2 digits after the decimal point, should I be adding 0.001? 0.005? 0.0005?

The rounding function is quite simple:

double round_to_2_decimals( double value )
{
    value *= 100.0;
    value = std::round(value);
    value /= 100.0;
    return value;
}

Answer 1

Step one is admitting that double may not be the right data type for your application. :-) Consider using a fixed-point type, or multiplying all of your values by 100 (or 1000, or whatever), and working with integer values.

You can't actually guarantee that adding any particular small epsilon won't give you the wrong results in some other situation. What if your value actually was 1.54999999..., and you rounded it up? Then you'd have the wrong value the other way.

The problem with your suggested solution is that at the end of it, you're still going to have a binary fraction that's not necessarily equal to the decimal value you're trying to represent. The only way to fix this is to use a representation that can exactly represent the values you want to use.

Answer 2

This question doesn't make a lot of sense. POSIX mandates std::round rounds half away from zero. So the result should in fact be 116 not 115 . In order to actually replicate your behavior, I had to use a function that pays attention to rounding mode:

std::fesetround(FE_DOWNWARD);
std::cout << std::setprecision(20) << std::rint(1.155 * 100.0);

This was tested on GCC 5.2.0 and Clang 3.7.0.