pow

I have seen various answer here that depicts Strange behavior of pow function in C. But I Have something different to ask here. In the below code I have initialized int x = pow(10,2) and int y = pow(10,n) (int n = 2) . In first case it when I print the result it shows 100 and in the other case it comes out to be 99 . I know that pow returns double and it gets truncated on storing in int , but I want to ask why the output comes to be different. CODE1 #include<stdio.h> #include<math.h> int main() { int n = 2; int x; int y; x = pow(10,2); //Printing Gives Output 100 y = pow(10,n); //Printing

What's going on here: #include <stdio.h> #include <math.h> int main(void) { printf("17^12 = %lf\n", pow(17, 12)); printf("17^13 = %lf\n", pow(17, 13)); printf("17^14 = %lf\n", pow(17, 14)); } I get this output: 17^12 = 582622237229761.000000 17^13 = 9904578032905936.000000 17^14 = 168377826559400928.000000 13 and 14 do not match with wolfram alpa cf: 12: 582622237229761.000000 582622237229761 13: 9904578032905936.000000 9904578032905937 14: 168377826559400928.000000 168377826559400929 Moreover, it's not wrong by some strange fraction - it's wrong by exactly one! If this is down to me reaching

We all know that 0 0 is indeterminate. But , javascript says that: Math.pow(0, 0) === 1 // true and C++ says the same thing: pow(0, 0) == 1 // true WHY? I know that: >Math.pow(0.001, 0.001) 0.9931160484209338 But why does Math.pow(0, 0) throw no errors? Or maybe a NaN would be better than 1 . 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

So I was googling for a long time and i found almost nothing. I found some info about possible implementation of Math.Pow from this url , but they are inaccurate, for example this code public static double PowerA(double a, double b) { int tmp = (int)(BitConverter.DoubleToInt64Bits(a) >> 32); int tmp2 = (int)(b * (tmp - 1072632447) + 1072632447); return BitConverter.Int64BitsToDouble(((long)tmp2) << 32); } static void Main(string[] args) { double x = 12.53, y = 16.45; Console.WriteLine(Math.Pow(x, y)); Console.WriteLine(PowerA(x, y)); } provides output: 1,15158266266297E+18 8,9966384455562E+17

Which one is more efficient using math.pow or the ** operator? When should I use one over the other? So far I know that x**y can return an int or a float if you use a decimal the function pow will return a float import math print math.pow(10, 2) print 10. ** 2 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 0 (7.0) 6 LOAD_NAME 1 (i) 9 CALL

In my little project I need to do something like Math.pow(7777.66, 5555.44) only with VERY big numbers. I came across a few solutions: Use double - but the numbers are too big Use BigDecimal.pow but no support for fractional Use the X^(A+B)=X^A*X^B formula (B is the remainder of the second num), but again no support for big X or big A because I still convert to double Use some kind of Taylor series algorithm or something like that - I'm not very good at math so this one is my last option if I don't find any solutions (some libraries or a formula for (A+B)^(C+D)). Anyone knows of a library or