I think I read somewhere that cpu’s “do some floating point computations in 50 bits so that they can round down to 32 bits correctly”. What I think this means is that the intermediate value computed in aforementioned floating point operation is computed in 50 bits so that “correct rounding to float size” can be achieved.
What does this statement mean? Is it true? If so, can you point me to some resources which explain why they need to compute 18 extra bits? Why not 19 or 17? Or is it just plain false?
Edit:- I found this link which is quite helpful and exhaustive… http://www.gamasutra.com/view/news/167402/Indepth_Intermediate_floatingpoint_precision.php
thanks
It is common on modern computers that computing in double-precision (1 sign bit, 11 exponent bit, 52 explicit significand bits) is as fast as computing in single-precision (1 sign bit, 8 exponent bits, 23 significand bits). Therefore, when you load float objects, calculate, and store float objects, the compiler may load the float values into double-precision registers, calculate in double-precision, and store single-precision results. This benefits you by providing extra precision at very little cost. Results may be more often “correctly rounded” (the result returned is the representable value nearest the mathematically exact result), but this is not guaranteed (because there are still rounding errors, which can interact in unexpected ways) or may often be more accurate (closer to the exact result than float calculations would provide) (but that is also not guaranteed), but, in rare cases, a double-precision calculation can return a result worse than single-precision calculation.
There are times when double-precision is more expensive than single-precision, notably when performing SIMD programming.
Commonly, high-level languages leave the compiler free to decide how to evaluate floating-point expressions, so a compiler may use single-precision or double-precision depending on the vendor’s choices (or quality of the compiler), optimization and target switches you have passed to the compiler, other aspects of the code being compiled (e.g., availability of machine registers to do the calculations in), and other factors that may be random for practical purposes. So this is not behavior you can rely on.
Another meaning for what you heard might be that library routines for single-precision functions, such as sinf or logf, may be written in double-precision so that it is easier for them to get the desired results than if they had to be written entirely in single-precision. That is common. However, such library routines are carefully written by experts who analyze the errors that may occur during the calculations, so it is not simply a matter of assuming that more bits give better results.