Strange behaviour of the pow function

Question

While running the following lines of code:

int i,a;    

for(i=0;i<=4;i++)  
{    
    a=pow(10,i);    
    printf("%d\t",a);    
}   

I was surprised to see the output, it comes out to be 1 10 99 1000 9999 instead of 1 10 100 1000 10000.

What could be the possible reason?

Note
If you think it's a floating point inaccuracy that in the above for loop when i = 2, the values stored in variable a is 99.

But if you write instead

a=pow(10,2);

now the value of a comes out to be 100. How is that possible?

Answer 1

No one spelt out how to actually do it correctly - instead of pow function, just have a variable that tracks the current power:

int i, a, power;    

for (i = 0, a = 1; i <= 4; i++, a *= 10) {    
    printf("%d\t",a);    
}

This continuing multiplication by ten is guaranteed to give you the correct answer, and quite OK (and much better than pow, even if it were giving the correct results) for tasks like converting decimal strings into integers.

Answer 2

Mathematically, the integer power of an integer is an integer.

In a good quality pow() routine this specific calculation should NOT produce any round-off errors. I ran your code on Eclipse/Microsoft C and got the following output:

1   10  100 1000    10000   

This test does NOT indicate if Microsoft is using floats and rounding or if they are detecting the type of your numbers and choosing the appropriate method.

So, I ran the following code:

#include <stdio.h>
#include <math.h>
main ()
{
    double i,a;

    for(i=0.0; i <= 4.0 ;i++)
    {
        a=pow(10,i);
        printf("%lf\t",a);
    }
}

And got the following output:

1.000000    10.000000   100.000000  1000.000000 10000.000000    

Answer 3

The function pow() returns a double. You're assigning it to variable a, of type int. Doing that doesn't "round off" the floating point value, it truncates it. So pow() is returning something like 99.99999... for 10^2, and then you're just throwing away the .9999... part. Better to say a = round(pow(10, i)).

Answer 4

This is to do with floating point inaccuracy. Although you are passing in ints they are being implicitly converted to a floating point type since the pow function is only defined for floating point parameters.

Answer 5

I can't even spell c, but I can tell you why.

You have set a to be an int. pow() generates a floating point number, that in SOME cases may be just a hair less than 100 or 10000 (as we see here.)

Then you stuff that into the integer, which TRUNCATES to an integer. So you lose that fractional part. Oops. If you really needed an integer result, round may be a better way to do that operation.

Be careful even there, as for large enough powers, the error may actually be large enough to still cause a failure, giving you something you don't expect. Remember that floating point numbers only carry so much precision.