Mandelbrot-Menge

Sei $z$ eine komplexe Zahl mit Realteil $z.re$ und Imaginärteil $z.im$:

    public class Complex
    {
            double re;
            double im;

    ...

Das Quadrat einer komplexen Zahl $z$ hat den Realteil $z.re^{2}-z.im^{2}$ und den Imaginärteil $2 \cdot z.re \cdot z.im$. Der Betrag einer komplexen Zahl $c$ sei $\vert c\vert = \sqrt{c.re^{2}+c.im^{2}}$.
Betrachte die Funktion $f: \mathbb{C}\rightarrow \mathbb{C}, f(z)=z^{2}+c$ für festes $c$.

    Complex f(Complex z)
    {
            double tmp;

            tmp   = z.re;
            z.re  = z.re * z.re - z.im * z.im + c.re;
            z.im  = 2 * tmp * z.im + c.im;

            return z
    }

Betrachte die Folge $z, f(z),f^{2} (z), f^{3} (z), \ldots$ beginnend bei $z=0$ für festes $c$.

Für manche $c$ konvergiert sie zu einem Fixpunkt, für manche $c$ gerät sie in einen (beschränkten) Zyklus, für manche $c$ verhält sie sich (beschränkt) chaotisch, für manche $c$ strebt die Folge gegen Unendlich.

Die $Mandelbrotmenge$ besteht aus solchen komplexen Zahlen $c$, die beim Startwert $z=0$ zu einer beschränkten Folge führen. Um die Mandelbrotmenge grafisch darzustellen, definiert man

Ordne jedem Pixel $(p.x, p.y)$ des Bildschirms eine komplexe Zahl zu wie folgt. Die linke obere Ecke bezeichne die komplexe Zahl start (z.B. $-2.15, 2.15$). Die rechte obere Ecke bezeichne die komplexe Zahl ende (z.B. $0.85, 2.15$)
Dann ergibt sich bei $300$ Pixeln pro Zeile eine Schrittweite von $(0.85+2.15)/300=0.01$.
Somit läßt sich ein Koordinatenpaar $(p.x, p.y)$ umrechnen durch den folgenden Konstruktor.

        public Complex(Point p, Complex start, double schritt)
        // bildet die komplexe Zahl zum Pixel p mit linker/oberer Ecke start
        // und Schrittweite schritt
        {
                this.re = start.re + schritt * (double)p.x;
                this.im = start.im - schritt * (double)p.y;
        }

Sei $(p.x, p.y)$ das zur komplexen Zahl $c$ gehörende Pixel. Dann färbe es mit farbe($c$).

Abbildung 11.8: Mandelbrotmenge: $-2.2 \leq z.re \leq 0.6$, $-1.2 \leq z.im\leq 1.2$, 100 Iterationen

Implementation der Mandelbrot-Menge

Sobald während des Iterierens der Betrag von $z > 2 \Rightarrow$ Folge wächst mit Sicherheit über alle Grenzen (Satz von Fatou). Falls Betrag von $z$ nach z.B. 100 Iterationen noch $<2 \Rightarrow$ Folge bleibt vermutlich beschränkt.

D.h., bei Erreichen einer vorgegebenen Iterationenzahl wird das Pixel, welches der komplexen Zahl $c$ entspricht, schwarz gefärbt, da $c$ vermutlich zu einer beschränkten Folge führt.

void mandel ()
{
     Point p;
     int zaehler;
     Complex c, z;

     for (p.x = 0; p.x < WIDTH;  p.x++)
     for (p.y = 0; p.y < HEIGHT; p.y++)
     {
          zaehler = 0; 
          c       = new Complex(p, start, schritt);
          z       = new Complex(c);

          while ((betrag (z) < 2.0) && (zaehler++ < max_iter))

             z = f(z);

          if (betrag(z) < 2.0) set_pixel(p);
      }
}

Bemerkung:

Bei Erhöhung der Iterationszahl können einige Pixel weiß werden, da sich herausgestellt hat, daß durch weitere Iterationen die Betragsgrenze $2$ überschritten wird.
Um die Zahlen $c$, die zu einer unbeschränkten Folge geführt haben, weiter zu klassifizieren, setzt man

Also ergibt sich:

   if (betrag < 2.0)        set_pixel (p); else
   if ((zaehler %  2) != 0) set_pixel (p);

Bei Farbbildschirmen gibt es folgende Möglichkeit, die Divergenzgeschwindigkeit der Folge für ein $c$ zu veranschaulichen:

Es seien die Farben farbe[0], ..., farbe[NUM_COL-1] vorhanden

    set_col_pixel (p, farbe [zaehler % NUM_COL])

Abbildung 11.9: Mandelbrotmenge: $-1.2548 \leq Re \leq -1.2544$, $0.3816 \leq Im \leq 0.3822$, 100 Iterationen