The Mandelbrot set.
authorClaude Heiland-Allen <claude@mathr.co.uk>
Fri, 20 Dec 2013 19:22:59 +0000 (19:22 +0000)
committerClaude Heiland-Allen <claude@mathr.co.uk>
Fri, 20 Dec 2013 19:22:59 +0000 (19:22 +0000)
commitbcba5f0deb472299e17b96e35fe514992496ce30
tree836288f8abf1da22cb8c558835d9028f845c653c
parent912c346b11b8be2447c56e8152c0389385aee885
The Mandelbrot set.

Pick a complex number \(c\).  Starting from \(z_0 = 0\), form a sequence
of ``iterates'' by repeating \(z_{n+1} = z_n^2 + c\).  For some values of
\(c\), the iterates \(z_n\) get bigger and bigger, escaping towards
infinity.  These iterates are unbounded: for any size you pick, there'll
be some later iterate that is bigger still.  For other values of \(c\),
the iterates remain bounded.  The Mandelbrot set is a map of the parameter
plane, telling us which \(c\) values will give unbounded iterates, and
which remain bounded.  Mathematically, the Mandelbrot set consists of the
\(c\) values that remain bounded.  What does it look like?

It's possible to show that if an iterate gets bigger than 2, then it'll
escape to infinity.  So the whole Mandelbrot set must be inside a circle
\(|c| <= 2\).  One way to check that a point is not in the Mandelbrot set
is to keep iterating and see if it escapes.  But for any particular \(c\)
value, we don't yet know if it is in the Mandelbrot set or not -- if it
turns out that it is in the set, we would keep iterating forever.  So
that we don't have to wait beyond the end of time to see our picture of
the Mandelbrot set, we choose to give up after a certain maximum iteration
count.  If the point still hasn't escaped, it might or might not be in
the Mandelbrot set.  But if the point escaped, we can be sure the point
is not in the Mandelbrot set.  We can draw these two cases with two
different characters, giving us our first approximation to the Mandelbrot
set.

    $ ./mandelbrot
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ----------------------------------xx------------------------------------
    -------------------------------xxxxxxxxx--------------------------------
    -----------------------------xxxxxxxxxxx--------------------------------
    -----------------------xxxxxxxxxxxxxxxxxx-------------------------------
    --------------xxxxxxxxxxxxxxxxxxxxxxxxx---------------------------------
    -----------------------xxxxxxxxxxxxxxxxxx-------------------------------
    -----------------------------xxxxxxxxxxx--------------------------------
    -------------------------------xxxxxxxxx--------------------------------
    ----------------------------------xx------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    ------------------------------------------------------------------------
    $

Mathematical variables are immutable.  In maths, \(z = z^2 + c\) is an
equation, and you solve it by finding a value for \(z\) that makes the
value on both sides the same.  For example, for \(c = 0\) there are two
solutions: \(z = 0\) and \(z = 1\).  In the C programming language, variables
can change as the program runs.  We already saw this with the loop counters,
in our use of the increment operator {\tt ++i}.  In C, {\tt =} is an
``assignment'' operator, not mathematical equality (for which C uses
{\tt ==}).  Variables in C are like boxes that contain values.  On the right
hand side of {\tt =}, values are taken out of the boxes and used to calculate
the result of the expression.  Then {\tt =} takes that result and stores it
into the box on the left hand side, overwriting the previously stored value.
The use of z as an ``l-value'' on the left hand side of {\tt z = z * z + c}
has a different meaning to the usees of z as an ``r-value'' on the right
hand side.
mandelbrot.c