How to Make a Mandelbrot

Welcome to Judebert's How to Make a Mandelbrot. This is a tutorial on how to make fractal images on your computer, including Mandelbrot sets. I'll show you the math, include some source code fragments, and generally help you along. I assume you already know a programming language like C, but I'll refresh you on the math as we go.

To understand fractals, you must understand complex numbers. I've included a quick refresher course. To avoid boring anyone, you can skip to the stuff you don't already know:

• Conventions
• Complex Number Primer
• The Complex Plane and the magnitude of a complex number
• The Formula for a Mandelbrot Set
• Suggested Improvements
• Other Fractal Resources

Conventions
I don't want to include a lot of graphics, so I've got to set up some conventions.

Multiplication will be represented by the asterisk: *. For instance, 3 * 6 = 18.

When I want the square root of a number, I'll write sqrt(), like in C. For instance, sqrt(4) = 2.

When I want the square of a number, I'll write **2. For instance, 2**2 = 4. I'll also use this for other exponents, like cubing: 2**3 = 8.

I'll write examples on their own lines, to make them easier to follow.

Complex Numbers
A complex number is a number including the square root of -1. If you remember your algebra, you know that any number sqared is positive; therefore no known number squared can result in -1, since it is negative. Since it doesn't exist, but we have to use it to solve some mathematical problems, we call it "imaginary." We have to use sqrt(-1) often enough that we've given it a special symbol, based on the fact that it's imaginary: i.

Since i is an imaginary number, we couldn't just subtract it from other numbers. What is 2 - i? Well, it's not 1. It's not 3. It's not any number we could actually name. Therefore we just call it (2 - i). Same thing goes for addition, multiplication, division, anything. You might notice that (2 - i) has more two parts: the real part, which is 2, and the imaginary part, which is i. Since this number contains more parts than a simple number, we call it a "complex" number.

Dealing with these numbers is not as difficult as it sounds. Consider trying to add two complex numbers. To complete this mind-bogglingly complex calculation, simply add the parts together. Like this:

   (2 + i)
  +(1 + i)
  ----------------
   (3 + 2i)

Note that you can add complex and simple numbers, too. This is easy because you can think of a simple number as a complex number with the i set to 0. For instance, 5 can be thought of as (5 + 0i). So to add (2 + i) and 5, you could do this:

   (2 +  i)
  +(5 + 0i)
  ----------------
   (7 +  i)

Here's another example:

   (2 + i)
  +(1 - i)
  ---------------
   (3 + 0i), which is 3. 

Now for multiplication. As you recall from above, i is sqrt(-1); therefore i**2, or i squared, is -1. This is simple, so I'll only say it one more time: since sqrt(x)**2 (the square root of x, squared) is x, i**2 is sqrt(-1)**2, which is -1. Thus ends the lesson in definitions and identities.

The tricky part is multiplying complex numbers. For instance, what is

   (2 + i) * (1 + 2i)?

   (2 + x) * (1 + 2x)

                       (2 + x) * (1 + 2x)
   The First terms are 2 and 1.             2 * 1  =  2.
   The Outer terms are 2 (again) and 2x.    2 * 2x = 4x.  
   The Inner terms are x and 1.             x * 1  =  x.
   The Last  terms are x and 2x.            x * 2x = 2x**2.

Well, the original question was about multiplying two complex numbers; so we substitute i for the x and get 2 + 5i + 2i**2. And, as you recall from the start of the discussion, i**2 is -1, so the 2i**2 is best written as -2. That changes the polynomial a bit, to 2 + 5i + (-2), which is 0 + 5i, or just 5i, if you like.

If you got lost, go back and read it again. This is important to the whole idea of fractals.

One last note before moving on: there's a simpler way to see the outcome when you square a polynomial. Here it is, using no numbers, all letters:

                       (a + bx) * (a + bx)
   The First terms are a and a.             a * a  = a**2
   The Outer terms are a (again) and bx.    a * bx = abx.
   The Inner terms are bx and a.            bx * a = abx.
   The Last  terms are bx and bx.           bx * bx = (b**2)(x**2)

(a + bi)**2 = a**2 - b**2 + 2abi.

The Complex Plane
The Mandelbrot uses a complex plane; all fractals do. You're accustomed to a number plane with x going left-to-right (horizontal) and y going up-and-down (vertical). (At least, I HOPE you're familiar with this idea.) The complex plane is a very simple modification on this standard number plane, with the vertical axis being imaginary numbers. That's right, instead of ...-2, -1, 0, 1, 2... the vertical axis is ...-2i, -1i, 0i, 1i, 2i...

That makes it easy to place complex numbers on the plane. For instance, (2 - i) could be drawn as a point at (2, -1). (-2 + 3i) could be drawn as a point at (-2, 3). This is going to come in handy in just a moment.

Finally, the last idea about complex numbers and the complex plane you need to know: magnitude. This is just the distance from the origin of the complex plane to the point. You use the pythagorean theorem for this one: a**2 + b**2 = c**2. So, the complex number (3 + 4i), which lies at (3, 4) on the complex plane, has a magnitude of:

   3**2 + 4**2 = magnitude**2
   9 + 16 = magnitude**2
   25 = magnitude**2
   5 = magnitude

The Mandelbrot
You might notice that all those complex numbers have some interesting properties. For instance, Benoit Mandelbrot noticed that if you square the number, then add it on to your figure, and kept doing that forever, the number will either become infinitely large or it will tend to go towards 0. The formula looks like this:

   z = z**2 + c
or more computerish
   z = last_z**2 + c.

0: last_z**2 + c = 
   0**2 + (2 + 0i), which is 
   (2 + 0i).  

1: last_z**2 + c =
   (2 + 0i)**2 + c = 
   (4 - 0 + 0i) + c = 
   (4 + 0i) + (2 + 0i) = 
   (6 + 0i). 

That was the easy example. For a harder one, consider (0, -1). We start z and last z at 0, then set c to (0 - i). Then:

0: last_z**2 + c =
   0**2 + (0 - i) = 
   (0 - i).

1: last_z**2 + c = 
   (0 - i)**2 + c =
   (0 - 1 + 0i) + c =
   (-1 + 0i) + c =
   (-1 + 0i) + (0 - i) =
   (-1 - i)

2: last_z**2 + c =
   (-1 - i)**2 + c =
   (1 - 1 + 2i) + c = 
   (0 + 2i) + c = 
   (0 + 2i) + (0 - i) =
   (0 + i)

3: (-1 - i)
4: ( 0 + i)
5: (-1 - i)
6: ( 0 + i)
7: (-1 - i)

Obviously it's nice to have a computer to do all this figuring for us. I'll leave the programming to you; come up with a nice representation of complex numbers and use it. Or get a fractal program that already does this stuff for you.

For these examples, we could tell intuitively whether they would become infinitely large. But the computer will need some rules. How can the computer tell if we're going infinite?

Some lucky mathematician already solved this problem for us. He proved that if the magnitude of a complex number was greater than 2, then it would go to infinity when used in Mandelbrot's formula. So if we ever get a number of magnitude greater than 2, we're done with that point. And it's easy to see that (-23, -8) has a magnitude much greater than 2, so it will go to infinity, just as we suspected. (Another note for the advanced mathematicians: why bother to take the square root? You get the square of the magnitude along the way; just check to see if its greater than 4.)

This is where the pretty picture comes in. We can see the Mandelbrot set will never go farther up, down, left or right than 2, since (0, 2), (2, 0), (-2, 0), and (0, -2) all have magnitude greater than 2. So we start at (-2, 2) and work pixel-by-pixel towards (2, -2). If the number goes to infinity (magnitude > 2) we draw a point there and move on. If it doesn't, we draw a black point (or don't draw the point at all) and move on.

Wait... what about the ones that don't go to infinity?

Their magnitude never goes over 2, so if we only check for numbers getting too big we'll be stuck working complex multiplication all day. Computers are fast, but an endless loop is still an endless loop. You'll never get to infinity, no matter how fast you run.

So we'd better limit how long we're willing to work this problem. If after, say, 100 calculations your number still hasn't reached a magnitude of 2, we'll guess that it's on its way to 0 and draw it black.

This also gives us a nice way to add color to our picture. Some numbers start on their way to infinity faster than others. (2, 2) does it right off. If we look at how many times we had to calculate before we stop, we could color pixels according to how fast the number "escapes." The faster pixels could be closer to white (or blue, or whatever) while the slower ones get darker and darker. (Actually it looks better the other way, with faster pixels dark and slower pixels bright, but who cares? Color it however you like it.) The pixels that never escape we color black.

That gives you the classic Mandelbrot, right there on your screen. Cool, huh?

Anything else?
There are a few things you should be careful about if you intend to take this any farther.

We've been working with integers; the Mandelbrot set we draw works with real numbers. Like (1.5768293 + 0.2836589i). Computers are great, aren't they? If you're drawing from (-2, 2) to (2, -2), then your number plane is 4.0 across. If you've got 640 pixels accross the screen, then you want to start at -2.0 and add (4.0 / 640) = 0.00625 each time until you get to 2. Get the idea? That's how all these examples were drawn.

Why just draw from (-2, 2) to (2, -2)? That shows you the whole set. It's pretty, but... there are more interesting things farther down. Try drawing from (-0.5, 2) to (0.5, 1.0). Or other places. Just be careful: some of those places that look black aren't really black. They're pixels that would have gone to infinity if we waited longer. Try 150, 1000, 1500, 10000 iterations. It'll take longer, but you'll get to see more of the Mandelbrot set, and in better detail, too.

If you try more iterations than you have colors, you could run into trouble. For instance, if you have a table of 256 colors, and you find a pixel that escapes after 300 iterations, what color do you paint it? Maybe you should try to map the iterations into a colormap differently. You could spread the iterations through the color bands. Or find a way to map into 24 bit color.

While we're on the subject, why use the iterations to color the pixels? I only mentioned it because it's simple and easy. You could use the magnitude of the pixel when it escaped as its color. Or you could use the iteration as the red component, the magnitude as the blue component, and the start number as the green. What the hell; it can't be worse than some of the stuff I've tried.

Julia sets. A Julia set has the same formula as the Mandelbrot set. The only difference is that the Julia set uses a constant value for c. In a Mandelbrot, you change the c in "z = last_z**2 + c" every time you calculate a new pixel. In a Julia, you change c only at the beginning of a render. The last_z starts not at 0, but at the value of the point you're calculating right now. This picture is a Julia set where c is a point near the tip of the Mandelbrot set. Julias and Mandelbrots have a lot in common. Click the picture to get a larger version of this Julia set.

Other Fractal Resources
Finally, check out places on the Web for other fractal interests. I'll post about zooming smoothly into fractals some other day; meanwhile there's a lot of interesting information at The Mu Encyclopedia. Or go to the Fractint home page (it's a very powerful fractal program, ready for you to use).

Have fun! Can't wait to see what you come up with!
Back to the Top

click to visit my home page
Fractal information, wasted youth ranting, and feedback form

This page has had

visitors.