## 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

Benchmarking was the same for integer or float base or exponent.

Python testing done with:

- Python 3.7.4
- Ipython 7.8.0
- Numpy 1.16.5

`**`

operator

The `**`

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

if inputs are `int`

and arithmetic result is integer.

```
10**(-3)
8.22 ns ± 0.0182 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
pow(10, -3)
227 ns ± 0.313 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
math.pow(10, -3)
252 ns ± 1.56 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
numpy.power(10., -3)
1.5 µs ± 2.91 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
```

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.

## Julia

Julia 1.2.0 was likewise benchmarked under power/ 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.

3.399 nanoseconds

## Go

Go 1.13.1 was benchmarked under power/:

```
go test -bench=Power
```

```
BenchmarkPower-12 33883672 31.8 ns/op
```