exponent

I am basically making a Java program that will have to run a lot of calculations pretty quickly(each frame, aiming for at least 30 f/s). These will mostly be trigonometric and power functions. The question I'm asking is: Which is faster: using the already-supplied-by-Java Math functions? Or writing my own functions to run? The built-in Math functions will be extremely difficult to beat, given that most of them have special JVM magic that makes them use hardware intrinsics. You could conceivably beat some of them by trading away accuracy with a lot of work, but you're very unlikely to beat the

For example I want to calculate (reasonably efficiently) 2^1000003 mod 12321 And finally I want to do (2^1000003 - 3) mod 12321. Is there any feasible way to do this? Basic modulo properties tell us that 1) a + b (mod n) is (a (mod n)) + (b (mod n)) (mod n) , so you can split the operation in two steps 2) a * b (mod n) is (a (mod n)) * (b (mod n)) (mod n) , so you can use modulo exponentiation (pseudocode): x = 1 for (10000003 times) { x = (x * 2) % 12321; # x will never grow beyond 12320 } Of course, you shouldn't do 10000003 iterations, just remember that 2 1000003 = 2 * 2 1000002 , and 2

So, I have the following code in R: y a <- -0.1 test <- (1/((y+as.numeric(!y))*(a-1))) test test^a -0.9090909^a Giving me the output: > y [1] 0.00000000 0.06024096 0.00000000 0.01098901 0.00000000 0.00000000 [7] 0.01829268 0.00000000 0.06976744 0.00000000 0.04380665 0.01351351 [13] 0.00000000 0.00000000 0.00000000 0.00000000 0.00310559 0.00000000 [19] 0.00000000 0.00000000 0.09957447 0.00000000 0.03738318 0.00000000 > a <- -0.1 > test <- (1/((y+as.numeric(!y))*(a-1))) > test [1] -0.9090909 -15.0909091 -0.9090909 -82.7272727 -0.9090909 [6] -0.9090909 -49.6969697 -0.9090909 -13.0303030 -0

I'm running some code where in the middle I have this line: e2 = np.exp(dot1) If I print out the value dot1 , it is: [[-30.248272500719885]] But the line produces this error: e2 = np.exp(dot1) AttributeError: exp If I go to a new window and simply code this: print numpy.exp([[-30.248272500719885]]) there are no problems... then what's wrong with the above code? Edit I've added some surrounding code to the original line: import numpy as np # LOTS OF CODE INCLUDING THE INITIALIZATION OF ARRAYS y and self.g # AND getting into into a loop with index i for j in range(m): print "Calculating beta for

Which is faster in GLSL: pow(x, 3.0f); or x*x*x; ? Does exponentiation performance depend on hardware vendor or exponent value? While this can definitely be hardware/vendor/compiler dependent, advanced mathematical functions like pow() tend to be considerably more expensive than basic operations. The best approach is of course to try both, and benchmark. But if there is a simple replacement for an advanced mathematical functions, I don't think you can go very wrong by using it. If you write pow(x, 3.0) , the best you can probably hope for is that the compiler will recognize the special case,