converting float to int: rounding in complex cases (ceil() and floor() not usable)

Question

Hello,

I want to convert a floating point value to its integer representation. As this will be used in comparisons, the default rounding mode (round_to_nearest) is not appropriate for me. As far as I know I can't specify the rounding mode to the FPU in a C++ standard compliant way (not even in C++0x). What are the other ways to accomplish that and which one of them is the most portable? I'm programming on Linux, GCC, i386 + x86-64.

Thanks!

EDIT

I'm interested in round_toward_infinity and round_toward_neg_infinity rounding modes and I want to be able select one of them each time.

Answer 1

You have to specify which type of rounding you do want.

Think about it in these terms:

1. take a floating point variable

2. round it appropriately

3. cast to integer will get the integer part of the floating point value - it truncates the value

You might look at floor() and ceil() for round-down and round-up respectively.

You have to pay particular attention to what you want to happen around 0 and negative numbers.

GLIBC has lots of rounding functions available.

Here's a round-towards-infinity function:

int round_towards_infinity(double value) {
  if(value > 0)
     return ceil(value);
  return floor(value);
}

Answer 2

You should use floor and ceil. The prototype is not int floor nor int ceil, but they do return an integer value.

#include <math.h>
#include <stdio.h>

int main()
{
        float x = 6.04;
        printf("floor = %f ceil = %f\n", floor(x), ceil(x));
        return 0;
}

Produces:

$ ./test 
floor = 6.000000 ceil = 7.000000

So you just now have to cast the answer.

Answer 3

Maybe like this :

#include <cmath>

int Round( const double a )
{
  return static_cast< int >( std::floor( a + 0.5 ) );
}

Answer 4

The conversion I've always been taught to use (although I'm sure proper floating point mathematicians will shoot me for it) has been:

float x = ....;
int   y = int(x + 0.5f);

A quick look through my reference says that C99 has an "lrint" family of functions that take floating point values and return long ints. It may be what you are looking for.

Answer 5

If both 12.3 and 14.7 are floats then in IEEE 754 both 13.0 and 14.0 are floats (more generally: given two non-integer floats, all integers in between are floats as well). Therefore, under IEEE 754, floor and ceil always work correctly (note that x86 uses IEEE 754 representations).

If you're not under IEEE 754, note that the definition of floor says (C99:7.12.9.2/3, I don't have C90 handy)

The floor functions return the largest integer value not greater than x, expressed as a floating-point number.

I don't know how to interpret that if the largest integer value not greater than x cannot be represented exactly.

Answer 6

Since C99 there's llrint() which rounds to the next (long long) integer, using the current rounding mode (that can be set by fesetround()).

Answer 7

Sounds like you're going to have to do some bit twiddling to get the right answer. Extract the exponent of the float and use that to shift the bit pattern of the mantissa by the right amount. You may need to do some additional trickery to handle +/- infinity and overflows and denormalised values... but it sounds like a painful path.. I'd not walk it if you really didn't have to.