Does this number have more than D decimal places?

Question

Let's say I want to write a function that does the following:

Given a number N,
when N is rounded to D1 digits
does the result include more than D2 decimal places, not counting trailing zeroes?

For example, say N is .01001, D1 is 4, and D2 is 2. The question becomes, does .0100 include more than 2 decimal places, not counting trailing zeroes? And the answer is "no". But if N was .00101, the answer would be "yes".

I'm looking for an efficient way to do this using standard C library functions, taking into account the limitations of floating-point numbers.

An example of my intended usage: show a number using four digits if necessary, but otherwise show it using two digits.

(This is not a homework question -- this is a result of being a professional programmer who didn't do these kinds of homework questions when he was a student.)

Answer 1

The only easy way to do this with the standard library is to use snprintf (or just sprintf) with the right format, and then count the zeros yourself. Correctly computing the decimal representation of a (binary) floating point number is a very very difficult task that you don't want to try to do yourself, and you have near-zero chance of writing a correct version that's faster than your standard library one.

I hope I got this right; it's untested:

double n; /* the number N */
int d1, d2; /* the parameters d1 and d2 */
char s[MAXLEN], *z;
snprintf(s, sizeof s, "%.*f", d1, n);
for (z=s+strlen(s)-1; *z==0; z--);
if (strlen(++z)<d1-d2) puts("yes");
else puts("no");

Edit: As noted by ssianky, snprintf may have limitations on the precision it prints. Actually the C standard allows pretty much any floating point operation to give the wrong result for no reason whatsoever as long as the implementation documents as such, but IEEE behavior is encouraged, and POSIX additionally requires correctly rounded results up to DECIMAL_DIG places, but allows implementations to print nonsense (for example all zeros) after printing sufficiently many places to uniquely determine the actual floating point value. So to make a long story short, if d1 is reasonably large, or if your platform is pathological, snprintf-based approaches might not give the right answer. (In practice they'll give the right answer on GNU systems and the wrong answer on Microsoft systems.)

If you care about this shortcoming and want correct results for any value of d1, you'll have to implement exact float-to-decimal code yourself. Loops that involve multiplying a floating point value repeatedly by 10 will not suffice for this.

Edit 2: Looking at the OP's "intended usage", using snprintf seems like a no-brainer. If you want to print the value to begin with and are just trying to decide how many decimal places to use, just print it to a string and then chop off the trailing zeros before displaying it. In fact, the %g printf format specifier might even do what the OP wants already...

Answer 2

You can first multiply your number by 10^D1 and round it to the nearest integer, then check if it's divisible by 10^D2. There are a handful of rounding functions to choose from that will round up/down/away from zero/etc., so be sure to check that you're using the one you want.

The function below is written so that it is small and self-contained, but a production implementation should use a lookup table for the powers of ten as indicated in the comment lines. This will yield faster performance and avoid error accumulating in the floating-point product.

int f (double N, unsigned int D1, unsigned int D2)
{
   int i, n_mult_round, ten_d2;
   /* instead of the loop below, a real implementation should use */
   /* N *= dbl_powers_of_ten[D1]; */
   /* where dbl_powers_of_ten is a double array containing powers of ten */
   for (i = 0; i < D1; ++i) {
      N *= 10.0;
   }
   n_mult_round = (int) round (N);
   /* instead of the loop below, a real implementation should use */
   /* ten_d2 = int_powers_of_ten[D2]; */
   /* where int_powers_of_ten is an int array containing powers of ten */
   ten_d2 = 1;
   for (i = 0; i < D2; ++i) {
      ten_d2 *= 10;
   }
   if ( n_mult_round % ten_d2 == 0 ) {
      return ( 1 );
   }
   else {
      return ( 0 );
   }
}

Answer 3

1. Format it as a string to the max precision.
2. Remove zeros from the right until you reach the min precision.

Here's an unsafe implementation to get you started:

char buff[20]; /* make as big as necessary */
int maxPrecision = 4;
int minPrecision = 2;

sprintf(buff, "%.*f", maxPrecision, myFloat);

char *p = buff + (strlen(buff) - 1);
char *punct = strchr(buff, ".");

/* remove trailing zeros until we reach minPrecision */
while (*p == '0' && p > (punct + minPrecision))
    *p-- = 0; 

Answer 4

What about this? fmod should return the decimals after the specified number of decimal places, so we can compare those two numbers to see if they're equal.

int needsD1Decimals(float N, int D1, int D2) {
    float pow1 = pow(0.1f, D1); // 0.0001
    float pow2 = pow(0.1f, D2); // 0.01
    float mod1 = fmod(N, pow1); // 0.00001
    float mod2 = fmod(N, pow2); // 0.00001
    if (fabs(mod1 - mod2) > (pow1 / 2)) { // > 0.00005 to handle errors
        return 1;
    }
    return 0;
}

If you're just wanting to print out the correct answer, it might be faster to just print it with the most decimal places and truncate the zeros at the end:

void printNumber(float N, int D1, int D2) {
    char format[256];
    char result[256];
    sprintf(format, "%%.%df", D1);
    sprintf(result, format, N);
    char *end = result + strlen(result) - 1;
    int zeros = 0;
    while (end > result && end[0] == '0' && zeros < (D1 - D2))
    {
        zeros++;
        end--;
    }
    if (zeros >= (D1 - D2))
    {
        end[1] = '\0';
    }
    puts(result);
}

void doNumber(float N, int D1, int D2) {
    printf("%f, %d, %d: ", N, D1, D2);
    printNumber(N, D1, D2);
    printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
    doNumber(0.01001f, 4, 2);
    doNumber(0.010101f, 4, 2);
    doNumber(0.011001f, 4, 2);
    doNumber(5000.0f, 4, 2);
    return 0;
}

Answer 5

int foo(float number, int d1, int d2)
{
    assert((number > 0.0f) && (number < 1.0f) && (d1 <= FLT_DIG) && (d2 < d1) && (d2 > 0));

    int count = d1;
    int n = (int)(number * pow(10.0f, d1));

    if (n == 0) return 0;

    while ((n % 10) == 0)
    {
        n /= 10;
        count--;
    }

    return (count > d2) ? 1 : 0;
}