A fast method to round a double to a 32-bit int explained

by

A value of the double floating-point type is represented like so:

double representation

and it can be seen as two 32-bit integers; now, the int taken in all the versions of your code (supposing it’s a 32-bit int) is the one on the right in the figure, so what you are doing in the end is just taking the lowest 32 bits of mantissa.

Now, to the magic number; as you correctly stated, 6755399441055744 is 251 + 252; adding such a number forces the double to go into the “sweet range” between 252 and 253, which, as explained by Wikipedia, has an interesting property:

Between 252 = 4,503,599,627,370,496 and 253 = 9,007,199,254,740,992, the representable numbers are exactly the integers.

This follows from the fact that the mantissa is 52 bits wide.

The other interesting fact about adding 251 + 252 is that it affects the mantissa only in the two highest bits—which are discarded anyway, since we are taking only its lowest 32 bits.

Last but not least: the sign.

IEEE 754 floating point uses a magnitude and sign representation, while integers on “normal” machines use 2’s complement arithmetic; how is this handled here?

We talked only about positive integers; now suppose we are dealing with a negative number in the range representable by a 32-bit int, so less (in absolute value) than (−231 + 1); call it −a. Such a number is obviously made positive by adding the magic number, and the resulting value is 252 + 251 + (−a).

Now, what do we get if we interpret the mantissa in 2’s complement representation? It must be the result of 2’s complement sum of (252 + 251) and (−a). Again, the first term affects only the upper two bits, what remains in the bits 0–50 is the 2’s complement representation of (−a) (again, minus the upper two bits).

Since reduction of a 2’s complement number to a smaller width is done just by cutting away the extra bits on the left, taking the lower 32 bits gives us correctly (−a) in 32-bit, 2’s complement arithmetic.

More Related Contents:

  1. Why does changing 0.1f to 0 slow down performance by 10x?
  2. Avoiding denormal values in C++
  3. Regarding time out in code
  4. Integer division always zero [duplicate]
  5. round() for float in C++
  6. Floating point division vs floating point multiplication
  7. Floating point comparison [duplicate]
  8. Is < faster than
  9. Does the C++ standard mandate poor performance for iostreams, or am I just dealing with a poor implementation?
  10. Why can’t I use float value as a template parameter?
  11. What is IACA and how do I use it?
  12. Performance of built-in types : char vs short vs int vs. float vs. double
  13. Floating point vs integer calculations on modern hardware
  14. Dealing with accuracy problems in floating-point numbers
  15. Ternary operator ?: vs if…else
  16. C++ decimal data types
  17. while (1) Vs. for (;;) Is there a speed difference?
  18. How to check if C++ compiler uses IEEE 754 floating point standard
  19. Is using double faster than float?
  20. Trial-division code runs 2x faster as 32-bit on Windows than 64-bit on Linux
  21. vector or map, which one to use?
  22. Floating point comparison revisited
  23. Performance issue for vector::size() in a loop in C++
  24. Building a 32-bit float out of its 4 composite bytes
  25. Why does Clang optimize away x * 1.0 but NOT x + 0.0?
  26. Why is there no 2-byte float and does an implementation already exist?
  27. Performance penalty for working with interfaces in C++?
  28. Why isn’t “0f” treated as a floating point literal in C++?
  29. Memory-efficient C++ strings (interning, ropes, copy-on-write, etc) [closed]
  30. Fastest way to get the integer part of sqrt(n)?

Leave a Comment