## Use ** instead of pow in Python

In Python, `x**y`

is much faster than:

Julia is more than 5 times faster than Python at scalar exponentiation, while Go was in-between Python and Julia in performance.

## Python

The timing was the same for integer or float base or exponent.

Python testing done with:

- Python 3.7.2
- Ipython 7.4.0
- Numpy 1.16.1

`**`

operator

The `**`

operator in Python also has the advantage of returning `int`

if inputs are `int`

and arithmetic result is integer.

`%timeit 10**(-3)`

18.8 ns ± 0.263 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

`pow()`

`%timeit pow(10, -3)`

490 ns ± 5.62 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

`math.pow()`

`%timeit math.pow(10, -3)`

572 ns ± 10.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

`numpy.power()`

Numpy is known in general to be slower at scalar operations than Python-native operators and Python built-in math. But of course Numpy is generally a lot faster and easier for N-dimensional array operations.

`%timeit numpy.power(10, -3)`

3.85 µs ± 440 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

## Julia

Julia 1.1.0 was likewise benchmarked for reference on the same computer. First we installed Julia BenchmarkTools:

```
import Pkg
Pkg.add("BenchmarkTools")
```

The Julia wallclock time for
exponentiation
was the same for `float`

and `int`

as with Python.

```
using BenchmarkTools
function caret(x, y)
z = x ^ y
return z
end
o = @benchmark caret(10, -3.)
println(minimum(o).time, " nanoseconds")
```

3.1 nanoseconds

## Go

Create a file my_test.go containing:

```
package main
import ("math"
"testing")
func BenchmarkPower(b *testing.B) {
for i := 0; i < b.N; i++ {
math.Pow(10, -3)
}
}
```

then run

`go test -bench=Power`

Will result in something like:

```
BenchmarkPower-4 20000000 61.9 ns/op
```