9.2 Optimising with NumPy#

Estimated time for this notebook: 30 minutes

If we have our values in a numpy ndarray, we apply operations to each element in the array in one go, without having to loop over it.

9.2.1 Operations on arrays#

First, we want a ndarray containing the complex values that we previously used as input to our function.

xmin = -1.5
ymin = -1.0
xmax = 0.5
ymax = 1.0
resolution = 300
xstep = (xmax - xmin) / resolution
ystep = (ymax - ymin) / resolution
xs = [(xmin + xstep * i) for i in range(resolution)]
ys = [(ymin + ystep * i) for i in range(resolution)]
# list with complex values
cs_listcomp = [[(x + y * 1j) for x in xs] for y in ys]
import numpy as np
cs = np.asarray(cs_listcomp)
(300, 300)

We now want to compare adding a constant to every element of the array by

  1. using a for loop

  2. using numpy operators.

# we need to make copies of array to avoid overwriting it
cs_loop = cs.copy()
cs_numpy = cs.copy()
for i in range(cs_loop.shape[0]):
    for j in range(cs_loop.shape[1]):
        cs_loop[i][j] = cs_loop[i][j] + 10
34.3 ms ± 47 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Sometimes, you can use operators such as + as if we were dealing with single values. This is because the Numpy ndarrays have overridden the __add__ operation.

cs_numpy + 10
45.6 µs ± 36.6 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

But most Python functions do not know how to handle multi-dimensional arrays so we’ll use Numpy implementations where they exist.

import math

TypeError                                 Traceback (most recent call last)
Cell In[8], line 3
      1 import math
----> 3 math.sqrt(cs)

TypeError: only size-1 arrays can be converted to Python scalars
array([[0.38908588-1.28506335j, 0.38980707-1.28268581j,
        0.39053184-1.28030535j, ..., 0.89141291-0.56090729j,
        0.89409221-0.55922644j, 0.8967725 -0.55755501j],
       [0.38670802-1.2843454j , 0.38742629-1.2819643j ,
        0.38814812-1.27958025j, ..., 0.88972681-0.55822378j,
        0.89241558-0.55654191j, 0.89510532-0.55486953j],
       [0.38432663-1.28363038j, 0.38504193-1.28124573j,
        0.3857608 -1.27885811j, ..., 0.88803965-0.55553075j,
        0.89073797-0.55384788j, 0.89343724-0.55217458j],
       [0.38194169+1.28291834j, 0.38265402+1.28053014j,
        0.3833699 +1.27813894j, ..., 0.88635146+0.55282811j,
        0.88905943+0.55114426j, 0.8917683 +0.54947008j],
       [0.38432663+1.28363038j, 0.38504193+1.28124573j,
        0.3857608 +1.27885811j, ..., 0.88803965+0.55553075j,
        0.89073797+0.55384788j, 0.89343724+0.55217458j],
       [0.38670802+1.2843454j , 0.38742629+1.2819643j ,
        0.38814812+1.27958025j, ..., 0.88972681+0.55822378j,
        0.89241558+0.55654191j, 0.89510532+0.55486953j]])

9.2.2 Attempt 1: Binary Mandelbrot#

Numpy allows us to perform an iteration for our series on all complex values we’re interested in in a single line.

z0 = cs
z1 = z0 * z0 + cs
z2 = z1 * z1 + cs
z3 = z2 * z2 + cs

So can we just apply our mandel function to the whole matrix?

def mandel(constant, max_iterations=50):
    """Computes the values of the series for up to a maximum number of iterations.

    The function stops when the absolute value of the series surpasses 2 or when it reaches the maximum
    number of iterations.

    Returns the number of iterations.

    value = 0

    counter = 0
    while counter < max_iterations:
        if abs(value) > 2:

        value = (value * value) + constant

        counter = counter + 1

    return counter

assert mandel(0) == 50
assert mandel(3) == 1
assert mandel(0.5) == 5
ValueError                                Traceback (most recent call last)
Cell In[12], line 1
----> 1 mandel(cs)

Cell In[11], line 14, in mandel(constant, max_iterations)
     12 counter = 0
     13 while counter < max_iterations:
---> 14     if abs(value) > 2:
     15         break
     17     value = (value * value) + constant

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Looking at the error message, we learn a few things:

  • There’s a problem with line 14, where we check if the value of the series has divereged.

  • There’s some confusion about the truth value of our array. Our array has more than one element (300 x 300 elements to be precise), and the if condition on line 14 returns True for some elements and False for others. But what does True mean for the entire array: Does every element have to be True or is it enough if any element is True? Since there’s no good answer to this, an error is raised.

What if we just apply the Mandelbrot algorithm without checking for divergence until the end:

def mandel_numpy_explode(constants, max_iterations=50):
    """Has the series diverged after all iterations?

    Returns an array with True if the series doesn't explode and False otherwise.
    value = np.zeros(constants.shape)

    counter = 0
    while counter < max_iterations:

        value = (value * value) + constants

        counter = counter + 1

    return abs(value) < 2
result_numpy_explode = mandel_numpy_explode(cs)
/tmp/ipykernel_16739/3334138926.py:11: RuntimeWarning: overflow encountered in multiply
  value = (value * value) + constants
/tmp/ipykernel_16739/3334138926.py:11: RuntimeWarning: invalid value encountered in multiply
  value = (value * value) + constants

We get an Overflow warning that we shouldn’t ignore. The overflow is caused by some values in the series exploding and running off to \(\infty\).

Go to notebook 9.6 Classroom Exercises and do Exercise 9c to fix the overflow issue.

9.2.3 Attempt 2: Return iterations#

The function mandel_binary (see Exercise 9c) runs on an array and is faster than our previous implementations. At the moment, it returns a boolean value for each element of the input: True if the element is in the Mandelbrot set, False otherwise.

It would be nice if the function returned, as before, the number of iterations that were performed. Let’s modify the function to do exactly that:

def mandel_numpy(constants, max_iterations=50):
    """Computes the values of the series for up to a maximum number of iterations.

    The function stops values from exploding once diverged.

    Returns the number of iterations.

    value = np.zeros(constants.shape)
    # An array which keeps track of the first step at which each position diverged
    diverged_at_count = np.ones(constants.shape) * max_iterations
    counter = 0
    while counter < max_iterations:
        value = value * value + constants
        diverging = abs(value) > 2

        # Any positions which are:
        # - diverging
        # - haven't diverged before
        # are diverging for the first time
        first_diverged_this_time = np.logical_and(
            diverging, diverged_at_count == max_iterations

        # Update diverged_at_count for all positions which first diverged at this step
        diverged_at_count[first_diverged_this_time] = counter
        # Reset any divergent values to exactly 2
        value[diverging] = 2
        counter = counter + 1

    return diverged_at_count

assert mandel_numpy(np.asarray([0])) == np.asarray([50])
assert mandel_numpy(np.asarray([4])) == np.asarray([0])
53.7 ms ± 184 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
result_numpy = mandel_numpy(cs)
import matplotlib.pyplot as plt

    result_numpy, interpolation="none", extent=[xmin, xmax, ymin, ymax], origin="lower"
<matplotlib.colorbar.Colorbar at 0x7fbf5f980130>

Even though we’re doing unnecessary calculations (compared to our pure Python implementation), we are much faster.