Ambiguous call to pow()

[Ganon11]

I was working on a program this morning that required me to use the pow function (to compute 2^i at one point, and 3^i at another). I used the following code:

std::vector<int> increments(static_cast<int>(log(a.size() + 1)/log(2)));
for (int i = 0; i < increments.size(); i++)
    increments[i] = pow(2, i);

and got an error message saying "The call to pow(int, int&) is ambiguous. Candidates are:" and proceeded to list all sorts of pow functions using doubles, long doubles, floats, etc., but no int or long int versions!

Eventually I had to change that last line to

increments[i] = static_cast<int>(pow(static_cast<double>(2), i));

in order to get the dang thing to compile. It produced expected results, but still frustrated me.

Why is there no pow(int, int) function available in the cmath header file?

[RRick]

For most of the functions in cmath, it doesn't make sense to have an integer version. Functions like sine and sqrt don't transfer well to integer.

They did make a version of abs for integers and longs, but pow has been left behind.

Since you are dealing with floating point values for pow, you might run into round off errors when converting to ints. It is advisable to add a small delta to pow before converting to an int.

increments[i] = static_cast<int>(pow(static_cast<double>(2), i)+.005);

[Ganon11]

I agree that sine, sqrt, and exp don't need int versions, but it makes perfect sense to raise an integer to an integer power and expect an integer to result.

[weaknessforcats]

I recommend that you not cast in C++ unless you are on fire.

This is not a fire.

Just write a

int pow(int, int);

as suggested and off you go.

You have to remember that pow() is an old C function and C does not allow for function overloading so everyone had to type cast. Unfortunately, that is an extremely bad habit in C++.

The C++ pow() requires you use a valarray rather than an int. Personally, I think you will have your function working before you understand how to use valarray.

[Ganon11]

All right, I'll keep that in mind for future projects.

Will simply putting a declaration of int pow(int, int) at the top of my program work? Or will I have to provide a definition for the function?

EDIT: Wrote a simple test program to find out that I did need to provide a declaration, so I used the fast exponentiation method we learned in class:

int pow(int base, int power) {
    if (power == 0) return 1;
    if (power == 1) return base;
    if (power % 2 == 0) return pow(base * base, power / 2);
    if (power % 2 == 1) return base * pow(base * base, power / 2);
}

Annoying, if you ask me.

[weaknessforcats]

Will simply putting a declaration of int pow(int, int) at the top of my program work? Or will I have to provide a definition for the function?

The declaration will be enough for the compile step. But you will need the definiton to be compiled for the link step.

Your pow() should allow for negative exponents.

[Laharl]

I had the same result doing this lab, and eventually got it without nasty casting:

pow(2.0, i);

[weaknessforcats]

I had the same result doing this lab, and eventually got it without nasty casting:


Code: ( text )
pow(2.0, i);

It still is a cast. This calls:

double pow(double, double);
 

The int i is automatically cast as a double using the compiler's C++ promotion rules. The probem is that the result is a double when an int is desired.

[Laharl]

If you know that only whole number values will be returned or that a truncated value will be sufficient, you can use floor() to take care of that.

[dhodder]

http://www.cplusplus.com/reference/clibrary/cmath/pow/

Look at the definition for ::pow. I don't see int pow(int, int). Where are you getting this from?

Why not cast in c++? If you know what you're doing - it's no problem.

In what documentation is advising you not to cast? or is this just your personal opinion?


@weaknessforcats