Julia-Menge

Gegeben eine komplexe Funktion $f: \mathbb{C}\rightarrow \mathbb{C}$, z.B. $f(z)=z^2$. Wähle Startwert $z_0$. Betrachte die Folge $z_{0}, {z_{0}}^{2}, {z_{0}^{4}}, {z_{0}^{8}}, \ldots$. Es gilt:

a)

für $\vert z_{0}\vert < 1$ werden die erzeugten Zahlen immer kleiner und konvergieren zum Nullpunkt,

b)

für $\vert z_{0}\vert > 1$ werden die erzeugten Zahlen immer größer und laufen gegen unendlich,

c)

für $\vert z_{0}\vert = 1$ bleiben die Zahlen auf dem Einheitskreis um den Ursprung, der die Gebiete a) und b) trennt.

Die Menge c) wird Julia-Menge genannt. Sie ist invariant bzgl. der komplexen Funktion $f(z)$ und punktsymmetrisch zum Ursprung.

Abbildung 11.10: Julia-Kurve für $f(z)=z^2$

Es gilt: Julia-Menge für $f(z)=z^{2} +c$ ist genau dann zusammenhängend, wenn $c$ in der Mandelbrotmenge für $f(z)$ liegt.

Vom Julia-Algorithmus erzeugte Bilder mit $c=i$ und $c=0.746 +0.112i$

Implementation der Julia-Menge:

1. Möglichkeit:

Sei $c$ gegeben. Jeder Wert $z$ der komplexen Fläche wird überprüft, ob er als Startwert zur Konvergenz führt:

void  julia_voll(         // berechnet Julia-Menge als gefuelltes Gebiet
        Complex c,        // fuer komplexes c,
        Complex start,    // die linke obere Ecke start der komplexen Flaeche,
        double schritt,   // Schrittweite schritt
        int max_iter)     // mit vorgegebener Iterationszahl max_iter
{
        Point p = new Point();
        Point q = new Point();          // Symmetrischer Punkt
        int zaehler ;
        Complex z;
 
        for (p.x = 0; p.x <= WIDTH;     p.x++)
        for (p.y = 0; p.y <= HEIGHT/2;  p.y++)
        // Wegen Symmetrie nur bis zur Haelfte laufen
        {
                z = new Complex(p, start, schritt);
 
                q.x = WIDTH  - p.x;     // Symmetrie nutzen
                q.y = HEIGHT - p.y;
 
                zaehler = 0;
                while ((q_betrag(z) < 4.0) && (zaehler++ < max_iter))
                {
                        z = f(z,c);
                }
         
                if (q_betrag(z) < 4.0)
                {
                        set_pixel(p);
                        set_pixel(q);
                }
        }
}

Es gilt: Der Rand der berechneten Fläche stellt die Julia-Menge für $c$ dar.

2. Möglichkeit:

Inverse Iteration Method:
Aus $f(z)=z^{2}+c \Rightarrow f^{-1} (z)=\pm \sqrt {z-c}$

Sei $z=a+b \cdot i$ eine komplexe Zahl. Es gilt:

Abbildung 11.12: Zur Berechnung der Wurzel bei der Inverse Iteration Method

Realisiere $f^{-1}$ durch

Complex backward_random (Complex z, Complex c)
{   
     /* z = z - c */
     /* bestimme r mit r * r = z */
     /* wuerfel das Vorzeichen von r */
     return (r);
}

Die Wahl des Vorzeichens bei dieser inversen Iteration erfolgt zufällig.

Ausgehend von $z = 1 + 0i$ werden zunächst 50 Iterationen $z:=f^{-1}(z)$ durchgeführt, um die berechneten Punkte nahe genug an die Julia-Kurve heranzuführen. Iteriere danach weiter $z:=f^{-1}(z)$ und zeige jeweils die berechneten $z$:

void julia_rueck(          // berechnet Julia-Menge
        Complex c,         // fuer komplexes c
        Complex start,     // linke obere Ecke der komplexen Flaeche
        double schritt,    // Schrittweite
        int anzahl)        // durch anzahl Rueckwaertsspruenge
{
        int k;
        Complex z = new Complex(1.0, 0.0);   // Startposition

        for (k=0; k<50; k++)        // tastet sich an die Julia-Kurve heran
            z = backward_random(z,c);


        for (k=0; k < anzahl; k++) {        // bestimme anzahl Vorgaenger
            z = backward_random(z,c);
            set_pixel(z.getPoint(start, schritt)); // und zeichne sie
        }

}