prev up inhalt next

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$ wächst der Betrag beliebig, für manche $c$ konvergiert er zu einem Fixpunkt. Die $Mandelbrotmenge$ besteht aus solchen komplexen Zahlen $c$, die beim Startwert $z=0$ zur Konvergenz 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 konvergiert definitiv nicht.
Falls Betrag von $z$ nach z.B. 100 Iterationen noch $<2 \Rightarrow$ Folge konvergiert vermutlich.
D.h., bei Erreichen einer vorgegebenen Iterationenzahl wird das Pixel, welches der komplexen Zahl $c$ entspricht, schwarz gefärbt, da $c$ vermutlich zur Konvergenz 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 nicht zur Konvergenz 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


prev up inhalt next