Fast rounding float on three digits precision in C

Question

I have seen this code:

(int)(num < 0 ? (num - 0.5) : (num + 0.5))

(How to round floating point numbers to the nearest integer in C?) for rounding but I need to use float and precision for three digits after the point. Examples: 254.450 should be rounded up to 255. 254.432 should be rounded down to 254 254.448 should be rounded down to 254 and so on.

Notice: This is what I mean by "3 digits" the bold digits after the dot.

I believe it should be faster then roundf() because I use many hundreds of thousands rounds when I need to calculate the rounds. Do you have some tips how to do that? I tried to search source of roundf but nothing found.

Note: I need it for RGB2HSV conversion function so I think 3 digits should be enough. I use positive numbers.

Answer 1

"it should be faster then roundf()" is only verifiable with profiling various approaches.

To round to 0 places (round to nearest whole number), use roundf()

float f;
float f_rounded3 = roundf(f);

---

To round to 3 places using float, use round()

The round functions round their argument to the nearest integer value in floating-point format, rounding halfway cases away from zero, regardless of the current rounding direction.

#include <math.h>

float f;
float f_rounded3 = round(f * 1000.0)/1000.0;

Code purposely uses the intermediate type of double, else code code use with reduced range:

float f_rounded3 = roundf(f * 1000.0f)/1000.0f;

---

If code is having trouble rounding 254.450 to 255.0 using roundf() or various tests, it is likely because the value is not 254.450, but a float close to it like 254.4499969 which rounds to 254. Typical FP using a binary format and 254.450 is not exactly representable.

Answer 2

When you can change de border from b=0.5 to b=0.45 you must know that for positives the rounded value is round_0(x,b)=(int)( x+(1-b) ) therefore b=0.45 ⟹ round_0(x)=(int)(x+0.55) and you can threat the signal. But remember that don't exists 254.45 but 254.449997 and 254.449999999999989, maybe you prefer to use b=0.4495.

If you have float round_0(float) to zero-digit rounding (can be like you show in question), you can do for one, two... n-digit rounding like this in C/C++: # define round_n(x,n) (round_0((x)*1e##n)/1e##n).

round_1( x , b ) = round_0( 10*x ,b)/10

round_2( x , b ) = round_0( 100*x ,b)/100

round_3( x , b ) = round_0( 1000*x ,b)/1000

round_n( x , b , n ) = round_0( (10^n)*x ,b)/(10^n)

But do typecast to int and (one more typecast) to float to operate is slower than rounds in operations. If don't simplify the add/sub (some compilers have this setting) for faster zero-digit round to float type you can do it.

inline float round_0( float x , float b=0.5f ){
    return (( x+(0.5f-b) )+(3<<22))-(3<<22) ;  // or (( x+(0.5f-b) )-(3<<22))+(3<<22) ;
}

inline double round_0( double x , double b=0.5 ){
    return (( x+(0.5-b) )+(3<<51))-(3<<51) ;  // or (( x+(0.5-b) )-(3<<51))+(3<<51) ;
}

When b=0.5 it correctly rounds to nearest integer if |x|<=2^23 (float) or |x|<=2^52 (double). But if compiler uses FPU (ten bytes floating-point) optimizing loads then constant is 3.0*(1u<<63), works |x|<=2^64 and use long double can be faster.

Answer 3

You can use double transformation float -> string -> float, while first transformation make 3 digits after point:

  sprintf(tmpStr, "%.3f", num);

Answer 4

this work for me

#include <stdio.h>


int main(int ac, char**av)                                                                    
{                                                                                             
  float val = 254.449f;                                                                       
  float val2 = 254.450f;                                                                      
  int res = (int)(val < 0 ? (val - 0.55f) : (val + 0.55f));                                   
  int res2 = (int)(val2 < 0 ? (val2 - 0.55f) : (val2 + 0.55f));                               
  printf("%f %d %d\n", val, res, res2);                                                       
  return 0;                                                                                   
}                                                                                             

output : 254.449005 254 255

to increase the precision just add any 5 you want in 0.55f like 0.555f, 0.5555f, etc

Answer 5

I wanted something like this:

float num = 254.454300;
float precision=10;
float p = 10*precision;
num = (int)(num  * p + 0.5) / p ;

But the result will be inaccurate (with error) - my x86 machine gives me this result: 254.449997