Mandelbrot

Berechnung mit Reihen-Entwicklung

Die Entdeckung und Beschreibung der Mandelbrot-Funktion war eine wichtige Stufe auf dem Weg zu den heute vielfach verwendeten Fraktalen und zum Verständnis dynamischer und chaotischer Systeme. Auf dieser Seite werden Methoden zur praktischen Berechnung der Mandelbrot-Funktion vorgestellt.
Algorithmen Ausgewählte IT-Rezepte, Iterationen
Mandelbrot-Funktion Die Entdeckungen von Benoît B. Mandelbrot
Mandelbrot-Algorithmus Berechnung der Mandelbrot-Funktion
Mandelbrot Grafik Herstellung mit Kalkulations-Programmen und Visual Basic (VBA)
Mandelbrot mit PHP Herstellung einer Mandelbrot-Grafik mit PHP
Mandelbrot mit C/C++ Mandelbrot-Funktion mit C/C++
Mandelbrot-Farben Willkürliche Umsetzung der Funktion in Farben
Julia Berechnung der eng verwandten Julia-Menge

Mandelbrot-Funktion
Quelle: Wikipedia
Benoît B. Mandelbrot (1924 - 2010) war ein genialer Mathematiker mit internationalen Wurzeln. Er wurde in Polen als Kind einer litauischen Familie geboren, in Frankreich ausgebildet, u.a. von Gaston Julia. Später zog er in die USA, wo er eine glänzende Karierre bei IBM und an verschiedenen Universitäten absolvierte.

Er erforschte insbesondere die 'Julia'-Funktionen komplexer Zahlen. Dabei interessiert weniger das Ergebnis einzelner Funktionen, sondern ihr Verhalten bei fortgesetzter Anwendung (Iteration). Ein philosophisch interessantes Ergebnis ist, dass gerade die einfachsten Funktionen eine unglaublich große Menge an vielfältigen Ergebnissen liefern können.

Die Mandelbrot-Funktion steht in engem Zusammenhang mit der → Julia-Menge: Jeder einzelne (Bild)-Punkt der Mandelbrot-Funktion ist der 'Startpunkt' für eine dort ansetzende Julia-Funktion. 		Dieses Bild zeigt eine Mandelbrot-Grafik. Sie wurde mit dem auf dieser Seite vorgestellten ↓ PHP-Programm hergestellt.

Hier wird nicht auf Herleitung, Bedeutung oder Anwendung der Mandelbrot-Funktion 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 Mandelbrot-Iterationen in Farben umgesetzt werden. Das übersteigt zwar die Grenzen einfacher Kalkulations-Programme, ist jedoch eine lohnende Aufgabe für beliebige Programmiersprachen.

Mandelbrot-Algorithmus

ℂ   Komplexe Zahlen

Alle Mandelbrot- und 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.

Mandelbrot- und 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.

Julia-Funktionen

setzen eine komplexe Konstante c voraus und beschreiben das Verhalten der Funktion ausgehend von variablen Startpunkten z[0]
Je nach Wahl der Konstanten c erhält man unendlich viele verschiedene Mengen (2dimensionale Grafiken).

Mandelbrot-Funktion

Diese Funktion geht von einem fixen Startpunkt z[0,0] aus und beschreibt das Verhalten der Funktion bei variablen Werten der komplexen Variablen c
Es gibt für diesen Startpunkt nur eine einzige Mandelbrot-Grafik, von der sich allerdings herausgestellt hat, dass ihre Details sehr interessant sind, und dass sie unendlich komplex ist.

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) Der komplexe Startpunkt S(sx,sy) wird mit sx=0 und sy=0 festgelegt.

(2) Zur Berechnung eines einzelnen Funktionswerts (= 1 Bildpunkt der Mandelbrot-Grafik) muss man eine komplexe Variable c(cx,cy) festlegen.
In der Praxis berechnet man keine einzelnen Funktionswerte, sondern je einen Wert für jeden einzelnen Bildpunkt der Mandelbrot-Grafik. Dazu variiert man die Koordinaten cx,cy in 2 ineinander geschachtelten Schleifen (bildlich umgesetzt: von links nach rechts und von oben nach unten).
(3) Die Koordinaten des fixen Startpunkts (0,0) 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 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 - meistens schwarz.
• 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-Calc, OpenOffice-Calc, MS-Excel, ...
   ABCD
1cx=ZUFALLSZAHL()*3-2n[max]*=WENN(D2=MAX(A5:A1000);-1;D2)
2cy=ZUFALLSZAHL()*2-1n[max]=MAX(D5:D1000)
3    
4nzxzyn*
5000=WENN(ISTZAHL(C5);A5;0)
6=A5+1=B5^2-C5^2+$B$1=2*B5*C5+$B$2=WENN(ISTZAHL(C6);A6;0)
...
55=A54+1=B54^2-C54^2+$B$1=2*B54*C54+$B$2=WENN(ISTZAHL(C55);A55;0)
• Die Vorgabe des Startpunkts wird in den 2 Zellen B1:B2 eingegeben.
• Mit Klick auf Taste F9 werden neue Zufallswerte verwendet.
Alternativ kann man die Koordinaten in B1:B2 manuell eingeben.
• In Zeile 5 werden die Anfangswerte des Zählers (n) und der Koordinaten (zx,zy) festgelegt.
• In Zeile 6 sind bereits die Formeln zur Berechnung von Element z[1] aus dem vorherigen Element z[0] eingetragen. Man kann den Bereich A6:C6 und D5 nach unten ausfüllen, z.B. bis Zeile 55 = Element 50
• Je nach Anfangswert werden mehr oder weniger Elemente berechnet. Wenn der Werte-Bereich überschritten wird, dann enthalten die letzten Zellen den Fehler-Wert #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.
• Die maximale Anzahl berechenbarer Elemente) wird in D2 zusammengefasst.
• Das Ergebnis in D1 wird =-1 gesetzt, wenn die Reihe nicht divergiert - Das ist für den 'inneren' Bereiech um den Nullpunkt der Fall (in der Grafik schwarz angezeigt). Andernfalls wird das Ergebnis auf die maximale Anzahl berechenbarer Elemente gesetzt. Aus diesem Ergebnis wird die Farbe des jeweiligen Bildpunkts berechnet.
♣ Tipp: Klicken sie mehrmals die Taste F9, um die Funktion für verschiedene zufällige Werte von c zu berechnen:
Für die im Beispiel angegeben Daten sollte das Ergebnis in D4 entweder =-1 oder Werte im Bereich 11...50 annehmen.

Mandelbrot (Pseudo)-Grafik mit Kalkulation + Visual Basic (VBA)
Man kann jedes Standard Kalkulations-Programm z.B. LibreOffice-Calc, OpenOffice-Calc, 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 der Mandelbrot-Funktion 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.

Mandelbrot-Funktion

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

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

• Danach werden in einer while-Schleife alle weiteren Elemente der Reihe berechnet.
Die Koordinaten jedes neuen Elements werden in xq,yq berechnet und danach auf x,y übertragen.

• Die Schleife wird 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 mz. Dort wird die fortlaufenden Nummer n des letzten berechneten Elements zurückgegeben und die Funktion beendet.
Für kleine Werte von c divergiert die Funktion nicht oder nur langsam und die Mandelbrot-Funktion gibt den Wert -1 zurück, der in einer Grafik meist schwarz dargestellt wird.
Zur Sicherheit wird die Schleife in jedem Fall nach maximal 100 Elementen abgebrochen und das Ergebnis =0 zurückgegeben. 		Visual Basic (VBA) Funktion zur Berechnung der maximal berechenbaren Anzahl von Elementen einer Mandelbrot-Reihe.
Function mandel_iter(cx As Double, cy As Double) As Double
Dim doloop As Boolean
Dim n As Long
Dim x, y, xq, yq As Double
x = 0
y = 0
n = 0
doloop = True
On Error GoTo mz
While doloop
xq = x * x - y * y + cx
yq = 2 * x * y + cy
x = xq
y = yq
n = n + 1
If (n > 100) Then doloop = False
Wend
n = -1
mz:
mandel_iter = CDbl(n)
End Function

Kalkulation - Vorgaben

   AB
1x[min]-2
2x[max]2
3Δx =(B2-B1)/AG8
4y[min]-1
5y[max]1
6Δy =(B5-B4)/A40
Fortgeschritten AnwenderInnen können mit einem Standard Kalkulations-Programm eine einfache Pseudo-Grafik der Mandelbrot-Funktion 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 x[min],x[max],y[min],y[max] geben den von der Pseudo-Grafik anzuzeigenden Bereich an.

Kalkulation - Pseudografik

Der 2.Teil stellt die Mandelbrot-Grafik in vereinfachter Form dar.
Markieren sie die Spalten C:AG und stellen sie die Spalten-Breite schmal ein, z.B. auf den Wert =0.75cm bzw. 3.5 (Excel)
Markieren sie den Bereich A8:AG40 und reduzieren sie die Schriftgröße, z.B. auf 9pt.
   ABCD   AG
8  0=C8+1 =AF8+1
9  =$B$1=C9+$B$3 =AF9+$B$3
10 0=$B$5=mandel_iter(C$9;$B10) =mandel_iter(D$9;$B10)  =mandel_iter(AG$9;$B10)
11=A10+1=B10-$B$6=mandel_iter(C$9;$B11) =mandel_iter(D$9;$B11) =mandel_iter(AG$9;$B11)
... ...
40=A39+1=B39-$B$6=mandel_iter(C$9;$B40) =mandel_iter(D$9;$B40) =mandel_iter(AG$9;$B40)

Zählung der Zellen

In Zeile 8 werden die Zellen ('Bildpunkte') in X-Richtung gezählt. Füllen sie Zelle D8 nach rechts bis AG8 aus.
In Spalte A werden die Zellen in Y-Richtung gezählt. Füllen sie Zelle A11 nach unten bis A40 aus.

Koordinaten

In Zeile 9 werden die X-Koordinaten berechnet. Füllen sie Zelle D9 nach rechts bis AG9 aus.
In Spalte B werden die Y-Koordinaten berechnet. Füllen sie Zelle B11 nach unten bis B40 aus.

Mandelbrot

In den Zellen C10:AG40 werden die Pseudo-'Bildpunkte' berechnet. Füllen sie Zelle C10 nach rechts bis AG10 und danach weiter bis AG40 aus. Die angezeigten Werte sollten im Zentrum -1 betragen, am Rand ca. 11
Formatieren sie den gesamten Bereich der Pseudo-Grafik C10:AG40 mit Muster (Hintergrund) = dunkelgrau.

Format

Markieren sie Zelle C10 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>=20; Format: Muster (Hintergrund) dunkelblau, Schrift weiß
• Bedingung 2: Zellwert>=14; Muster: mittelblau
• Bedingung 3: Zellwert>=0: Muster: weiss
♣ Sie sehen die Wirkung erst dann, wenn sie das Format dieser Zelle kopieren und in den gesamten Bereich C10:AG40 einfügen.
Wenn alles funktioniert, dann wird eine grob aufgelöste Version der Mandelbrot-Grafik im Bereich C10:AG40 in 4 Farben dargestellt. Sie können den angezeigten Bereich durch Eingabe der Grenzen (=Zellen B1,B2,B4,B5) ändern.

2D- oder 3D-Grafik

Unabhängig von der 'Bedingten Formatierung' kann man die Mandelbrot-Grafik auch mit einem Oberflächen-Diagramm darstellen: 		Markieren sie den Bereich C10:AG40 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.

Mandelbrot 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, sollten sie je nach Größe und PC-Leistung mit 1..100 Sekunden Prozessor-Zeit rechnen. 		Muster einer Mandelbrot-Grafik, erzeugt mit dem hier vorgestellten Programm:
Das Beispiel zeigt die Funktion in einem vergrößerten Ausschnitt.

Um diese Grafik 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 Mandelbrot-Funktion in Farb-Werte: Im Beispiel werden Ergebnisse n<=10 mit dem kleinsten Farb-Wert =0 angezeigt, Ergebnisse n>=30 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.

● 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 Mandelbrot-Funktion ist entsprechend den oben gezeigten Angaben programmiert.
Die (Julia)-Variable c wird mit den Argumenten $cx,$cy 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 Mandelbrot-Funktion berechnet. Die Koordinaten der (Julia)-Variablen $cx,$cy 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 Mandelbrot-Grafik, z.B. als Text-Datei mandelbrot.php
<?php
header('Content-type: image/png');
header('Cache-Control: no-cache');
//########## Einstellbare Vorgaben ##########
$imgx=300; $imgy=300;   // Bild-Groesse (px)
$xmin=-2; $xmax=0.75;   // X-Skala
$ymin=-1; $ymax=1;   // Y-Skala
$nmin=10; $nmax=30;   // Farb-Skala
//########## Skalierungen ##########
$kx=($xmax-$xmin)/$imgx;
$dx=$xmin;
$ky=-($ymax-$ymin)/$imgy;
$dy=$ymax;
$kcol=255/($nmax-$nmin);
$dcol=-$nmin*$kcol;
//########## Mandelbrot-Funktion ##########
function mandelbrot($cx,$cy) {
$jx = 0;
$jy = 0;
$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++) {
$cx = $x * $kx + $dx;
for($y=0;$y<=$imgy;$y++) {
$cy = $y * $ky + $dy;
$n = mandelbrot($cx,$cy);
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="mandelbrot.php" />
<img src="mandelbrot.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.

Mandelbrot Grafik mit C/C++
Nur die mit → C/C++ oder Java erzeugten Programme sind schnell genug für die praktische Erzeugung von 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 Mandelbrot-Funktion mit C/C++ vorgestellt: Man kann damit zumindest einfache Experimente ausführen.
Das Beispiel zeigt ein einfaches, jedoch vollständiges C-Programm.

• Die Argumente der Mandelbrot-Funktion cx,cy sind im Quelltext des Hauptprogramms vorgegeben.

• Die Programmierung der Mandelbrot-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 Mandelbrot-Funktion.

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

int mandelbrot(double,double);

int main() {
int mb;
double cx,cy;
cx=1;   cy=1;
mb = mandelbrot(cx,cy);
printf("mandelbrot(%f,%f) = %d\n",cx,cy,mb);
return 0;
}

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

Mandelbrot Farben
Die Mandelbrot-Funktion selbst erzeugt keine Farben.
Jede grafische Darstellung - auch die hier vorgestellte - ist eine willkürliche Interpretation dieser Funktion. Andererseits ist das Verhalten der Mandelbrot-Funktion so komplex, dass man an einer Grafik nicht vorbeikommt: Man ist praktisch gezwungen, die Funktion auf irgend eine sinnvolle Weise in eine Grafik umzusetzen. 		Die Beispiele dieser Seite verwenden zur Übersetzung der Funktion in Farben besonders einfache Algorithmen. Alle gängigen 'Mandelbrot'-Programme treiben wesentlich mehr Aufwand, um mit weniger Rechenzeit mehr Auflösung und eine größere Vielfalt von Farben zu erzeugen.

Divergenz-Grenze

Der interessanteste Bereich der Mandelbrot-Funktion ist die Grenze zum divergenten Verhalten, in der Grafik sichtbar als Grenze zwischen dem inneren - meist schwarz gefärbten - Bereich und dem Außen-Bereich, der meist (auch hier) bunt eingefärbt ist.

Die Grenze des divergenten Verhaltens ist unendlich lang, da sie in umso mehr Details gegliedert ist, je mehr man sie vergrößert.

Je näher man der Grenze kommt, umso größer wird die Anzahl sinnvoller Iterationen. Mit zunehmender Vergrößerung braucht man daher immer mehr Iterations-Schritte und Rechenzeit. Dieses Verhalten muss man bei der Umsetzung der Funktion in Farben berücksichtigen, daher sind die Algorithmen zur Festlegung der Farbe meist an die dargestellte Vergrößerung gebunden.

Abbruch der Reihe

In den hier vorgestellten Beispielen wird die Berechnung (Schleife) abgebrochen, wenn ein Fehler durch Überschreitung der berechenbaren Werte-Grenze auftritt. Das ist einfach zu programmieren, verschwendet jedoch viel Rechenzeit mit der Berechnung zahlreicher großer Zahlen.
• Man kann die Rechnung sehr beschleunigen, wenn man die Schleife bereits früher abbricht.
• Bei zunehmender Vergrößerung von Details nimmt allerdings die Anzahl sinnvoller Iterations-Schritte rasch zu. Man muss daher die gesetzte Grenze an die Vergrößerung anpassen.

Anzahl der Iterationen

In den hier vorgestellten Beispielen wird zur Codierung der Farbe lediglich die Anzahl der berechenbaren Elemente herangezogen.
• Das ist eine ganze Zahl, die bei grober Darstellung der gesamten Mandelbrot-Funktion nur wenige Werte annimmt - in den gezeigten Beispielen ca. 11...50 - Damit lassen sich auch nur wenige Farben darstellen. Deshalb zeigen Gesamt-Darstellungen der Mandelbrot-Funktion oft nur grobe Farbstufen.

Andere Indikatoren

Wenn die Anzahl der berechneten Elemente ein zu grobes Maß ist, dann werden meist andere Variablen zur Farb-Codierung herangezogen, die eine feinere Abstufung erlauben.
• Unverbindliches Beispiel ist der Betrag der Koordinaten sqrt(x^2+y^2) oder sein Quadrat. Man gibt diese Werte bei Abbruch der Schleife an Stelle der hier verwendeten Anzahl der Iterationen zurück.
Diese Variablen liefern feiner abgestufte Gleitkomma-Werte, werfen jedoch ein neues Problem auf: Sie andern sich höchst ungleichmäßig, daher verwendet man zur Umsetzung in Farb-Werte nicht ihre Werte, sondern deren Logarithmen, teilweise noch wesentlich kompliziertere Funktionen.
All diese willkürlichen Maßnahmen sind prinzipiell zulässig, wenn sie das Verhalten der Mandelbrot-Funktion sinnvoll darstellen. Man darf sie jedoch nicht als exakt folgerichtige Darstellungen auffassen, sondern als Maßnahmen zur leichter verdaulichen Konsumation der Ergebnisse.

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