Using floorf to reduce the number of decimals

Question

I would like to use the first five digits of a number for computation. For example, A floating point number: 4.23654897E-05

I wish to use 4.2365E-05.I tried the following

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

float num = 4.23654897E-05;
int main(){
float rounded_down = floorf(num * 10000) / 10000;
printf("%f",rounded_down);
return 0;

}

The output is 0.000000.The desired output is 4.2365E-05. In short,say 52 bits are allocated for storing the mantissa.Is there a way to reduce the number of bits being allocated?

Any suggestions on how this can be done?

Answer 1

A number x that is positive and within the normal range can be rounded down approximately to five significant digits with:

double l = pow(10, floor(log10(x)) - 4);
double y = l * floor(x / l);

This is useful only for tinkering with floating-point arithmetic as a learning tool. The exact mathematical result is generally not exactly representable, because binary floating-point cannot represent most decimal values exactly. Additionally, rounding errors can occur in the pow, /, and * operations that may cause the result to differ slightly from the true mathematical result of rounding x to five significant digits. Also, poor implementations of log10 or pow can cause the result to differ from the true mathematical result.

Answer 2

The result is expected. The multiplication by 10000 yield 0.423.. the nearest integer to it is 0. So the result is 0. Rounding can be done using format specifier %f to print the result upto certain decimal places after decimal point.

If you check the return value of floorf you will see it returns If no errors occur, the largest integer value not greater than arg, that is ⌊arg⌋, is returned. where arg is the passed argument.

Without using floatf you can use %e or (%E)format specifier to print it accordingly.

printf("%.4E",num);

which outputs:

4.2365E-05

After David's comment:

Your way of doing things is right but the number you multiplied is wrong. The thing is 4.2365E-05 is 0.00004235.... Now if you multiply it with 10000 then it will 0.42365... Now you said I want the expression to represent in that form. floorf returns float in this case. Store it in a variable and you will be good to go. The rounded value will be in that variable. But you will see that the rounded down value will be 0. That is what you got.

float rounded_down = floorf(num * 10000) / 10000;

This will hold the correct value rounded down to 4 digits after . (not in exponent notation with E or e). Don't confuse the value with the format specifier used to represent it.

What you need to do in order to get the result you want is move the decimal places to the right. To do that multiply with larger number. (1e7 or 1e8 or as you want it to).

Answer 3

I'd go:

printf("%.6f", num);

Or you can try using snprintf() from stdlib.h:

float num = 4.23654897E-05;  char output[50];

snprintf(output, 50, "%f", num);

printf("%s", output);

Answer 4

I would like to use the first five digits of a number for computation.

In general, floating point numbers are encoded using binary and OP wants to use 5 significant decimal digits. This is problematic as numbers like 4.23654897E-05 and 4.2365E-05 are not exactly representable as a float/double. The best we can do is get close.

The floor*() approach has problems with 1) negative numbers (should have used trunc()) and 2) values near x.99995 that during rounding may change the number of digits. I strongly recommend against it here as such solutions employing it fail many corner cases.

The *10000 * power10, round, /(10000 * power10) approach suffers from 1) power10 calculation (1e5 in this case) 2) rounding errors in the multiple, 3) overflow potential. The needed power10 may not be exact. * errors show up with cases when the product is close to xxxxx.5. Often this intermediate calculation is done using wider double math and so the corner cases are rare. Bad rounding using (some_int_type) which has limited range and is a truncation instead of the better round() or rint().

An approach that gets close to OP's goal: print to 5 significant digits using %e and convert back. Not highly efficient, yet handles all cases well.

int main(void) {
  float num = 4.23654897E-05f;

  //         sign   d   .   dddd   e   sign   expo + \0
  #define N (1    + 1 + 1 + 4    + 1 + 1    + 4    + 1)
  char buf[N*2];  // Use a generous buffer - I like 2x what I think is needed.

  // OP wants 5 significant digits so print 4 digits after the decimal point.
  sprintf(buf, "%.4e", num);

  float rounded = (float) atof(buf);
  printf("%.5e %s\n", rounded, buf);
}

Output

4.23650e-05 4.2365e-05

---

Why 5 in %.5e: Typical float will print up to 6 significant decimal digits as expected (research FLT_DIG), so 5 digits after the decimal point are printed. The exact value of rounded in this case was about 4.236500171...e-05 as 4.2365e-05 is not exactly representable as a float.