C++: how to truncate the double in efficient way?

Question

Hello, I would like to truncate the float to 4 digits. Are there some efficient way to do that? My current solution is:

double roundDBL(double d,unsigned int p=4)
{
 unsigned int fac=pow(10,p);
 double facinv=1.0/static_cast<double>(fac);
 double x=static_cast<unsigned int>(d*fac)*facinv;
 return x;
}

but using pow and delete seems to me not so efficient.

kind regards

Arman.

Answer 1

Efficiency depends on your platform.

Whatever methods you try, you should profile to make sure

1. the efficiency is required (and a straightforward implementation is not fast enough for you)
2. the method you're trying is faster than others for your application on real data

You could multiply by 10000, truncate as an integer, and divide again. Converting between double and int might be faster or slower for you.

You could truncate on output, e.g. a printf format string of "%.4f"

Answer 2

You could replace pow with a more efficient integer-based variant instead. There's one here on Stack Overflow: http://stackoverflow.com/questions/101439/the-most-efficient-way-to-implement-an-integer-based-power-function-powint-int

Also, if you can accept some inaccuracy, replace the divide with a multiply. Divisions are one of the slowest common math operations.

Other than that, I'll echo what others have said and simply truncate on output, unless you actually need to use the truncated double in calculations.

Answer 3

round(d*10000.0)/10000.0;

or if p must be variable;

double f = pow(10,p);
round(d*f)/f;

round will usually be compiled as a single instruction that is faster than converting to an integer and back. Profile to verify.

Note that a double may not have an accurate representation to 4 decimal places. You will not truly be able to truncate an arbitrary double, just find the nearest approximation.

Answer 4

If you need to perform exact calculations that involve decimal digits, then stop using double right now! It's not the right data type for your purpose. You will not get actually rounded decimal values. Almost all values will (after truncation, not matter what method you use) be in fact be something like 1,000999999999999841, not 1,0001.

That's because double is implemented using binary fractions, not decimal ones. There are decimal types you can use instead that will work correctly. They will be a lot slower, but then, if the result does not need to be correct, I know a method to make it infinitely fast...