CODING MANDELBROT & PYTHON

PYTHON: MAKE YOUR OWN

TUTORIAL
MANDELBROT SET
With a smattering of Python and a bit of clever maths you too can
TARIQ RASHID
create a bit of beautiful chaos inside your Linux box.

T
he image below depicts the famous code files and using shells to execute the programs.
WHY DO THIS? Mandelbrot set. You may have seen it on You can also share your web-based “notebooks” by
• Create hugely complex posters, music videos or demonstrations of exporting them, or sharing them online.
results from a simple
equation. computer power – back in the 1990s it took hours to There are pre-packaged distributions of IPython
• Turn this into pretty plot it using home computers. Despite its organic including the numerical and graphical extensions, so
graphs! intricate appearance it is in fact the result of extremely you don’t have to worry about installing and
simple mathematics. configuring the right versions and their many
The maths hasn’t changed since the 1990s, but dependencies. Even better, because IPython is used
computing power has come on in leaps and bounds, purely through a web browser, you can use one of
so the psychedelic beauty of the Mandelbrot set can several online services offering IPython in the cloud.
be ours to play with. We’ll be using the Python You don’t have to install any software at all, and you
programming language because it’s popular, easy to can work on your code and demonstrate the results
learn, and has well established numerical and plotting from any internet-connected device that supports a
extensions. It’s no accident that Python is the tool of modern browser.
choice in the scientific community, as well as The code in this article series was tested with the
powering some of the world’s largest infrastructures. online service from wakari.io, which offers free trial
The following images
As an interpreted, rather than compiled language, accounts, and the locally installed IPython Anaconda
are closeups of parts of
this same fractal. The Python gives immediate feedback. We’re going to take free distribution from continuum.io.
Mandelbrot set is in fact this interactivity one step further by using IPython, Whether you select an online service or install your
infinitely detailed, and which is Python packaged with an interactive web own IPython distribution, check to see if it works by
contains a wide variety of interface. You can just type instructions and get firing it up and clicking on New Notebook. Type 2*3
patterns. results straight away. You avoid having to edit source into it and click the Run button, which looks like an
audio play selector. If it responds with ‘6’, great – you
have a working IPython environment!

Beginning Python
Let’s now learn just enough Python to make our own
Mandelbrot fractal. Fire up IPython and open a new
notebook. In the next ready cell, labelled In [ ], type the
following code and click Play (or press Ctrl+Enter).
print “Hello World!”
You should get a response that simply prints the
phrase “Hello World!” You should see that issuing the
second instruction didn’t remove the previous cell with
its instruction and output answer. This is useful when
you’re slowly building up a solution of several parts.
The following code introduces the key idea of
variables. Enter and run it in a new cell. If there is no
new empty cell, click the button with the downward
pointing arrow labelled ‘Insert Cell Below’, not to be
confused with the one labelled “Move Cell Down”.
x = 10
print x
print x+5
print z
The first line, x = 10, looks like a mathematical
statement that says x is 10. In Python this means that
x is set to 10, that is, the value 10 is placed in an
virtual box called x. That 10 stays there until further

96 www.linuxvoice.com
 MANDELBROT & PYTHON CODING

Fractals
Before we dive in and start coding, let’s take a is entirely random noise – there isn’t a lack of patterns with just the right amount of unpredictable
step back and consider again some of the patterns detail, but now there isn’t enough structure in the variation. These patterns are called fractals.
we find in nature or create ourselves. Look at the image to keep us interested. The cauliflower has The Mandelbrot fractals appear natural, organic
following three images. repeated patterns at different scales. These and even beautiful because they too sit at that fine
The first set of shapes is very regular. They’re patterns also have just the right amount of variation line between order and chaos, having structures
what most people would consider mathematical to keep us interested. This is a common theme that have self-similar patterns but infused with just
shapes, but there isn’t enough interesting detail in throughout nature, where clouds, mountains, rivers, enough variation – and parts of these fractals do
them to hold our attention for long. The last image trees, blood vessels etc all have self-similar look like plants, lightning or natural coastlines.

notice. We shouldn’t be surprised that print x prints in is the bit that creates a loop, and here it does
the value of x, which is 10. Why doesn’t it just print x? something for every number in the list, and keeps
Python will evaluate whatever it can, and x can be count by assigning the current value to the variable n.
evaluated to the value 10, so it prints that. The next We saw variables earlier, and this is just like assigning
line, print x+5 evaluates x+5, which is 10+5 or 15, so n=0 during the first pass of the loop, then n=1, then
we expect it to print 15. n=2, until n=9, the last item in the list.
What happens with the line print z when we haven’t The next line print n prints the value of n, just as
assigned a value to it like we have with x? We get an before. We expect all the numbers in the list to be
PRO TIP
error message telling us about the error of our ways, printed. But notice the indent before print n. This is Explore the Mandelbrot
fractal using the
trying to be helpful as possible so we can fix it. important in Python as indents are used meaningfully interactive XaoS open
to show which instructions are subservient to others, source software at
Automating lots of work in this case, the loop created by for n in .... The loop http://bit.ly/1vLdz52 or
through a web browser
Computers are great for doing similar tasks many ends when the code stops being indented. Here, we’ve http://bit.ly/1lbXYL1.
times – they don’t mind and they’re very quick used a pass instruction to highlight the end of the loop
compared with humans with calculators. Let’s see if (pass is superfluous, and Python will ignore it but it
we can get a computer to print the first 10 squared helps the interpreter exit a code block. You can remove
numbers, starting with 0 squared, 1 squared, then 2 it if you want). This means we only expect done to be
squared and so on. We expect to see a printout of printed once, and not 10 times.
something like 0, 1, 4, 9, 16, 25, and so on. Issue the It should be clear now that we can print the squares
following code into the next ready cell and run it. by printing n*n. In fact we can make the output more
range(10) helpful with phrases like “The square of 3 is 9”. The
You should get a list of 10 numbers, from 0 up to 9. following code shows this change inside the loop.
This is great because we got the computer to do the Note how the variables are not inside quotes and are
work to create the list – we didn’t have to do it therefore evaluated.
ourselves. for n in range(10):
A common way to get computers to do things print “The square of”, n, “is”, n*n
repeatedly is by using loops. The word loop does give pass
you the right impression of something going round print “done”
and round potentially endlessly. Rather than define a This is already quite powerful. We can get the
loop, it’s easiest to see a simple one. Enter and run computer to do a lot of work very quickly. We could
following code in a new cell. easily make the number of loop iterations much larger
for n in range(10): by using range(100) or even range(100000) if we
print n wanted. Try it!
pass
print “done” Functions
There are three new things going on here. The first Python makes it easy to create reusable computer
line has the range(10) command that we saw before, instructions. Like mathematical functions, these
which creates a list of numbers from 0 to 9. The for n reusable snippets of code, also called functions, stand

www.linuxvoice.com 97
 CODING MANDELBROT & PYTHON

# and outputs their average

def avg(x,y):
print “first input is”, x
print “second input is”, y
a = (x + y) / 2.0
print “average is”, a
return a
The first two lines beginning with # are ignored by
Python, but we use them to add comments for future
readers. The next bit, def avg(x,y), tells Python we are
about to define a new reusable function. That’s the def
keyword. The avg part is the name we’ve given it. It
could have been called “banana” or “pluto” but it
makes sense to use names that remind us what the
function actually does. The bits in brackets (x,y) tells
Python that this function takes two inputs, to be called
x and y inside the definition of the function.
Now that we’ve signalled to Python that we’re about
to define a function, we need to actually tell it what the
function is to do. This definition of the function is
indented under def. The first and second numbers, x
and y, which the function receives when it is invoked
are printed. The next bit calculates (x+y)/2.0 and
assigns the value to the variable named a, before it is
printed. The last statement says return a. This is the
end of the function and tells Python what to return
back to whoever invoked it.
The amazing thing is
that all this detail and on their own if you define them sufficiently well, and When we ran this code, it didn’t seem to do
variety emerges from the allow you to write shorter more elegant code. Why anything. There were no numbers produced. That’s
behaviour of a very simple shorter code? Because invoking a function by its because all we’ve done is define the function; we
mathematical function; name many times is better than writing out all the haven’t used it yet. What has actually happened is that
z2+c. function code many times. (By sufficiently well Python has noted this function and will keep it ready
defined we mean being clear about what kinds of for when we want to use it.
input a function expects, and what kind of output it In the next cell enter avg(2,4) to invoke this function
produces. Some functions will only take numbers as with the inputs 2 and 4. The output should be what we
input, so you can’t supply it with text.) expect, with the function printing a statement about
Let’s look at a simple function and play with it. Enter the two input values and the average it calculated. The
the following code and run it. following shows the function definition and the results
# function that takes 2 numbers as input of calling it with avg(2,4) and also bigger values (200,

PRO TIP Explore fractals in a web browser

In Python, like many You can explore the Mandelbrot fractal without installing any image. You can then point at a new point in the closer view, or
programming languages, software at all. The following two are implemented entirely in go back and pick a new point to explore from.
the = equals sign means
JavaScript, so you only need a modern browser to explore the The explorer at http://mandelbrot-set.com requires you
“is set to”. So x=5 means
x is set to 5 until, and fractals. Have a go! to use your pointer to select a rectangle to zoom into. The
if, it is updated later. The explorer at http://davidbau.com/mandelbrot enables level of detail calculated rapidly is impressive. You can select
This is different from you to progressively click on points to cretae a new closer different colour schemes with the options menu.
the mathematical or
logical equivalence,
which can confuse new
programmers.

The simple folk of the 90s would be awed and terrified to see the Mandelbrot set calculated in a browser.

98 www.linuxvoice.com
 MANDELBROT & PYTHON CODING

301). Experiment with your own inputs.

You may have noticed that the function code which
calculates the average divides the sum of the two
inputs by “2.0” and not just “2”. This is because “2” is
an integer and so Python will round the result to an
integer as well, which we don’t want here.

Arrays
Arrays are just tables of values. You refer to particular
cells with the row and column number, just like you
would with cells in a spreadsheet.
Enter and run the following code.
a = zeros( [3,2] )
print a
This creates an array of shape 3 by 2, with all the
cells set to the value zero and assigns the whole thing
to a variable named a. Printing a shows the array full
of zeros in what looks like a table with three rows and
two columns.
Now let’s modify the contents of this array. The
following code shows how you can refer to specific
cells to overwrite them with new values. It’s just like
referring to spreadsheet cells or street map grid
references.
a[0,0] = 1
a[0,1] = 2
a[1,0] = 9
a[2,1] = 12 An example of the images
print a doing just this. produced by the code
The first line updates the cell at row zero and print a[0,1] teaser, below. Can you
column zero with the value 1, overwriting whatever v = a[1,0] figure out how it works?
was there before. The other lines are similar updates, print v
with a final printout. Remember that the column and row numbering
Now that we know how to set the value of cells in starts from 0 and not 1, so the top-left is at [0,0] not
an array, how do we look them up without printing out [1,1]. This also means that the bottom-right is at [2,1]
the entire array? We’ve been doing it already. We not [3,2].
simply use the expressions like a[1,2] or a[2,1] to refer
to the content of these cells. The code shows us Plotting arrays
PRO TIP
Visualising arrays graphically is sometimes more
Remember that in
insightful than looking at large tables of numbers. We Python, indents have
can think of them as flat two-dimensional surfaces, meaning. Instructions
coloured according to the value at each cell in the that are subservient to
another are indented.
array. Let’s plot the small 3 x 2 array we created above: This includes function
imshow(a, interpolation=”nearest”) definitions and the
The instruction to create a plot is imshow(), and the contents of loops. An
errant space or tab can
first parameter is the array we want to plot. That last cause hard-to-spot errors.
bit, interpolation, is there to tell Python not to try to
blend the colours to make the plot look smoother,
which it does by default. The output is shown in the
image below.
As a teaser of things to come, the following short
PRO TIP
code will plot different images every time you run it.
Experiment with the
See if you can work out how it works using the online imshow() function
Python documentation. by trying different
import numpy as np options explained in its
documentation at
figsize(5,5) http://bit.ly/1lu1mkB.
imshow(np.random.rand(10,10), interpolation=”lanczos”)
The array cells which have the same value also have the To really appreciate the Mandelbrot fractal we need
same colour. When we plot the Mandelbrot set, we’ll be to experience for ourselves the unexpected behaviour
using this very same imshow instruction. of very simple mathematical functions that lead to

www.linuxvoice.com 99
 CODING MANDELBROT & PYTHON

its intricate patterns. You don’t need to be an expert parameter r.

in mathematics to follow and appreciate the same For some seed values and parameters r, the
surprise felt by those researchers who first pictured function behaves like a divergent or a convergent
the Mandelbrot set in the late 1970s. function. But for some, such as x=0.2 and r=3, the
function seems to oscillate. This is certainly
Iteration unexpected behaviour!
You can imagine a mathematical function as a What’s more, for some other values like x=0.2 and
machine that does some work. Its job is to take r=4 the behaviour breaks down into something
numbers in one end, the input, and spit out a new unrecognisable, apparently random. This is known as
number out the other end, the output. What happens chaos. Not only is this behaviour surprising from such
if we feed the output of one of these functions back a simple function, it was only really appreciated in the
into it again as the input? last 100 years or so of mathematics, which itself goes
Let’s try it with the function “divide by 3” and starting back thousands of years.
value of 9. We get the sequence 9, 3, 1, , … You can We’re going to see if we can feed our functions a
see the numbers getting ever smaller, and in fact new kind of number called a complex number. You
they’d never get to zero. may remember these from school, but if not, we’ll
Iteration simply means doing the same thing again explain them here.
and again to produce a series of outputs. If the values Complex numbers have two parts. They are
keep growing larger forever, like those from the two-dimensional, and so can be used to refer to points
PRO TIP “multiply by 2” function, we say the values diverge. If in a flat plane just like grid coordinates. These two
It’s good practice to to they approach a finite value, like zero, like the “divide parts just happen to be called the real and imaginary
design your functions
to always return the by 3” function, we say the values converge. parts. We can add and subtract these numbers very
same result for the easily by combining the real and imaginary parts
same set of inputs. Starting conditions separately. For example 1+2i added to 3+4i is 4+6i (4
When your programs
grow in complexity, this Some functions behave differently depending on their is the real part and 6i is the imaginary part).
is a guarantee that will starting value – in these cases, we say they are Multiplying complex numbers is just like school
help keep your code sensitive to initial conditions. Consider the function algebra. The brackets are expanded and similar terms
understandable and aid
debugging. “square it” which simply takes an input and multiplies are recombined, but there is one special rule for
it by itself. If the starting value is greater than 1, the complex numbers: any i2 is replaced by -1. For
successive outputs keep growing larger. If the seed example (2+3i)*(1+4i) is 2 + 8i + i3 + 12i2 which
value is smaller than 1, the values keep getting simplifies to (-10+11i).
smaller. A seed value of exactly 1 stays the same, and Python can work with complex numbers out of the
separates the two domains of divergence and box. We use the form complex(a,b) to tell Python we
convergence. This idea of domains of different mean a+ib where a is the real part and b is the
behaviour is important for the Mandelbrot fractal imaginary part of the complex number. Try the
because that is exactly what it is showing – regions of following in an IPython notebook.
divergence and convergence. # assign the complex number (2+3i) to c
Other kinds of behaviour were discovered only c = complex(2,3)
Orbit plot showing
successive values of z^2+c recently in the long history of mathematics. The print c
when c=0.4+0.4i. You can Logistic Map is a function rx(1-x) that was developed
see an initial circling then by scientists trying to model population growth. The # print c multiplied by (1 - 4i)
a sudden divergence. behaviour is very sensitive to the starting value and print c * complex(1,-4)

iterate function “z 2+c”, start value z-0+0i, # print c squared

>

c=0.4+0.41, orbit plot print c*c

The behaviours we saw earlier, including oscillation
5 and chaos, also occur for functions working on
complex numbers, except they take place in two
dimensions. The successive values from a function
2.5
are called orbits. The plot below-left shows successive
values for the simple function z2+c with z starting at 0
imaginary

0 and c=0.4+0.4i. You can see that after an initial

circling, the values suddenly diverge – not the
behaviour we were used to at school with less
-2.5 interesting functions!

Mandelbrot fractal recipe

-5
-5 -2.5 0 2.5 5 The Mandelbrot set is just a two-dimensional atlas
coloured to show which regions of its world, the
real two-dimensional complex plane, diverge or converge

100 www.linuxvoice.com
 MANDELBROT & PYTHON CODING

when the amazingly simple function z2+c is applied

iteratively. Here z starts at 0, and c is the complex
number representing the chosen point on the complex
plane. If a chosen point diverges and gets bigger and 10 -7 3
bigger it is considered outside the Mandelbrot set. We
could colour all such points one colour, but it is
common to chose a colour according to how rapid the
divergence is. The points inside the set, those which multiply
3 by -1 -3
don’t diverge, are usually coloured black.
It turns out, to many people’s surprise, that the
boundary between the two is not a boring shape like a
circle but is incredibly detailed and intricate, and in
fact beautiful – it is the famous Mandelbrot fractal!
4 square 16
Mandelbrot set in Python
We’ll build up a Python program to calculate and plot
a Mandelbrot fractal in easy to understand pieces.
Let’s start at the core of the Mandelbrot calculation.
Some examples of
For each point being tested on a selected rectangle of the maximum maxiter, or is stopped sooner by a
functions: the square
the complex plane, the function z2+c is repeatedly magnitude threshold test. What’s left is to fill in the functions takes an input of
iterated the resulting values may diverge rapidly. The code describing the iterated function z2+c and then 4 and squares it, producing
point is coloured according to how quickly that check to see if the threshold has been breached. the resulting answer 16.
function diverges. This means the Python function we These are fairly easy, so let’s write them out and
want to write returns the number of iterations it takes explain them.
to diverge beyond a threshold magnitude. The def mandel(c, maxiter):
function still needs to calculate successive values of z = complex(0,0)
z2+c, it just doesn’t have to return them. So the start
and end of the core calculating Python function, which for iteration in xrange(maxiter):
we’ll call mandel(), looks like the following. z = (z*z) + c
def mandel(c):
.. if abs(z) > 4: PRO TIP
.. break There are several kinds
return iterations pass of convergence you’ll
find if you experiment
What if the point doesn’t diverge? We can define the with these and similar
maximum number of iterations the function is to be pass functions. Successive
applied before giving up. We can pass it as a values will get closer
to, but never reach,
parameter to the core mandel() function. The function return iteration
zero or a finite value.
would then look something like mandel(c, maxiter). Here we’ve added the z = (z * z) + c instructions, Alternatively, they will
Why would we need to change it? Well, as you explore which calculates the next value of z based on the fluctuate above and
below a value as they get
the Mandelbrot fractal’s finer detail, you need more current value and the chosen c. We then check to see ever closer to it. In some
iterations to establish whether very close points if the magnitude, or absolute value denoted abs() in cases they might orbit
behave differently or not. Python, of c is greater than 4, and if it is, the instruction about a finite number of
different attractors, that
We now have a mandel() function that takes the break simply breaks out of the for loop. Once this is, multiple points which
test point c, and the maximum number of iterations happens there are no more instructions after the loop, seem to pull them closer.
as its parameters: and so the mandel(c,maxiter) function returns the
def mandel(c, maxiter):
z = complex(0,0) PRO TIP
Resources
Complex numbers really
for iteration in xrange(maxiter): aren’t complex. The term
If you’d like a fuller explanation of the mathematics and is an accident of history,
… Python discussed in this series, you’ll find the Make Your and sadly puts some
… Own Mandelbrot ebook (Amazon and Google) takes a people off them. If they
… slower journey with more examples and discussion. All the were called composite
source code can be found at the blog. numbers, that would
pass
Source code http://makeyourownmandelbrot.blogspot. reflect the fact that
co.uk/2014/04/sharing-code.html they are made up of two
return iteration IPython http://ipython.org/install.html independent parts.
We set the starting value of z to be zero, or more Wakari.io www.wakari.io
precisely (0+0i). The for .. code loop, which iterates a XaoS http://matek.hu/xaos/doku.php
maximum of maxiter times, keeps count in the Blog http://makeyourownmandelbrot.blogspot.co.uk
Amazon Kindle ebook www.amazon.co.uk/dp/
variable named iteration. The end of the function is B00JFIEC2A
still returning the iteration count, whether that reaches

www.linuxvoice.com 101
 CODING MANDELBROT & PYTHON

PRO TIP Arithmetic with complex numbers

You can find a visual
representation and The following table summarises how to add, subtract and multiply complex numbers.
gentler explanation of the
algorithm to calculate
and plot the Mandelbrot
Operation How to do it
fractal at
http://bit.ly/1qK78e3 Add the two complex numbers (a + bi) and (c + di) (a + bi) + (c + di) = (a+c) + (b+d)i
Add the real and imaginary parts independently.

Subtract the complex number (c + di) from (a + bi) (a + bi) - (c + di) = (a-c) + (b-d)i
Subtract the real and imaginary parts independently.

Multiply the two complex numbers (a + bi) * (c + di) (a + bi) * (c + di) = (ac + adi + bci + dbi2) = (ac-bd) + (ad+bc)i
Expand out the terms and apply the special rule that i2 is -1.
Then collect real and imaginary parts to make a neat answer.

value of iteration. If the point doesn’t diverge, then x_list = linspace( -2.0, 4.0, 13)
abs(z) is never more than 4, so the for loop simply y_list = linspace( -2.0, 2.0, 9)
keeps running until the count reaches the maximum for x in x_list:
iterations, and it is this maximum that is then finally for y in y_list:
returned by the mandel(c, maxiter) function. print x,y
pass
The atlas pass
We now need to define in Python which part of this Next we need to find a way of associating these
complex plane we points with the pixels in an array of colour values that
are interested in. We could be plotted using the imshow() function we used
“We want to colour each region also need to divide earlier. The complex plane region is just a list of points,
according to its convergence up this section into
regularly spaced
represented by complex numbers, and these don’t
have a colour associated with them to plot. We need
or divergence behaviour.” points, ultimately to give the imshow() plotting function something that
representing pixels in contains colour information. Also, imshow() expects
an image. to plot a two-dimensional array where the contents of
Python has a function linspace() which divides an a cell represent the colour to be plotted, not a long list
interval into evenly spaced points. Let’s imagine we of complex numbers like the ones we created earlier.
want a rectangle with bottom-left at (-2,-2) and the Given that the rows and columns of the plotted
top-right at (4,2). This has a horizontal length of 6, and array need to increment in whole units, we can simply
a vertical height of 4. Let’s divide the horizontal length place each of the evenly spaced points between the
into 12 sections, and the vertical into 8. The following bottom-left and top-right into the array. So if the points
After each iteration of the
‘multiply by 2’ function, Python code shows how you can use the familiar were 0.5 units apart on the complex plane, they would
the results get ever further Python loops over each element of linspace lists to be 1 unit apart in the array.
from each other – this is create the coordinates for each test point within this Let’s now define the complex plane region. Enter
divergence. rectangle. and run the following code. It makes sense to place
this at the top of your IPython notebook because it
iterate function “multiply by 2”, start value 2 sets out up front which region you are interested in.
Use the button marked as ‘Insert Cell Above’ to create
2400
a new cell at the top.
# set the location and size of the complex plane rectangle
1800
xvalues = linspace(-2.25, 0.75, 1000)
yvalues = linspace(-1.5, 1.5, 1000)

1200 # size of these lists of x and y values

value

xlen = len(xvalues)
ylen = len(yvalues)
600 The first instruction creates a list of 1000 points
evenly placed between -2.25 and 0.75, inclusive.
These will be the horizontal divisions of the rectangle,
0 and we’ll call the list xvalues. Similarly, yvalues is the
0 2 4 6 8
list of 1000 evenly spaced points between -1.5 and
iteration
1.5. The last two lines simply take the length of the
lists and assign them to variables.

102 www.linuxvoice.com
 MANDELBROT & PYTHON CODING

The following code creates the image array of

colour values of size xlen by ylen. We’ve called it atlas iterate function “divide by 3”, start value 10
because we want to colour each region according to 10
its convergence or divergence behaviour.
atlas = empty((xlen,ylen))
We’re almost there! All that remains is to fill this 7.5

array with colour values and plot it using imshow().

The following code uses loops to fill it with the
5

value
returned values from the mandel() function.
for ix in xrange(xlen):
for iy in xrange(ylen):
2.5

cx = xvalues[ix]
cy = yvalues[iy] 0
0 2 4 6 8
c = complex(cx, cy)
iteration
atlas[ix,iy] = mandel(c,40)

In the divide by three

pass
function, the result
pass That’s it, the hard work is done! Now let’s see the trends towards, but never
You’ll recognise that this code is simply two loops, one results. In a new cell, enter the following code. reaches, zero.
inside the other. The loops count through the rows figsize(18,18)
and columns of the atlas array using variables ix and imshow(atlas.T, interpolation=”nearest”)
iy. These counts refer to the contents of the array, The first line sets the size of the plot to 18 by 18
which are also counted from 0 to xlen-1, and not 1 to because the default is too small. The imshow
xlen. You may have noticed that we use xrange instruction plots the array. We also refer to atlas with
PRO TIP
instead of range. range would work, but for very large a .T appended to it because otherwise the array is
The code for the full
lists xrange is more efficient because it doesn’t plotted on its side compared to what we want to see. programs to calculate and
actually create a list, but gives you the contents as Run the code and you’ll see the Mandelbrot set. plot the Mandelbrot and
you ask for them. You can zoom into parts of the Mandelbrot set by Julia fractals is online at
http://bit.ly/1qpnlsE.
These two loops enable us to refer to every cell of changing the bottom-left and top-right points of the
the array using atlas[ix,iy]. The code inside the loops complex plane region. We simply change the code
uses the counts ix and iy to look up the actual that sets the xvalues and yvalues. For example, using
complex number to be tested by the mandel() the rectangle from earlier in this guide with the values
function. The real and imaginary parts were in the (-0.22 - 0.70i) bottom-left and (-0.21 -0.69i) as
xvalues and yvalues lists we created earlier, and can top-right means setting the following xvalues and
be dug out using xvalues[ix] and yvalues[iy]. yvalues as follows:
The last part inside the loops is updating the # set the location and size of the atlas rectangle
contents of the array with the return value from the xvalues = linspace(-0.22, -0.21, 1000) PRO TIP
mandel() function. yvalues = linspace(-0.70, -0.69, 1000) Don’t forget you can
The resulting image was quite undefined because explore the Mandelbrot
we set too low a value for maximum iterations. and other fractals using
the interactive XaoS open
Change it from 40 to 120 as follows: source software at http://
atlas[ix,iy] = mandel(c,120) bit.ly/1vLdz52 or through
The result is a more detailed image, as shown a web browser http://bit.
ly/1lbXYL1.
below-left. It’s really quite beautiful!
The complete Python code we’ve built up to plot our
own Mandelbrot fractals is available for you to look
over at http://makeyourownmandelbrot.blogspot.
co.uk/2014/04/sharing-code.html. I’ve added
comments to help remind you what each code
section does.
Next month we’ll look at the Julia fractals, which are
intimately related to the Mandelbrot fractals. They’re
even more beautiful in my opinion! We’ll also extend
our 2D fractals into interactive alien 3D landscapes
you’ll be able to explore.

Tariq spends his time grappling with enterprise IT problems,

It looks different from the image on the first page of this
informed by two decades of working with open technology.
tutorial, but this is actually just a magnified section.

www.linuxvoice.com 103