Julia

Berechnung mit Reihen-Entwicklung

Die Entdeckung und Beschreibung der Julia-Mengen war eine wichtige Stufe auf dem Weg zu den heute vielfach verwendeten Fraktalen. Auf dieser Seite werden Methoden zur praktischen Berechnung einiger Julia-Funktionen vorgestellt.
Algorithmen Ausgewählte IT-Rezepte, Iterationen
Julia-Menge Die Entdeckungen von Gaston Maurice Julia
Julia Funktionen Berechnung mit Standard Kalkulations-Programmen
Julia Grafik Herstellung mit Kalkulations-Programmen und Visual Basic (VBA)
Julia mit PHP Herstellung einer Julia-Grafik mit PHP
Julia mit C/C++ Programmierung der Julia-Funktion mit C/C++
Mandelbrot Die Berechnung der eng verwandten Mandelbrot-Funktion

Julia-Menge
Quelle: RWTH Aachen
Gaston Maurice Julia (1893 - 1978) war ein französicher Mathematiker. Er erlitt im 1.Weltkrieg eine schwere Gesichts-Verletzung und trug während seines ganzen folgenden Lebens eine abdeckende Kappe.

Eine seiner größten Leistungen war 1918 die Entdeckung und Beschreibung der nach ihm benannten Julia-Menge. Unabhängig von ihm forschte zur gleichen Zeit auch der französische Astronom und Mathematiker Pierre Fatou auf diesem Gebiet.

Die Julia-Menge geht auf Untersuchungen von Funktionen komplexer Zahlen zurück. Dabei interessiert weniger das Ergebnis einzelner Funktionen, sondern ihr Verhalten bei fortgesetzter Anwendung (Iteration). Die bekannte → Mandelbrot-Funktion ist mit der Julia-Menge eng verwandt. 		Diese Grafik zeigt einen Ausschnitt der Julia-Menge. Sie wurde mit dem auf dieser Seite vorgestellten ↓ PHP-Programm hergestellt.

Hier wird nicht auf Herleitung, Bedeutung oder Anwendung der Julia-Menge eingegangen, sondern lediglich auf die Berechnung mit den Methoden der Informatik.

Die Berechnung selbst ist relativ einfach, jedoch wenig spektakulär. Sie gelingt mit jedem Standard Kalkulations-Programm.

Zur Demonstration eignen sich 2dimensionale grafische Darstelllungen, in denen die Ergebnisse vieler einzelner Julia-Iterationen in Farben umgesetzt werden. Das übersteigt zwar die Grenzen einfacher Kalkulations-Programme, ist jedoch eine lohnende Aufgabe für beliebige Programmiersprachen.

Julia-Funktionen

ℂ   Komplexe Zahlen

Alle Julia-Funktionen verwenden komplexe Zahlen. Diese Zahlen bestehen aus 2 Teilen, dem Real-Teil und dem Imaginär-Teil. Für das Rechnen mit komplexen Zahlen gibt die Mathematik spezielle Regeln an, die man jedoch nicht unbedingt beherrschen muss, um eine Demo-Grafik einer Julia-Menge herzustellen.

Julia-Funktionen

haben die allgemeine Form
z[n+1] = z[n]^2 + c
Jedes Element einer Reihe z[0]...z[n] wird mit dieser einfachen Formel aus dem vorhergehenden Element berechnet.
Beide Argumente z, c sind komplexe Zahlen. Zur Berechnung eines Elements z[n] verwendet man daher je 4 Zahlenwerte, die realen und die imaginären Teile von 2 Argumenten.

Algorithmus

Zur Berechnung ist keine Kenntnis der komplexen Zahlen notwendig. Alle weiteren Kapitel dieser Seite verwenden daher XY-Koordinaten, weil diese in der Praxis auf wesentlich breitere Akzeptanz bauen können als komplexe Zahlen. Es wird jedoch ausdrücklich darauf hingeweisen, dass die Angaben nicht mathematisch, sondern rein praktisch begründet sind.

(1) Das Erscheinungsbild der Julia-Menge wird nur durch den Wert der komplexen Konstanten c bestimmt. Man muss die beiden Teile von c als Koordinaten cx, cy im Programm vorgeben oder von den AnwenderInnen eingeben lassen.

(2) Zur Berechnung eines einzelnen Funktionswerts (= 1 Bildpunkt der Julia-Grafik) muss man einen Startpunkt S(sx,sy) festlegen.
In der Praxis berechnet man keine einzelnen Funktionswerte, sondern je einen Wert für jeden einzelnen Bildpunkt der Julia-Grafik. Dazu variiert man die Koordinaten sx,sy des Stanpunkts in 2 ineinander geschachtelten Schleifen (bildlich umgesetzt: von links nach rechts und von oben nach unten).
(3) Die Koordinaten eines Startpunkts sx,sy bilden das erste Element z[n=0] der Reihe. Für jedes weitere Element z[1], z[2], ... werden dessen Koordinaten aus dem vorhergehenden Element berechnet:
x[n+1] = = x[n]^2 - y[n]^2 + cx
y[n+1] = 2 * x[n] * y[n] + cy

(4) Man berechnet in einer Schleife so viele Elemente wie möglich.
Je nach Wahl von c und Startpunkt ergeben sich mehrere Möglichkeiten:
• Die Koordinaten der Elemente x[n],y[n] ändern sich nicht, oder schwanken periodisch um einen Mittelwert. In diesem Fall setzt man das Ergebnis (...die Farbe des Bildpunkts) auf einen neutralen Wert.
• Das Ergebnis wird so groß, dass man es (mit den üblichen Variablen des → Typs double) nicht mehr berechnen kann. In diesem Fall speichert man die Nummer n des letzten noch berechneten Elements und berechnet daraus die Farbe des Bildpunkts.

Kalkulation

Die Berechnung eines einzelnen Funktionswertes ist mit jedem Standard Kalkulations-Programm möglich, z.B. mit LibreOffice, OpenOffice, MS-Excel, ...
   ABCD
1cx0  
2cy1  
3sx=ZUFALLSZAHL()*4-2  
4sy=ZUFALLSZAHL()*4-2n[max]=MAX(D7:D37)
5    
6nzxzyn*
70=B3=B4=WENN(ISTZAHL(C7);A7;0)
8=A7+1=B7^2-C7^2+$B$1=2*B7*C7+$B$2=WENN(ISTZAHL(C8);A8;0)
...
37=A36+1=B36^2-C36^2+$B$1=2*B36*C36+$B$2=WENN(ISTZAHL(C37);A37;0)
Die Vorgaben werden in den 4 Zellen B1:B4 eingegeben.
• Der Startpunkt wird hier durch Zufalls-Zahlen im Bereich -2...+2 festgelegt.
• Mit Klick auf Taste F9 werden neue Zufallswerte verwendet.
Alternativ kann man die Koordinaten des Startpunkts in B3:B4 manuell eingeben.
• In Zeile 7 werden die Anfangswerte des Zählers (n) und der Koordinaten (zx,zy) festgelegt.
• In Zeile 8 sind bereits die Formeln zur Berechnung von Element z[1] aus dem vorherigen Element z[0] eingetragen. Man kann den Bereich A8:C8 und D7 nach unten ausfüllen, z.B. bis Zeile 37 = Element 30
• Je nach Anfangswert werden mehr oder weniger Elemente berechnet. Meistens wird der Werte-Bereich überschritten und die letzten Zellen enthalten den Fehler-Wert #NUM! oder #ZAHL!
• In Spalte D wird das Verhalten der Funktion beobachtet: Hier wird der Zähler n (nur dann) übernommen, wenn das jeweilige Element korrekt berechnet wurde.
• Das Ergebnis (=die maximale Anzahl berechenbarer Elemente) wird in D4 zusammengefasst.
♣ Tipp: Klicken sie mehrmals die Taste F9, um die Funktion für verschiedene zufällige Startpunkte zu berechnen:
Für die im Beispiel angegeben Daten sollte das Ergebnis in D4 Werte im Bereich 9...30 annehmen.

Julia (Pseudo)-Grafik mit Kalkulation + Visual Basic (VBA)
Man kann jedes Standard Kalkulations-Programm z.B. LibreOffice, OpenOffice, MS-Excel, ... durch 'Benutzer-definierte Funktionen' ergänzen, die in der Programmiersprache → Visual Basic (VBA) bzw. den Äquivalenten in LibreOffice oder OpenOffice erstellt wurden. Hier wird vorgestellt, wie man mit einem Standard Kalkulations-Programm (d.h. mit Ausnahme von MS-Excel kostenfrei) einfache grafische Darstellungen von Julia-Mengen selbst herstellen kann. Die Progerammierung erfordert allerdings fortgeschrittene Kenntnisse der Tabellen-Kalkulation.
♦ Details zur Organisation von VBA-Funktionen auf der Seite VBA-Module dieses Webs.

Julia-Funktion

Die rechts vorgestellte Funktion kombiniert die Berechnung aufeinander folgender Elemente einer Julia-Reihe mit der Zählung der berechenbaren Elemente.

• Die Koordinaten eines Elements werden in den Variablen jx,jy verwaltet. Die Anfangswerte (des Elements z[0] ) werden auf die Koordinaten des Startpunkts sx,sy gesetzt.

• Danach werden in einer while-Schleife alle weiteren Elemente der Reihe berechnet.
Die Koordinaten jedes neuen Elements werden in jxq,jyq berechnet und danach auf jx,jy übertragen.

• Im Normalfall wird die Schleife abgebrochen, wenn ein Fehler durch Überlauf des Werte-Bereichs auftritt. Die Anweisung On Error GoTo führt das Programm in diesem Fall (ohne Felder-Meldung) zur SprungMarke jz. Dort wird die fortlaufenden Nummer n des letzten berechneten Elements zurückgegeben und die Funktion beendet.
Zur Sicherheit wird die Schleife in jedem Fall nach maximal 1000 Elementen abgebrochen und das Ergebnis =-1 zurückgegeben. 		Visual Basic (VBA) Funktion zur Berechnung der maximal berechenbaren Anzahl von Elementen einer Julia-Reihe.
Function julia( _
sx As Double, sy As Double, _
cx As Double, cy As Double) As Double
Dim jx, jxq, jy, jyq As Double
Dim n As Long
jx = sx
jy = sy
n = 0
On Error GoTo jz
While n >= 0
jxq = jx * jx - jy * jy + cx
jyq = jx * jy + jx * jy + cy
n = n + 1
If n > 1000 Then n = -1
jx = jxq
jy = jyq
Wend
n = -1
jz:
julia = CDbl(n)
End Function

Kalkulation - Vorgaben

   AB
1cx0
2cy1
3x[min]-2,5
4x[max]2,5
5Δx =(B4-B3)/AH10
6y[min]-2,5
7y[max]2,5
8Δy =(B7-B6)/B42
Fortgeschritten AnwenderInnen können mit einem Standard Kalkulations-Programm eine einfache Pseudo-Grafik der Julia-Menge darstellen.
Das Beispiel ist in 2 Teile unterteilt, die beide auf einer Seite eines Kalkulations-Dokuments Platz haben.

Der 1.Teil enthält die einstellbaren Vorgaben:
Die Variablen cx,cy geben den realen und den imaginären Teil der Konstanten c an. Im Internet und in der Literatur finden sie zahlreiche Beispiele mit Angaben der Konstanten c. Alternativ können sie experimentieren und c manuell einstellen.
Die Variablen x[min],x[max],y[min],y[max] geben den von der Pseudo-Grafik anzuzeigenden Bereich an.

Kalkulation - Pseudografik

Der 2.Teil, welcher die Grafik darstellt, ist etwas versetzt angeordnet.
Markieren sie die Spalten C:AH und stellen sie die Spalten-Breite schmal ein, z.B. auf den Wert =0.75cm bzw. 3.5 (Excel)
Markieren sie den Bereich B10:AH42 und reduzieren sie die Schriftgröße, z.B. auf 9pt.
   BCDE   AH
10  0=D10+1 =AG10+1
11  =$B$3=D11+$B$5 =AG11+$B$5
12 0=$B$7=julia(D$11;$C12;$B$1;$B$2) =julia(E$11;$C12;$B$1;$B$2)  =julia(AH$11;$C12;$B$1;$B$2)
13=B12+1=C12-$B$8=julia(D$11;$C13;$B$1;$B$2) =julia(E$11;$C13;$B$1;$B$2) =julia(AH$11;$C13;$B$1;$B$2)
 
42=B41+1=C41-$B$8=julia(D$11;$C42;$B$1;$B$2) =julia(E$11;$C42;$B$1;$B$2) =julia(AH$11;$C42;$B$1;$B$2)

Zählung der Zellen

In Zeile 10 werden die Zellen ('Bildpunkte') in X-Richtung gezählt. Füllen sie Zelle E10 nach rechts bis AH10 aus.
In Spalte B werden die Zellen in Y-Richtung gezählt. Füllen sie Zelle B13 nach unten bis B42 aus.

Koordinaten

In Zeile 11 werden die X-Koordinaten berechnet. Füllen sie Zelle E11 nach rechts bis AH11 aus.
In Spalte C werden die Y-Koordinaten berechnet. Füllen sie Zelle C13 nach unten bis C42 aus.

Julia

In den Zellen D12:AH42 werden die Pseudo-'Bildpunkte' berechnet. Füllen sie Zelle D12 nach rechts bis AH12 und danach weiter bis AH42 aus. Die angezeigten Werte sollten im Zentrum >20 betragen, am Rand <10

Format

Markieren sie Zelle D12 und legen sie eine bedingte Formatierung an:
Menü Format | Bedingte Formatierung:
Klicken sie so lange auf den Button 'Hinzufügen', bis (mindestens) 3 Bedingungen angezeigt werden.
Stellen sie ein:
• Bedingung 1: Zellwert>14; Format: Muster (Hintergrund) dunkelblau, Schrift weiß
• Bedingung 2: Zellwert>10; Muster: mittelblau
• Bedingung 3: Zellwert>9: Muster: hellblau
♣ Sie sehen die Wirkung erst dann, wenn sie das Format dieser Zelle kopieren und in den gesamten Bereich D12:AH42 einfügen.
Wenn alles funktioniert, dann wird die Julia-Menge im Bereich D12:AH42 in 4 Farben dargestellt. Sie können die Form der Julia-Menge durch Eingabe der Konstanten c (=Zellen B1,B2) ändern. Beginnen sie mit kleinen Änderungen.
Sie können den angezeigten Bereich durch Eingabe in die Zellen B3;B4;B6;B7 ändern.

2D- oder 3D-Grafik

Unabhängig von der 'Bedingten Formatierung' kann man die Julia-Menge auch mit einem Oberflächen-Diagramm darstellen: 		Markieren sie den Bereich D12:AH42 und erstellen sie eine Grafik des Typs 'Oberfläche'. Man kann derartige Diagramme in 2dimensionaler Form (wie eine Landkarte) oder 3dimensionaler Form (Relief) anzeigen lassen.

Julia Grafik mit PHP
Das hier vorgestellte Programm erzeugt Live eine 'Dynamische Grafik', die man in jede eigene Webseite einbetten und mit jedem gängigen Browser anzeigen kann.

Die meisten Vorgaben sind im Programm einstellbar, die Julia-Konstante c, welche die Form der Julia.Grafik bestimmt, kann man Live durch User-Angaben steuern.

An dieser Stelle werden keine Einzelheiten der PHP-Programmierung vorgestellt.
♦ Details zur Erzeugung von Pixel-Grafik mit PHP, Übergabe von Argumenten (User-Daten) an PHP, Farben in der Informatik

Die rechts angezeigte Grafik wurde mit dem vorgestellten Programm erzeugt, wird hier jedoch nicht Live erzeugt, um den Webserver nicht zu belasten. Wenn sie die Grafik mit ihrem eigenen PC Live berechnen lassen, müssen sie je nach Größe und PC-Leistung mit 1..100 Sekunden Prozessor-Zeit rechnen. 		Muster einer Julia-Grafik, erzeugt mit dem hier vorgestellten Programm:
Das Beispiel zeigt die Menge mit c=(0,-1) im Bereich -1.5...+1.5 der X-und Y-Achsen

Um diese Grafik mit dem vorgestellten Programm Live zu erzeugen, braucht man einen Webserver und die Programmiersprache PHP. Diese Komponenten können sich bei ihrem Web-Provider befinden, oder an einem Server-PC im eigenen lokalen Netzwerk, oder an einem Arbeits-PC. Die Software kann man kostenfrei aus dem Internet laden.
♦ Details zu den Vorgaben und zur Anwendung am ↓ Ende dieses Kapitels.
● Am Beginn des Programms wird die → MIME-Type des erzeugten Produkts angegeben.

● Die meisten Vorgaben sind im Quelltext eistellbar, z.B. die Größe des erzeugten Grafik in Bildpunkten (px), der angezeigte Bereich der XY-Koordinaten und die Umrechnung der Ergebnisse der Julia-Funktion in Farb-Werte: Im Beispiel werden Ergebnisse n<=8 mit dem kleinsten Farb-Wert =0 angezeigt, Ergebnisse n>=25 mit dem größten Farb-Wert =255
Die Rechenzeit hängt stark von der Größe der Grafik $imgx,$imgy ab. Die hier angegeben Werte erzeugen eine Grafik von 300x300=90000 Pixel.

● Die Julia-Konstante c wird mit den 'klassischen' Werten cx=0, cy=1 vorgegeben und lässt sich durch interaktive Angaben der AnwenderInnen (GET-Methode) beliebig ändern.
Man kann die Julia-Konstante alternativ in den Quelletext-Vorgaben festlegen, oder umgekehrt einige der Vorgaben ebenfalls mit GET-Argumenten interaktiv einstellen.

● Nach Festlegung der Vorgaben werden die Faktoren für die notwendigen Skalierungen berechnet: Umrechnung der XY-Koordinaten in XY-Pixel, Umrechnung der Ergebnisse der Julia-Funktion in Farb-Werte.

● Die Julia-Funktion ist entsprechend den oben gezeigten Angaben programmiert.
Die Julia-Konstante c wird in den Variablen $cx,$cy global verwaltet.
Der Startpunkt wird mit den Argumenten $sx,$sy an die Funktion übergeben.
Beim Überschreiten des Werte-Bereichs werden keine Fehler ausgelöst, sondern die Werte NaN (Not a Number) oder INF (Unendlich). Diese beiden Fälle werden mit den PHP Standard-Funktionen is_nan(), is_infinite() getestet und damit die while-Schleife abgebrochen. Die Schleife wird in jedem Fall nach maximal 1000 Schritten abgebrochen, in diesem Fall wird n=-1 zurückgegeben.

● Das Image-Objekt $img wird in der vorgegebenen Größe erzeugt, danach die Farbe des Hintergrunds $cbg (hier: schwarz) festgelegt.
In je einer for-Schleife werden die Koordinaten aller Bildpunkte $x,$y durchlaufen.
Für jeden Bildpunkt wird die Julia-Funktion berechnet. Die Koordinaten des Startpunkts $sx,$sy werden durch 'Lineare Transformation' aus jenen der Bildpunkte $x,$y berechnet.
Das Ergebnis (=Anzahl der berechenbaren Elemente) $n wird in Farb-Werte $r,$g,$b umgerechnet und mit der → GD-Funktion imagesetpixel() die Farbe des Bildpunkts gesetzt.
Im Beispiel werden alle 3 → RGB-Farben mit unterschiedlichen Faktoren verändert. Man kann die Farbe auch beliebig anders aus dem Ergebnis $n berechnen.

Zuletzt wird das Image-Objekt $img als → Datenstrom an den Browser gesendet, welcher die Grafik anzeigt. 		PHP-Programm zur Erzeugung einer dynamischen Julia-Grafik, z.B. als Text-Datei julia.php
<?php
header('Content-type: image/png');
header('Cache-Control: no-cache');

//########## Einstellbare Vorgaben ##########
$imgx=300; $imgy=300;   // Bild-Groesse (px)
$xmin=-2; $xmax=2;   // X-Skala
$ymin=-2; $ymax=2;   // Y-Skala
$nmin=8; $nmax=25;   // Farb-Skala

//########## GET ##########
$cx=0; $cy=1;
if(isset($_GET['cx'])) {$cx=$_GET['cx']+0;}
if(isset($_GET['cy'])) {$cy=$_GET['cy']+0;}

//########## Skalierungen ##########
$kx = ($xmax-$xmin) / $imgx;
$dx = $xmin;
$ky = -($ymax-$ymin) / $imgy;
$dy = $ymax;
$kcol = 255 / ($nmax-$nmin);
$dcol = -$nmin * $kcol;

//########## Julia-Funktion ##########
function julia($sx,$sy) {
global $cx,$cy;
$jx = $sx;   $jy = $sy;
$n = 0;
while($n>=0) {
$jxq = $jx*$jx - $jy*$jy + $cx;
$jyq = 2 * $jx * $jy + $cy;
if(is_nan($jxq) || is_nan($jyq)) {break;}
if(is_infinite($jxq) || is_infinite($jyq)) {break;}
$n++;
if($n>1000) {$n=-1;}
$jx = $jxq;   $jy = $jyq;
}
return $n;
}
//########## Image-Objekt ##########
$img=imagecreatetruecolor($imgx,$imgy);
$cbg=imagecolorallocate($img,0,0,0);
for($x=0;$x<=$imgx;$x++) {
$sx = $x * $kx + $dx;
for($y=0;$y<=$imgy;$y++) {
$sy = $y * $ky + $dy;
$n = julia($sx,$sy);
if($n>0) {
$b = round($n*$kcol+$dcol,0);
$g = $b/8;   $r = $b/3;
$cj = imagecolorallocate($img,$r,$g,$b);
imagesetpixel($img,$x,$y,$cj);
}
}
}
imagejpeg($img);
imagedestroy($img);
?>

Voraussetzungen

Zur Anwendung des vorgestellten Programms braucht man einen → Webserver, welcher mit der Programmiersprache → PHP zusammenarbeitet. Der Server kann sich bei ihrem Web-Provider befinden, oder am eigenen → Server-PC ihres lokalen Netzwerks, oder an ihrem Arbeits-PC.

● Man kann die Software für alle gängigen Betriebssyssteme kostenfrei laden und am eigenen Server- oder Arbeits-PC installieren.
Alle gängigen Linux-Distributionen enthalten bereits diese Komponenten, oder können sie auf Wunsch mit Mausklick installieren.
Auf Windows-Systemen muss man die Software selbst installieren:
♦ Details zur Installation aller WAMP-Komponenten, des Apache-Webservers, der Programmiersoprache PHP auf Windows.

Anwendung:

Man kann die vom PHP-Programm Live erzeugte Grafik als HTML <img>-Element in jede eigene Webseite einbetten, z.B.
<img src="julia.php" />
<img src="julia.php" style="width:300px; height:300px;" />
Mit dem Attribut src wird der Pfad zur PHP-Datei festgelegt. In diesem Fall wird angenommen, dass sich die Datei im gleichen Verzeichnis (Ordner) wie die Webseite *.html befindet, daher reduziert sich der Pfad auf die Angabe des Datei-Namens.

• Optional kann man Daten als Argumente an das Programm übergeben, z.B. in der Form
<img src="julia.php?cx=0.25&cy=1.25" />
Die Argumente werden meistens mit Hilfe eines HTML-Formulars (<form>) Live eingegeben und automatisch an das PHP-Programm gesendet.
♦ Details zur Übergabe von Argument-Daten an ein PHP-Programm.

Julia Funktion mit C/C++
Nur die mit → C/C++ oder Java erzeugten Programme sind schnell genug für die praktische Erzeugung von Julia- (oder Mandelbrot)-Grafik. Man kann die Funktionen auch mit jeder anderen Programmiersprache erstellen, die Grafik muss sich dann jedoch auf wenige Bildpunkte beschränken oder die Erzeugung dauert lange (Sekunden ... Minuten). Die Herstellung von → Pixel-Grafik mit C/C++ erfordert die Installation der GD-Library und mäßig fortgeschrittene Kenntnisse.
An dieser Stelle wird nur die Julia-Funktion mit C/C++ vorgestellt: Man kann damit zumindest einfache Experimente ausführen.
Das Beispiel zeigt ein einfaches, jedoch vollständiges C-Programm.

• Alle Argumente der Julia-Funktion cx,cy,sx,sy sind im Quelltext des Hauptprogramms vorgegeben.

• Die Programmierung der Julia-Funktion erfolgt gleich wie für alle anderen Beispiele dieser Seite.

• Die Abbruch-Bedingung ist eine Besonderheit: In der 2. Zeile des Quelltexts wird dazu die Makro-Funktion is_nan() definiert.
Da viele Compiler keine Funktionen zum Erkennen von NaN (not a number) oder INFINITY bieten, wird dazu der Vergleich mit sich selbst verwendet, der nur in diesen Fällen nicht zutrifft.

• Wenn man die führenden // Kommentar-Zeichen entfernt, dann werden die einzelnen Schritte der Berechnung mit → Funktion printf() dokumentiert.

Das Programm berechnet in dieser Minimal-Version nur einen einzigen Punkt der Julia-Funktion.

Anregungen zur Erweiterung:
• Interaktive Eingabe von sx und sy mit Funktion scanf()
• Berechnung von → Zufalls-Werten (-2...+2) für sx und sy
• Verschachtelte Schleifen zur automatischen Variation von sx und sy - Das ist bereits die Vorbereitung zur Herstellung einer Julia-Grafik.
#include <stdio.h>
#define is_nan(x) ((x)!=(x))

int julia(double,double,double,double);

int main() {
int j;
double cx,cy,sx,sy;
cx=0.0;   cy=1.0;
sx=1.0;   sy=0.0;
j = julia(cx,cy,sx,sy);
printf("julia(%f,%f) = %d\n",sx,sy,j);
return 0;
}

int julia(double cx,double cy,double sx,double sy) {
int n;
double jx,jxq,jy,jyq;
jx=sx;   jy=sy;
n=0;
while(n>=0) {
jxq = jx*jx - jy*jy + cx;
jyq = 2.0 * jx * jy + cy;
// printf("n=%d, jxq=%E, jyq=%E\n",n,jxq,jyq);
if(is_nan(jxq) || is_nan(jyq)) {break;}
n++;
if(n>1000) {n=-1;}
jx = jxq;   jy = jyq;
}
return n;
}

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Algorithmen   >   Reihen-Entwicklung   >   Julia-Menge