8.7 Julia-Menge

Gegeben eine komplexe Funktion f : , z.B. f (z) = z ². Wähle Startwert z₀ . Betrachte die Folge z₀,z₀²,z₀⁴,z₀⁸,.... Es gilt:

a)

für |z₀| < 1 werden die erzeugten Zahlen immer kleiner und konvergieren zum Nullpunkt,

b)

für |z₀| > 1 werden die erzeugten Zahlen immer größer und laufen gegen unendlich,

c)

für |z₀| = 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.

Julia-Kurve für f (z) = z ²

Es gilt: Julia-Menge für f (z) = z ² + 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
        Komplex c,        // fuer komplexes c,
        Komplex 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 ;
        Komplex 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 Komplex(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 ² + c f ^{- 1}(z) =

Sei z = a + b · i eine komplexe Zahl. Es gilt:

Zur Berechnung der Wurzel bei der Inverse Iteration Method

Realisiere f ^{- 1} durch

Komplex backward_random (Komplex z, Komplex 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
        Komplex c,         // fuer komplexes c
        Komplex start,     // linke obere Ecke der komplexen Flaeche
        double schritt,    // Schrittweite
        int anzahl)        // durch anzahl Rueckwaertsspruenge
{
        int k;
        Komplex z = new Komplex(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
        }

}