Why Pow(10,5) = 9,999 in C++

Why the result of pow(10,2) 99 instead of 100? [duplicate]

pow(10, 2) yields a value slightly under 100 because it is a low-quality implementation of pow that does not return a good result.

pow is a difficult function to implement, and all commercial implementations produce many results that are inaccurate to some degree. However, good implementations make an effort to get certain cases exactly correct, including cases where the result is exactly an integer (or, for that matter, is rational).

In pow(base, exp), if exp is known to be 2 at compile time, base*base should be used instead—it is fast and accurate and avoids the pow problem. If exp is not known to be two at compile time, the code must be designed to tolerate inaccuracies in pow or other adjustments must be made. (Further advice could be given to questions that are more specific about the circumstances or requirements.)

Why does gcc compiler output pow(10,2) as 99 not 100? [duplicate]

Because of integer truncation. pow() returns a floating point value, and due to floating point arithmetic, it is probably ~ 99.999...; however, due to integer truncation, even 99.999... gets truncated down to 99.

I got different results with pow(10,2) and pow(10,j), j=2;

What's going on is that you have a C implementation whose standard library has a very low quality implementation of pow which is returning inexact results even when the exact result is representable in the type (double). The call to pow(10,2) seems to producing the value just below 100.0, which, when rounded to an integer, yields 99. The reason you don't see this when the arguments are constant is that the compiler took the liberty to optimize out the call alltogether and replace it with a constant 100 at compiletime.

If your intent is to do integer powers, don't use the pow function. Write a proper integer power function, or when the exponent is known, just write out the multiplication directly.

Loss of precision with pow function when surpassing 10^10 limit?

The main reason of problems is pow() function. It works with double, not int. Loss of accuracy is price for representing huge numbers.
There are 3 way's to solve problem:

  1. For small n you can make your own long long int pow(int x, int pow) function. But there is problem, that we can overflow even long long int
  2. Use long arithmetic functions, as @rustyx sayed. You can write your own with vector, or find and include library.
  3. There is Math solution specific for topic's task. It solves the big numbers problem.
    You can write your formula like
    ((10^n) - 1) * (10^n) - (10^m - 1) * (10^m)) / 2 , (here m = n-1)
    Then multiply numbers in numerator. Regroup them. Extract common multiples 10^(n-1). And then you can see, that answer have a structure:
    X9...9Y0...0 for big enought n, where letter X and Y are constants.
    So, you can just print the answer "string" without calculating.

Why is std::pow(int, int) way faster than for loop with integer values?

It completely depends on the quality of std::pow implementation, and the optimization capability of your compiler

For example some standard libraries calculate pow(x, y) as exp(log(x)*y) even for integer exponents, therefor it may be inaccurate and slow, resulting in issues like these

  • Why does pow(5,2) become 24?
  • Why pow(10,5) = 9,999 in C++

But some better pow implementations check if the exponent is integer to use a better algorithm. They also use exponentiating by squaring so they'll be magnitudes faster than your linear multiplication like your for loop. For example for b100000 they need only 17 loops instead of 100000

If a compiler is smart enough to recognize your loop as to calculate power, it may convert to std::pow completely. But probably it's not your case so std::pow is still faster. If you write your pow(int, int) function that uses exponentiating by squaring then it may likely be faster than std::pow

Related Topics

Leave a reply