2/2/2015

theory - How to program a fractal? - Stack Overflow

sign up

log in

tour

Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no
registration required.

help

stack overflow careers

Take the 2-minute tour

How to program a fractal?

I do not have any experience with programming fractals. Offcours i've seen the famous Mandelbrot images and such.
Can you provide me with simple algorithms for fractals.
Programming language doesn't matter really, but I'm most familiar with actionscript, c#, java.
I know that if i google fractals, i get a lot of (complicated) information. But i would like to start with a simple algorithm
and play with it.
Suggestions to improve on the basic algorithm are also welcome, like how to make them in those lovely colors and
such.
Thanks!
theory

fractals

edited Jan 15 '14 at 14:41

Aryaveer
508

asked Jan 8 '09 at 21:07

Sander Versluys

19

15.4k

14

60

82

@EBGreen, That's a really awesome song. And it is idd a valid answer! :-) Sander Versluys Jan 8 '09 at
21:38
Ooohh... youtube.com/watch?v=G0nmVUU_7IQ Federico A. Ramponi Jan 8 '09 at 22:09
@Federico, It is so fascinating and freaky at the same time. Cool vid! Thanks! Sander Versluys Jan 9
'09 at 16:35
Mandelbrot RIP. cherouvim Oct 27 '10 at 6:17
3 Based on the answers in this question, I've created a gist on github with animated mandelbrot in javascript
using the canvas element. gist.github.com/1853604 Sander Versluys Feb 20 '12 at 8:36

14 Answers
Programming the Mandelbrot is easy.
My quick-n-dirty code is below (not guaranteed to be bug-free, but a good outline).
Here's the outline: The Mandelbrot-set lies in the Complex-grid completely within a circle with
radius 2.
So, start by scanning every point in that rectangular area. Each point represents a Complex
number (x + yi). Iterate that complex number:
[new value] = [old-value]^2 + [original-value]

while keeping track of two things:

1.) the number of iterations

2.) the distance of [new-value] from the origin.
If you reach the Maximum number of iterations, you're done. If the distance from the origin is
greater than 2, you're done.
When done, color the original pixel depending on the number of iterations you've done. Then
move on to the next pixel.
public void MBrot()
{
float epsilon = 0.0001; // The step size across the X and Y axis

http://stackoverflow.com/questions/425953/how-to-program-a-fractal

1/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

float x;
float y;
int maxIterations = 10; // increasing this will give you a more detailed
fractal
int maxColors = 256; // Change as appropriate for your display.
Complex Z;
Complex C;
int iterations;
for(x=-2; x<=2; x+= epsilon)
{
for(y=-2; y<=2; y+= epsilon)
{
iterations = 0;
C = new Complex(x, y);
Z = new Complex(0,0);
while(Complex.Abs(Z) < 2 && iterations < maxIterations)
{
Z = Z*Z + C;
iterations++;
}
Screen.Plot(x,y, maxColors % iterations); // depending on the
number of iterations, color a pixel.
}
}
}

Some details left out are:

1.) Learn exactly what the Square of a Complex number is and how to calculate it.
2.) Figure out how to translate the (-2,2) rectangular region to screen coordinates.
answered Jan 8 '09 at 21:28
abelenky
30.1k

52

97

You should indeed start with the Mandelbrot set, and understand what it really is.
The idea behind it is relatively simple. You start with a function of complex variable
f(z) = z^2 + C
where z is a complex variable and C is a complex constant. Now you iterate it starting from z
= 0, i.e. you compute z1 = f(0), z2 = f(z1), z3 = f(z2) and so on. The set of those constants C
for which the sequence z1, z2, z3, ... is bounded, i.e. it does not go to infinity, is the
Mandelbrot set (the black set in the figure on the Wikipedia page).
In practice, to draw the Mandelbrot set you should:
Choose a rectangle in the complex plane (say, from point -2-2i to point 2+2i).
Cover the rectangle with a suitable rectangular grid of points (say, 400x400 points), which
will be mapped to pixels on your monitor.
For each point/pixel, let C be that point, compute, say, 20 terms of the corresponding
iterated sequence z1, z2, z3, ... and check whether it "goes to infinity". In practice you
can check, while iterating, if the absolute value of one of the 20 terms is greater than 2 (if
one of the terms does, the subsequent terms are guaranteed to be unbounded). If some
z_k does, the sequence "goes to infinity"; otherwise, you can consider it as bounded.
If the sequence corresponding to a certain point C is bounded, draw the corresponding
pixel on the picture in black (for it belongs to the Mandelbrot set). Otherwise, draw it in
another color. If you want to have fun and produce pretty plots, draw it in different colors
depending on the magnitude of abs(20th term).
The astounding fact about fractals is how we can obtain a tremendously complex set (in
particular, the frontier of the Mandelbrot set) from easy and apparently innocuous
requirements.
Enjoy!

http://stackoverflow.com/questions/425953/how-to-program-a-fractal

2/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

edited Jan 8 '09 at 21:46

answered Jan 8 '09 at 21:29

Federico A. Ramponi
24.9k

19

74

115

There is a great book called Chaos and Fractals that has simple example code at the end of
each chapter that implements some fractal or other example. A long time ago when I read
that book, I converted each sample program (in some Basic dialect) into a Java applet that
runs on a web page. The applets are here: http://hewgill.com/chaos-and-fractals/
One of the samples is a simple Mandelbrot implementation.
answered Jan 8 '09 at 21:28
Greg Hewgill
394k

84

721

920

Those applets are great examples! Thanks! Sander Versluys Feb 20 '12 at 8:33
i have this book, it is great scape Aug 30 '13 at 0:43

I would start with something simple, like a Koch Snowflake. It's a simple process of taking a
line and transforming it, then repeating the process recursively until it looks neat-o.
Something super simple like taking 2 points (a line) and adding a 3rd point (making a corner),
then repeating on each new section that's created.
fractal(p0, p1){
Pmid = midpoint(p0,p1) + moved some distance perpendicular to p0 or p1;
fractal(p0,Pmid);
fractal(Pmid, p1);
}

answered Jan 8 '09 at 21:58

Dave Baghdanov
776

12

26

I have a set of tutorials and code written in C# on my blog to generate quite a few fractals,
including Mandelbrot, Julia, Sierpinski, Plasma, Fern and Newton-Rhapson fractals. I also
have the full source for all the fractals mentioned in the tutorials available for download from
the same location.
edited Oct 27 '10 at 6:15

answered Dec 1 '09 at 6:16

Serge Meunier
106

thanks! some great and diverse fractal examples, will definitely check them out! ;-) Sander Versluys Dec
1 '09 at 9:54

If complex numbers give you a headache, there is a broad range of fractals that can be
formulated using an L-system. This requires a couple of layers interacting, but each is
interesting in it own right.
First you need a turtle. Forward, Back, Left, Right, Pen-up, Pen-down. There are lots of fun
shapes to be made with turtle graphics using turtle geometry even without an L-system
driving it. Search for "LOGO graphics" or "Turtle graphics". A full LOGO system is in fact a
Lisp programming environment using an unparenthesized Cambridge Polish syntax. But you
don't have to go nearly that far to get some pretty pictures using the turtle concept.
Then you need a layer to execute an L-system. L-systems are related to Post-systems and
Semi-Thue systems, and like virii, they straddle the border of Turing Completeness. The
concept is string-rewriting. It can be implemented as a macro-expansion or a procedure set
with extra controls to bound the recursion. If using macro-expansion (as in the example
below), you will still need a procedure set to map symbols to turtle commands and a
procedure to iterate through the string or array to run the encoded turtle program. For a
bounded-recursion procedure set (eg.), you embed the turtle commands in the procedures
http://stackoverflow.com/questions/425953/how-to-program-a-fractal

3/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

and either add recursion-level checks to each procedure or factor it out to a handler function.
Here's an example of a Pythagoras' Tree in postscript using macro-expansion and a very
abbreviated set of turtle commands. For some examples in python and mathematica, see my
code golf challenge.

edited Feb 27 '13 at 9:44

answered Sep 18 '12 at 20:39

luser droog
10.2k

http://stackoverflow.com/questions/425953/how-to-program-a-fractal

19

57

4/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

The image was created using the technique described here to combine a short snippet of code with a small
illustration. luser droog Aug 4 '13 at 6:45

The Sierpinski triangle and the Koch curve are special types of flame fractals. Flame fractals
are a very generalized type of Iterated function system, since it uses non-linear functions.
An algorithm for IFS:es are as follows:
Start with a random point.

Repeat the following many times (a million at least, depending on final image size):

Apply one of N predefined transformations (matrix transformations or similar) to the

point. An example would be that multiply each coordinate with 0.5.
Plot the new point on the screen.

If the point is outside the screen, choose randomly a new one inside the screen instead.
If you want nice colors, let the color depend on the last used transformation.
edited Feb 14 '14 at 18:22

answered Aug 7 '09 at 9:11

Per Alexandersson
1,057

19

Another excellent fractal to learn is the Sierpinski Triangle Fractal.

Basically, draw three corners of a triangle (an equilateral is preferred, but any triangle will
work), then start a point P at one of those corners. Move P halfway to any of the 3 corners at
random, and draw a point there. Again move P halfway towards any random corner, draw,
and repeat.
You'd think the random motion would create a random result, but it really doesn't.
Reference: http://en.wikipedia.org/wiki/Sierpinski_triangle
edited Jul 11 '12 at 15:41

answered Jan 8 '09 at 22:12

abelenky
30.1k

52

97

1 This is really the basis of an IFS, which can be regarded as a generalization of the method you describe.
Algorias Jan 8 '09 at 22:15

There are plenty of examples listed on wikipedia.

answered Jan 8 '09 at 21:12
Brian Rasmussen
72.6k

19

129

233

+1 for how interesting that article was jjnguy Jan 8 '09 at 21:18

The mandelbrot set is generated by repeatedly evaluating a function until it overflows (some
defined limit), then checking how long it took you to overflow.
Pseudocode:
MAX_COUNT = 64 // if we haven't escaped to infinity after 64 iterations,
// then we're inside the mandelbrot set!!!
foreach (x-pixel)
foreach (y-pixel)
calculate x,y as mathematical coordinates from your pixel coordinates

http://stackoverflow.com/questions/425953/how-to-program-a-fractal

5/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

value = (x, y)
count = 0
while value.absolutevalue < 1 billion and count < MAX_COUNT
value = value * value + (x, y)
count = count + 1
// the following should really be one statement, but I split it for clarity
if count == MAX_COUNT
pixel_at (x-pixel, y-pixel) = BLACK
else
pixel_at (x-pixel, y-pixel) = colors[count] // some color map.

Notes:
value is a complex number. a complex number (a+b*i) is squared to give (a*a-b*b+2*a*b*i).
You'll have to use a complex type, or include that calculation in your loop.
answered Jan 8 '09 at 21:23
Jimmy
38.5k

79

120

1 Are you sure about value.absolutevalue < 1 billion??? Once value.absolutevalue is beyond 2, it will
"escape" and go to infinity. So you only need to test as far as 2, not 1 billion. abelenky Jan 8 '09 at 21:40

Well, simple and graphically appealing don't really go hand in hand. If you're serious about
programming fractals, I suggest reading up on iterated function systems and the advances
that have been made in rendering them.
http://flam3.com/flame_draves.pdf
answered Jan 8 '09 at 22:09
Algorias
1,242

15

Here's a simple and easy to understand code in Java for mandelbrot and other fractal
examples
http://code.google.com/p/gaima/wiki/VLFImages
Just download the BuildFractal.jar to test it in Java and run with command:
java -Xmx1500M -jar BuildFractal.jar 1000 1000 default MANDELBROT
The source code is also free to download/explore/edit/expand.
answered Nov 23 '10 at 12:07
reddev
86

I think you might not see fractals as an algorithm or something to program. Fractals is a
concept! It is a mathematical concept of detailed pattern repeating itself.
Therefore you can create a fractal in many ways, using different approaches, as shown in the
image below.

Choose an approach and then investigate how to implement it. These four examples were
implemented using Marvin Framework. The source codes are available here
http://stackoverflow.com/questions/425953/how-to-program-a-fractal

6/7

2/2/2015

theory - How to program a fractal? - Stack Overflow

answered Sep 28 '13 at 12:44

Gabriel Ambrsio Archanjo
1,959

16

People above are using finding midpoints for sierpinski and Koch, I'd much more recommend
copying shapes, scaling them, and then translating them to achieve the "fractal" effect.
Pseudo-code in Java for sierpinski would look something like this:
public ShapeObject transform(ShapeObject originalCurve)
{
Make a copy of the original curve
Scale x and y to half of the original
make a copy of the copied shape, and translate it to the right so it
touches the first copied shape
make a third shape that is a copy of the first copy, and translate it
halfway between the first and second shape,and translate it up
Group the 3 new shapes into one
return the new shape
}

edited Sep 29 '12 at 20:08

answered Sep 29 '12 at 20:01

faeophyta
44

http://stackoverflow.com/questions/425953/how-to-program-a-fractal

7/7