pow() works with real floating-point numbers and uses under the hood the formula pow(x,y) = e^(y log(x)) to calculate x^y. The int are converted to double before calling pow. (log is the natural logarithm, e-based) x^2 using pow() is therefore slower than x*x. Edit based on relevant comments Using pow even with integer exponents may … Read more
(-1.07)1.3 will not be a real number, thus the Math domain error. If you need a complex number, ab must be rewritten into eb ln a, e.g. >>> import cmath >>> cmath.exp(1.3 * cmath.log(-1.07)) (-0.6418264288034731-0.8833982926856789j) If you just want to return NaN, catch that exception. >>> import math >>> def pow_with_nan(x, y): … try: … … Read more
In C++ The result of pow(0, 0) the result is basically implementation defined behavior since mathematically we have a contradictory situation where N^0 should always be 1 but 0^N should always be 0 for N > 0, so you should have no expectations mathematically as to the result of this either. This Wolfram Alpha forum … Read more
Floating point precision is doing its job here. The actual working of pow is using log pow(a, 2) ==> exp(log(a) * 2) Look at math.h library which says: ###<math.h> /* Excess precision when using a 64-bit mantissa for FPU math ops can cause unexpected results with some of the MSVCRT math functions. For example, unless … Read more
pow works with double numbers. These represent numbers of the form s * 2^e where s is a 53 bit integer. Therefore double can store all integers below 2^53, but only some integers above 2^53. In particular, it can only represent even numbers > 2^53, since for e > 0 the value is always a … Read more
The function pow operates on two floating-point values, and can raise one to the other. This is done through approximating algorithm, as it is required to be able to handle values from the smallest to the largest. As this is an approximating algorithm, it sometimes gets the value a little bit wrong. In most cases, … Read more
Using the power operator ** will be faster as it won’t have the overhead of a function call. You can see this if you disassemble the Python code: >>> dis.dis(‘7. ** i’) 1 0 LOAD_CONST 0 (7.0) 3 LOAD_NAME 0 (i) 6 BINARY_POWER 7 RETURN_VALUE >>> dis.dis(‘pow(7., i)’) 1 0 LOAD_NAME 0 (pow) 3 LOAD_CONST … Read more
You can write your own, using repeated squaring: BigInteger pow(BigInteger base, BigInteger exponent) { BigInteger result = BigInteger.ONE; while (exponent.signum() > 0) { if (exponent.testBit(0)) result = result.multiply(base); base = base.multiply(base); exponent = exponent.shiftRight(1); } return result; } might not work for negative bases or exponents.
Add 0.5 before casting to int. If your system supports it, you can call the C99 round() function, but I prefer to avoid it for portability reasons.