Getting the amount of decimals a number has in c?

Question

I am trying to get the amount of decimals a number has in c: 0.0001 -> 4 decimals, 3,54235 -> 5 decimals, and so on (If you don't get it, the number of numbers behind the comma.) our teacher sais it can be done in two ways, using a string and not using a string. I figured i would go ahead not using a string because I have NO experiance with strings.

So this is what I came up with

int funzione1(float decimals){
  int x=1,c=0,y=1;
  while (x!=0){
      if((decimals - y) > 0){
          y = y / 10;
          c++;
      }else{
          decimals = decimals - y;
      }
      if(decimals == 0)
          x=0;
  }
  return c-1;
}

When calling the function it should return the amount of decimals I figured, but it does not, actually it gets stuck in an infinite loop.

the Idea behind this code was to for every number in the "string" of numbers to get them to 0 and then check if the total number was 0

3.456 c=0

0.456 c=1

0.056 c=2

0.006 c=3

0.000 return c

But That leaves me with two problems 1 how to detirmine tha amount of numbers before the comma for like 5564.34234 this code will not work because it will count to 8 before the full number is a solid 0. and therefor not return the right number of decimals.2. the code I designed isn't working. Just gets stuck in an infinite loop. I don't know where the infiniteness of the loop is created.

How do i get this code to work?

PS. I found this article about this problem in Java: How to find out how many decimals a number has? but it is using strings and I would not like that because of the fact that I don't know how to use strings.

edit: Here is another piece of code i tried and which faild really bad givving an output of 50 when you enter a number higher than 1 and 0 if the number is lower than 0(I don't get it, not a little bit) anyway here is the code:

int funzione1(float decimals){
    int i=0;
    while(decimals!=((int)decimals)){
        i++;
        decimals=decimals*10;
    }
    return i;
}

Answer 1

Your best bet would be to read the input as string and just count the digits after '.'. Floating point numbers are not exact representation i.e. the decimal values are stored in binary internally and may not exactly represent the true decimal value. However every binary representation is some decimal number with finite digits.

Have a look at this answer in SO.

Answer 2

If you don't care about rounding then you don't need to count the number of decimal places, you can just count the number of binary places. This is because 10 contains 2 as a factor exactly once so 10^n and 2^n have the same number of 2s as factors. The fastest way to count the number of binary places is to get the exponent of the floating point number.

e.g. binary 0.001 takes 3 decimal places to represent 0.125, 0.0001 takes 4 0.0625.

You can either get the fractional part of the value and keep multiplying by 2 and removing the integer as people have suggested doing with 10 (it will give you the same answer).

Or you can have a bit more fun over optimising the solution (the places function does most of the work):

#include <math.h>

int saturateLeft (unsigned int n) {
  n |= (n <<  1);
  n |= (n <<  2);
  n |= (n <<  4);
  n |= (n <<  8);
  n |= (n << 16);
  return n;
}

int NumberOfSetBits(int i)
{
  i = i - ((i >> 1) & 0x55555555);
  i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
  return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

int places (double num) {
  int exponent;
  float mantissa = frexp (num, &exponent);

  /* The answer we are looking for is given by the 
     (number of bits used by mantissa) - the exponent.
  */

  unsigned intMantissa = scalbnf (mantissa, 32);
  /* Could also be got by doing:
     intMantissa = *(unsigned *)&mantissa << 9;
  */

  /* To work out how many bits the mantissa covered we 
     need no gaps in the mantissa, this removes any gaps.
  */

  intMantissa = saturateLeft (intMantissa);
  int bitCount = NumberOfSetBits (intMantissa);

  /* bitCount could also be found like this:
     intMantissa = ~intMantissa;
     int bitCount = 32 - ilogb (intMantissa) - 1;
  */

  int result = bitCount - exponent;
  if (result < 0)
    return 0;

  return result;
}

The bitCounting algorithm was found here.

Answer 3

Here's an idea:

• Start with a floating point number, say a = 3.0141589
• Make the part before the decimal point 0 by subtracting the integral part, leaving 0.0141589
• In a loop, multiply a by 10 and save the integral part, this gives you a list of digits from 0 to 9.
• From this list, derive the number of decimals

There are some interesting details in this algorithm for you to find out, and I won't spoil the fun or surprises waiting for you.

Answer 4

Consider my string-based solution:

#include <stdio.h>
#include <string.h>
#include <locale.h>
#include <math.h>
#include <float.h>
int countDecimals(double x)
{
    int cnt;
    char * ptr;
    char str[20] = {0};
    // take  fractional part from x
    double ip;
    double fp = modf (x , &ip);
    // printf("%lg + %.15lg\n", ip, fp); // uncomment for debugging
    // to be sure that Decimal-point character is '.'
    setlocale(LC_NUMERIC, "C");
    // make string from number's fractional part asking maximum digits (DBL_DIG)
    sprintf(str,"%.*lg", DBL_DIG, fp);
    // find point
    if( ptr = strchr(str, '.') )
    {
        // calculate length of string after point
        // length - (point position from beginning) - point = number of decimals
        cnt = strlen(str) - (ptr - str) - 1;
    }
    else
    {
        cnt = 0;
    }
    return cnt;
}

int main (void)
{
    double fn;
    printf("Enter a float number: ");
    scanf("%lf", &fn);
    printf("Your number has %d decimals.\n" , countDecimals(fn) );
    return 0;
}

But you should remember about possible rounding and accuracy errors.

Note: I have used double type, for float function modff should be used instead of modf, and FLT_DIG instead of DBL_DIG