Mandelbrot-Menge (Praktische Berechnung)

Die grafische Darstellung der Mandelbrot-Menge und ihrer Strukturen im Randbereich ist nur mittels Computer durch sogenannte Fraktalgeneratoren möglich. Dabei entspricht jeder Bildpunkt einer Zahl $c$ der komplexen Ebene. Der Computer ermittelt für alle Bildpunkte, ob die zugehörigen Folgen divergieren oder nicht. Sobald der Betrag $| z_{n} |$ eines Folgengliedes die Fluchtgrenze $s = 2$ überschreitet, ist klar, dass die Folge divergiert; die Iterationszahl $n$ kann als Maß für den Divergenzgrad dienen. Die Bildpunkte werden nach einer Farbtabelle eingefärbt, die jeder Iterationszahl eine Farbe zuordnet.^[1]

Für harmonische Farbübergänge wird in der Praxis ein Fluchtradius $r > 2$ gewählt, da andernfalls die Breite der Farbstreifen zu sehr oszilliert. Je größer der Fluchtradius gewählt wird, desto besser entsprechen die Farbgrenzen den Äquipotentiallinien, die sich ergeben, wenn die Mandelbrot-Menge als elektrisch geladener Leiter interpretiert wird. Für kontinuierliche Farbverläufe, wie in der obigen Galerie einer Zoomfahrt, ist es erforderlich, entweder die genaue Fluchtzeit $t$ zu ermitteln, bei der der Fluchtradius $r$ gerade erreicht wird, oder den Abstand $d$ zum Rand der Menge abzuschätzen.^[2]

Da die Anzahl der Iterationsschritte $n,$ nach der die Fluchtgrenze $s = 2$ überschritten wird, beliebig groß sein kann, muss als Abbruchkriterium eine maximale Iterationszahl $n_{max}$ festgelegt werden. Alle Zahlen $c,$ deren Folgen danach einen Fluchtradius $r > 2$ noch nicht erreicht haben, werden zur Menge $𝕄$ gezählt. Je geringer der Abstand von $c$ zum Rand der Menge ist, desto größer ist in der Regel die Iterationszahl $n,$ bei der $r$ erreicht oder überschritten wird. Je stärker die Vergrößerung ist, mit der der Rand dargestellt wird, desto größer muss die maximale Iterationszahl $n_{max}$ gewählt werden, und umso mehr Rechenzeit ist nötig.

Ein erheblicher Teil der Rechenzeit wird dort benötigt, wo die Zahlenfolge nicht divergiert. Moderne Programme versuchen daher, die Rechenzeit an diesen Stellen durch verschiedene Verfahren zu verkürzen. Eine Möglichkeit besteht darin, die Berechnung abzubrechen, sobald die Zahlenfolge konvergiert oder in einem periodischen Zyklus gefangen ist. Andere Programme nutzen aus, dass das Innere einer geschlossenen Kurve automatisch in $𝕄$ liegt, wenn der Randbereits zu $𝕄$ gehört.^[3]

Grafisch besonders reizvoll ist die Darstellung des Randes von $𝕄$ mit seinem Formenreichtum. Je stärker die gewählte Vergrößerung ist, umso komplexere Strukturen lassen sich dort finden. Mit entsprechenden Computerprogrammen lässt sich dieser Rand wie mit einem Mikroskop mit beliebiger Vergrößerung darstellen. Zur Untersuchung interessanter Strukturen sind häufig Vergrößerungen erforderlich, die mit hardwareunterstützten Datentypen aufgrund deren limitierter Genauigkeit nicht berechnet werden können. Manche Programme enthalten daher Langzahlarithmetik-Datentypen mit beliebig wählbarer Genauigkeit. Damit sind (fast) beliebige Vergrößerungsfaktoren möglich.

Interpolation und Distanzschätzung

Wenn der Fluchtradius $r$ groß genug ist, kann zur Ermittlung der Fluchtzeit $t$ anstelle der eigentlichen Folge $z_{n + 1} = z_{n}^{2} + c$ mit $z_{0} = 0$ die vereinfachte Folge $z_{n + 1} = z_{n}^{2} + 0$ mit $z_{0} = c$ betrachtet werden. Die ersten Folgenglieder sind dann $z_{0} = c,$ $z_{1} = c^{2},$ $z_{2} = c^{4}$ und $z_{3} = c^{8},$ ganz allgemein ergibt sich $z_{n} = c^{2^{n}} .$ Betrachtet man eine Iterationszahl $n,$ bei der die Folge einen Fluchtradius $r ≫ 2$ erreicht oder überschreitet, so gilt $| z_{n} | = | c |^{2^{n}} \geq r$ und $n = \log_{2} (\frac{\ln | z_{n} |}{\ln | c |}) .$ Bestimmt man nun die Fluchtzeit $t \leq n$ aus der Interpolation $| c |^{2^{t}} = r,$ so ergibt sich mit $t = \log_{2} (\frac{\ln r}{\ln | c |}) :$ ^[4]^[5]

n - t = \log_{2} (\frac{\ln | z_{n} |}{\ln | c |}) - \log_{2} (\frac{\ln r}{\ln | c |}) = \log_{2} (\frac{\ln | z_{n} |}{\ln r}) .

^[6]

Für $| z_{n} (c) | \geq r ≫ 2$ erhält man die Fluchtzeit $t (c) = n - \log_{2} (\frac{\ln | z_{n} (c) |}{\ln r})$ aus einer Korrektur (Normalisierung) der Iterationszahl $n .$ Die äquivalente Gleichung $\frac{1}{2^{n}} \ln | z_{n} (c) | = 2^{- t (c)} \ln r$ weist auf die enge Beziehung der Potentialfunktionen $Φ_{n} (c) = \frac{1}{2^{n}} \ln | z_{n} (c) |$ und $Ψ_{r} (c) = 2^{- t (c)} \ln r$ hin. Häufig wird das Potential als Grenzwert $V (c) = lim_{n \to \infty} Φ_{n} (c)$ definiert; die Potentialfunktion $Ψ_{e} (c) = 2^{- t (c)} = e^{- t (c) \ln 2}$ zur Eulerschen Zahl mit $\ln e = 1$ wird nach George Green mit $G (c)$ bezeichnet.^[7]^[8]

Nähert sich $c$ dem Rand der Menge, so wird das Potential immer kleiner und erreicht am Rand den Grenzwert null. Daher kann der kürzeste Vektor $\vec{v}$ vom Punkt $c$ zum Rand näherungsweise aus der Gleichung $Φ_{n} (c) + \vec{v} \cdot \nabla Φ_{n} (c) = 0$ durch ein Skalarprodukt mit dem Gradientenvektor $\vec{u} = \nabla Φ_{n} (c)$ ermittelt werden. Man erhält so eine Lösung $\vec{v}$ mit der Länge $| \vec{v} | = \frac{Φ_{n} (c)}{| \nabla Φ_{n} (c) |} = \frac{\ln | z_{n} (c) |}{| \nabla \ln | z_{n} (c) | |} .$ Aus $\nabla \ln | z_{n} (c) | = \frac{1}{| z_{n} (c) |} \nabla | z_{n} (c) |$ und $| \nabla | z_{n} (c) | | = | z_{n}^{'} (c) |$ folgt die Distanzformel:^[9]^[8]

d_{n} (c) = \frac{\ln | z_{n} (c) |}{| \nabla \ln | z_{n} (c) | |} = \ln | z_{n} (c) | : | \frac{z_{n}^{'} (c)}{z_{n} (c)} | = \ln | z_{n} (c) | \cdot | \frac{z_{n} (c)}{z_{n}^{'} (c)} | .

^[10]

Die ersten Polynome sind $z_{0} (c) = 0,$ $z_{1} (c) = c,$ $z_{2} (c) = c^{2} + c$ und $z_{3} (c) = (c^{2} + c)^{2} + c,$ die zugehörigen Ableitungensind $z_{0}^{'} (c) = 0,$ $z_{1}^{'} (c) = 1,$ $z_{2}^{'} (c) = 2 c + 1$ und $z_{3}^{'} (c) = 2 (c^{2} + c) (2 c + 1) + 1.$ Alle weiteren Folgenglieder ergeben sich aus der Iterationsvorschrift $z_{n + 1} (c) = z_{n}^{2} (c) + c$ und der Ableitungsregel $z_{n + 1}^{'} (c) = 2 z_{n} (c) z_{n}^{'} (c) + 1.$

Um die Distanzformel einzusehen, kann wieder die vereinfachte Folge $z_{n + 1} = z_{n}^{2} + 0$ mit $z_{0} = c$ betrachtet werden. Die zugehörige Julia-Menge ist genau der Rand des Einheitskreises, und mit $z_{n} = c^{2^{n}}$ und $z_{n}^{'} = 2^{n} c^{2^{n} - 1}$ ergibt sich

d_{n} = \ln | c^{2^{n}} | \cdot | \frac{c^{2^{n}}}{2^{n} c^{2^{n} - 1}} | = 2^{n} \ln | c | \cdot | \frac{c}{2^{n}} | = \ln | c | \cdot | c |,

was in der Nähe des Einheitskreises eine gute Näherung für den Abstand $d = | c | - 1$ zum Rand ist: $| c | = 1,1$ ergibt $d_{n} = \ln (1,1) \cdot 1,1 \approx 0,1$ und $| c | = 1,01$ ergibt $d_{n} = \ln (1,01) \cdot 1,01 \approx 0,01.$ Wenn der wirkliche Abstand zum Rand gleich $d$ ist, so ergibt die Distanzformel den Wert

d_{n} = \ln | z_{n} | \cdot | \frac{z_{n}}{z_{n}^{'}} | \approx \ln (1 + d) \cdot (1 + d) \approx d .

Es stimmt aber nicht, dass der Grenzwert $lim_{n \to \infty} d_{n}$ gegen den wirklichen Abstand $d$ konvergiert, tatsächlich gelten nur schwächere Ungleichungen. Die Abschätzung kann mithilfe der lambertschen W-Funktion jedoch etwas verbessern werden, und mit $W (d_{n}) \approx \ln (1 + d)$ erhält man:^[11]^[12]

d_{n} \approx \ln (1 + d) e^{\ln (1 + d)} ⟺ d \approx e^{W (d_{n})} - 1.

Deep Zoom und Störungsrechnung

Vergleich der Blockartefakte mit dem Original (beide Bilder haben dieselbe Pixelanzahl)^{[A 1]}

Prozessoren unterstützen in Hardware die Berechnung mit typischerweise 32-bit- und 64-bit-Gleitkommazahlen. Dies ermöglicht es, in die Mandelbrot-Menge etwa um den Faktor 10¹² bis 10¹³ hineinzuzoomen, bevor benachbarte Pixel keine unterschiedlichen Startwerte $c$ mehr annehmen können (und damit Fehler durch Blockartefakte offensichtlich werden).

Ab diesem Punkt reicht die Genauigkeit der in Hardware implementierten Arithmetik nicht mehr aus. Man ist gezwungen, auf in Software implementierte Routinen für hochgenaue Arithmetik auszuweichen, was bei aktuellen Prozessoren zu einem immensen Geschwindigkeitseinbruch führt.

Man kann diesen deutlich durch Nutzen von Störungsrechnung reduzieren. Diese Methode wurde 2013 von Kevin Martin beschrieben und 2021 von Zhuoran Yu um eine automatische Fehlerkorrektur erweitert.^[13]^[14]

Dazu wird ein (möglichst nicht divergenter) Referenzpunkt $c$ in hochgenauer Arithmetik durchgerechnet und die zugehörige Referenzserie $z_{n}$ in einfacher oder doppelter Genauigkeit aufgezeichnet:^[15]

z_{0}, z_{1}, z_{2}, z_{3}, \dots, z_{n} .

Für in der direkten Nähe liegende Punkte $c^{'} = c + δ$ würde sich die Serie ${z_{n}}^{'}$ ergeben:

{z_{0}}^{'}, {z_{1}}^{'}, {z_{2}}^{'}, {z_{3}}^{'}, \dots, {z_{n}}^{'} .

Man will nun die Abweichung $ε_{n} = {z_{n}}^{'} - z_{n}$ indirekt ermitteln, um die direkte Berechnung der Serie ${z_{n}}^{'}$ zu vermeiden. Dabei gilt:

z_{n + 1} = z_{n}^{2} + c

für die Berechnung des Referenzpunktes und

{z_{n^{'} + 1}}^{'} = {z_{n}}^{'}^{2} + c^{'}

mit

{z_{n^{'} + 1}}^{'} = z_{n + 1} + ε_{n + 1}

und

{z_{n}}^{'} = z_{n} + ε_{n}

für die Berechnung des Nachbarpunktes.

Setzt man ein, ergibt sich

z_{n + 1} + ε_{n + 1} = {z_{n^{'} + 1}}^{'} = {z_{n}}^{'}^{2} + c^{'} = {z_{n}}^{'}^{2} + (c + δ) = (z_{n} + ε_{n})^{2} + (c + δ) .

Man betrachtet die beiden äußeren Terme

z_{n + 1} + ε_{n + 1} = (z_{n} + ε_{n})^{2} + (c + δ)

und multipliziert aus

z_{n + 1} + ε_{n + 1} = (z_{n}^{2} + 2 z_{n} ε_{n} + ε_{n}^{2}) + (c + δ)

und setzt

z_{n + 1} = z_{n}^{2} + c

z_{n}^{2} + c + ε_{n + 1} = (z_{n}^{2} + 2 z_{n} ε_{n} + ε_{n}^{2}) + (c + δ)

und löst die Klammern auf und kürzt

z_{n}^{2} + c + ε_{n + 1} = z_{n}^{2} + 2 z_{n} ε_{n} + ε_{n}^{2} + c + δ

und erhält

ε_{n + 1} = 2 z_{n} ε_{n} + ε_{n}^{2} + δ .

Wegen $z_{0} = 0$ und ${z_{0}}^{'} = 0$ ist auch $ε_{0} = {z_{0}}^{'} - z_{0} = 0.$ Mit der abgespeicherten Referenzserie $z_{n}$ können die Abweichungen $ε_{n}$ der Reihe nach berechnet werden:

ε_{1} = 2 z_{0} ε_{0} + ε_{0}^{2} + δ = δ,

ε_{2} = 2 z_{1} ε_{1} + ε_{1}^{2} + δ,

ε_{3} = 2 z_{2} ε_{2} + ε_{2}^{2} + δ,

⋮

ε_{n} = 2 z_{n - 1} ε_{n - 1} + ε_{n - 1}^{2} + δ .

Solange diese Terme klein bleiben, verhält sich ${z_{n}}^{'} = z_{n} + ε_{n}$ ähnlich wie $z_{n} .$ Insbesondere bleibt die Serie ${z_{n}}^{'}$ beschränkt, wenn die Referenzserie $z_{n}$ und die Abweichungen $ε_{n}$ beschränkt sind. Wenn die Abweichungen jedoch zu groß werden, kann das zu Fehlern in der Darstellung (Glitches) führen. Im Prinzip kann man dann auf einen günstigeren Referenzpunkt innerhalb der Referenzserie ausweichen: Liegt ein Punkt $z = z_{n} + ε_{n}$ näher am Referenzpunkt $z_{m}$ als am aktuellen Referenzpunkt $z_{n},$ so kann er auch durch $z = z_{m} + ε_{m}$ dargestellt und die Abweichung aus der Differenz $ε_{m} = z - z_{m}$ berechnet werden. Allerdings verliert man bei einer solchen Subtraktion aufgrund der Auslöschung die notwendige Genauigkeit. Nur beim ersten Referenzpunkt $z_{m} = z_{0} = 0$ passiert das nicht, und die Abweichung ergibt sich zu $ε_{m} = z - 0 = z .$ Man kann somit die Referenzserie zurücksetzen, wenn $| z | < | ε_{n} |$ gilt, d. h. wenn der Abstand von $z$ zu $z_{0}$ kleiner als der Abstand von $z$ zu $z_{n}$ ist. Dieses gelegentliche Zurücksetzen der Referenzserie (Rebasing) hält die Abweichungen so klein wie möglich.

Praktische Anwendung

Das Programm „Kalles Fraktaler“ basiert auf diesem Ansatz, und die bilineare Approximation ermöglicht noch leistungsfähigere Fraktalgeneratoren. Die Iterationsvorschrift $ε_{n + 1} = (2 z_{n} + ε_{n}) \cdot ε_{n} + δ$ lässt sich linearisieren, wenn $| ε_{n} | ≪ | z_{n} |$ gilt, d. h. wenn $ε_{n}$ viel kleiner als $z_{n}$ ist und man $ε_{n}$ in der Summe $2 z_{n} + ε_{n}$ vernachlässigen kann.^[16]Benachbarte Linearisierungen $ε_{n + 1} = 2 z_{n} ε_{n} + δ,$ $ε_{n + 2} = 2 z_{n + 1} ε_{n + 1} + δ,$ $\dots,$ $ε_{n + k} = 2 z_{n + k - 1} ε_{n + k - 1} + δ$ lassen sich zur bilinearen Gleichung $ε_{n + k} = a_{n, k} ε_{n} + b_{n, k} δ$ zusammenfassen.^[17] Die Koeffizienten $a_{n, k}$ und $b_{n, k}$ werden vorab berechnet und dienen während der Iteration als Abkürzung, um viele Iterationen zu überspringen, wenn $| ε_{n} | ⋘ min {| z_{n} |, | z_{n + 1} |, \dots, | z_{n + k - 1} |}$ gilt, d. h. wenn $ε_{n}$ sehr viel kleiner als $z_{n},$ $z_{n + 1},$ $\dots,$ $z_{n + k - 1}$ ist. Häufig können über 90 % der Iterationen übersprungen werden, was die Berechnung extrem beschleunigt.^[18]^[19]

Probleme

Der verwendete Referenzpunkt sollte möglichst innerhalb der zu untersuchenden Iterationen nicht divergieren, da die Nachbarpunkte maximal bis zu dem Abbruch der Referenzserie untersucht werden können. Alle Punkte mit einer größeren Iterationszahl müssen erneut berechnet werden. Die Auswahl und das Verwerfen von sich als ungeeignet herausgestellten Referenzpunkten stellt eine Herausforderung dar.
Für die Berechnung der Abweichungen $ε_{n}$ wird keine hohe Genauigkeit benötigt, allerdings ist der Wertebereich von 64-bit-Gleitkommazahlen arg limitiert. Ab etwa 10³⁰⁰ muss man leider mit eigenen Mathematikroutinen arbeiten, die zwar nur eine 52/64 bit-Mantisse benötigen, aber deutlich langsamer als hartkodierte Gleitkomma-Operationen sind (die aber wesentlich schneller als Berechnungen mit langen Mantissen sind).^[20]^[21]
Man benötigt Speicherbandbreite für das Lesen der Referenzserie $z_{n} .$ Die erste Verlangsamung gibt es, wenn diese nicht mehr in den L2-Cache passt, sehr viel langsamer wird es, wenn der L3-Cache nicht mehr ausreicht und auf den RAM zugegriffen werden muss.
Es gibt Abweichungen zwischen der nativen Iteration mit $c^{'}$ und der Störungsrechnung basierend auf $c^{'} = c + δ .$ Sieht man sich das ganze genauer an, ist die Berechnung basierend auf $c^{'} = c + δ$ meistens genauer, wenn die Referenzpunktberechnung hinreichend genau war (was mit Langzahlarithmetik für diesen einen Wert aber problemlos machbar ist).

Berechnungsgeschwindigkeit

Berechnungen nahmen beim Stand der Technik Ende der 1980er Jahre viel Zeit in Anspruch. Vergleichsweise zeigt dies eine Aufstellung durch die Anzahl der Iterationen, die verschiedene CPUs pro Sekunde durchführen konnten.

CPU	Jahr	Genauigkeit (Software)	Geschwindigkeit in Iterationen/sec	Rechendauer für 8,8 Mrd. Iterationen
Z80 @1,75 MHz	1987	32 bit Gleitkomma (1.)	9	31 Jahre
Z80 @2,45 MHz	1987	32 bit Integer (2.)	280	01 Jahr
80386 SX/20 + IIT 3C87SX/20	1992	32 bit Integer (3.)	130.000	19 Stunden
		80 bit Gleitkomma (FPU) (3.)	75.000	33 Stunden
		80 bit Gleitkomma (Emulation Borland) (3.)	2.000	51 Tage
Pentium 90	1994	32 bit Integer (3.)	1.450.000	01 Stunde 40 Minuten
Pentium 90	1994	80 bit Gleitkomma (3.)	2.900.000	50 Minuten
Xeon E5-2623 v3 × 2 (Dual Socket)	2015	32 bit Gleitkomma (4.)	50.000.000.000	0,177 Sekunden
Xeon E5-2623 v3 × 2 (Dual Socket)	2015	64 bit Gleitkomma (4.)	25.000.000.000	0,35 Sekunden

Eingesetzte Software

BASIC-Interpreter des KC 85/3
Selbst geschriebener Assemblercode^[22]
Borland C++ mit integriertem Assembler, die Gleitkomma-Emulation dieses Compilers war vergleichsweise langsam^[23]
Visual Studio C++ mit Intel Intrinsics, Nutzung von AVX2 und Fused multiply-add, multithreaded, 2 Threads pro Core

Eingesetzte Prozessoren

Z80: 8-Bit-Prozessor ohne Hardware-Multiplikation
80386: 32-Bit-Prozessor mit Hardware-Multiplikation und Gleitkomma-Koprozessor
Pentium: 32-Bit-Prozessor mit Hardware-Multiplikation und mit eingebautem Gleitkomma-Koprozessor
Xeon E5-2623: Vektorbefehle, 4 Kerne/8 Threads pro Sockel

↑ Robert P. Munafo: Escape Radius. In: mrob.com. 1997; abgerufen am 1. November 2024 (englisch).
↑ Robert P. Munafo: Equipotential Lines. In: mrob.com. 2023; abgerufen am 11. März 2025 (englisch).
↑ Dieser Zusammenhang ergibt sich aus dem Maximumprinzip: Wenn jeder Randpunkt $| z_{n} | \leq 2$ erfüllt, dann müssen auch alle inneren Punkte $| z_{n} | \leq 2$ erfüllen.
↑ Inigo Quilez: Continuous iteration count. In: iquilezles.org. 2007; abgerufen am 11. März 2025 (englisch).
↑ Jussi Härkönen: On Smooth Fractal Coloring Techniques. (PDF; 14 MB) The Smooth Iteration Count Coloring. In: jussiharkonen.com. 2007, S. 14–26, archiviert vom Original (nicht mehr online verfügbar) am 18. Juni 2014; abgerufen am 11. März 2025 (englisch).
↑ Die Folge $z_{n + 1} = z_{n}^{2} + c$ wächst für $| z_{n} | \geq r ≫ 2$ wie eine einfache Folge ${z_{n^{'} + 1}}^{'} = {z_{n}}^{'}^{2} + 0$ mit $| {z_{0}}^{'} | = | z_{n} |^{1 / 2^{n}} .$ Der genaue Anfangswert ${z_{0}}^{'} = c^{'}$ verschwindet jedoch aus der Differenz $n - t$ und ist daher ohne Bedeutung.
↑ Arnaud Chéritat: Mandelbrot set. The potential. In: math.univ-toulouse.fr. 2016; abgerufen am 11. März 2025 (englisch).
↑ ^a ^b Kees van den Doel: Notes on Mandelbrot set (Draft). (PDF; 0,2 MB) Basics. In: persianney.com. 2018, S. 1–2; abgerufen am 11. März 2025 (englisch).
↑ Inigo Quilez: Computing the SDF of fractals. In: iquilezles.org. 2004; abgerufen am 11. März 2025 (englisch).
↑ Die Division durch $z_{n} (c)$ und $z_{n}^{'} (c)$ ist im Außenbereich $| z_{n} | > 2$ immer möglich, da alle Nullstellen von $z_{n}$ und $z_{n}^{'}$ im Innenbereich $| z_{n} | \leq 2$ liegen (vgl. die Sätze von Gauß-Lucas und Jensen).
↑ Mikael Hvidtfeldt Christensen: Distance Estimated 3D Fractals (V): The Mandelbulb & Different DE Approximations. The potential gradient approximation. In: blog.hvidtfeldts.net. 2011; abgerufen am 11. März 2025 (englisch).
↑ Yumei Dang, Louis Kauffman, Daniel Sandin: Hypercomplex Iterations, Distance Estimation and Higher Dimensional Fractals. (PDF; 4,1 MB) Distance Estimation in Complex Space. In: evl.uic.edu. 2002, S. 13–29; abgerufen am 11. März 2025 (englisch).
↑ Phil Thompson: Perturbation Theory and the Mandelbrot set. In: philthompson.me. 2022; abgerufen am 21. Juni 2025 (englisch).
↑ Robert P. Munafo: Perturbation Methods. In: mrob.com. 2023; abgerufen am 21. Juni 2025 (englisch).
↑ Robert P. Munafo: Derivative Extrapolation. In: mrob.com. 2023; abgerufen am 21. Juni 2025 (englisch).
↑ Liegt der Quotient $| ε_{n} | / | 2 z_{n} |$ unterhalb der Maschinengenauigkeit, dann ist der Rundungsfehler bei der Addition von $ε_{n}$ genauso groß wie der Fehler durch die Linearisierung.
↑ Diese Idee lässt sich auf die Ableitung $z_{n + 1}^{'} = 2 z_{n} z_{n}^{'} + 1$ mit ${z_{n^{'} + 1}}^{'} + {ε_{n^{'} + 1}}^{'} = 2 (z_{n} + ε_{n}) ({z_{n}}^{'} + {ε_{n}}^{'}) + 1$ übertragen. Für $| ε_{n} | ≪ | z_{n} |$ erhält man ${ε_{n^{'} + 1}}^{'} = 2 z_{n} {ε_{n}}^{'}$ und ${ε_{n^{'} + k}}^{'} = a_{n, k} {ε_{n}}^{'}$ (Programmbeispiel).
↑ Claude Heiland-Allen: Kalles Fraktaler 2 +. In: mathr.co.uk. 2022; abgerufen am 11. März 2025 (englisch).
↑ Robert P. Munafo: Bivariate Linear Approximation. In: mrob.com. 2023; abgerufen am 21. November 2025 (englisch).
↑ Geoffroy Billotey: Fractalshades: Extended range floating points. In: github.io. 2023; abgerufen am 21. Juni 2025 (englisch).
↑ Robert P. Munafo: Floatexp. In: mrob.com. 2023; abgerufen am 11. März 2025 (englisch).
↑ der allerdings noch nicht das theoretische Limit darstellte, die verwendet Multiplikation war schnell, es gibt aber noch schnellere, siehe Multiplication 32 x 32 bit, base case
↑ Compiler, die direkte Bibliotheksaufrufe erzeugten und bei Vorhandensein einer 32-bit-CPU 32-bit-Befehle nutzten, waren deutlich schneller. Keine Messwerte mehr verfügbar.

Referenzfehler: <ref>-Tags existieren für die Gruppe A, jedoch wurde kein dazugehöriges <references group="A" />-Tag gefunden.

[escrad-1] Robert P. Munafo: Escape Radius. In: mrob.com. 1997; abgerufen am 1. November 2024 (englisch).

[2] Robert P. Munafo: Equipotential Lines. In: mrob.com. 2023; abgerufen am 11. März 2025 (englisch).

[3] Dieser Zusammenhang ergibt sich aus dem Maximumprinzip: Wenn jeder Randpunkt $| z_{n} | \leq 2$ erfüllt, dann müssen auch alle inneren Punkte $| z_{n} | \leq 2$ erfüllen.

[4] Inigo Quilez: Continuous iteration count. In: iquilezles.org. 2007; abgerufen am 11. März 2025 (englisch).

[5] Jussi Härkönen: On Smooth Fractal Coloring Techniques. (PDF; 14 MB) The Smooth Iteration Count Coloring. In: jussiharkonen.com. 2007, S. 14–26, archiviert vom Original (nicht mehr online verfügbar) am 18. Juni 2014; abgerufen am 11. März 2025 (englisch).

[6] Die Folge $z_{n + 1} = z_{n}^{2} + c$ wächst für $| z_{n} | \geq r ≫ 2$ wie eine einfache Folge ${z_{n^{'} + 1}}^{'} = {z_{n}}^{'}^{2} + 0$ mit $| {z_{0}}^{'} | = | z_{n} |^{1 / 2^{n}} .$ Der genaue Anfangswert ${z_{0}}^{'} = c^{'}$ verschwindet jedoch aus der Differenz $n - t$ und ist daher ohne Bedeutung.

[7] Arnaud Chéritat: Mandelbrot set. The potential. In: math.univ-toulouse.fr. 2016; abgerufen am 11. März 2025 (englisch).

[tecnote-8] Kees van den Doel: Notes on Mandelbrot set (Draft). (PDF; 0,2 MB) Basics. In: persianney.com. 2018, S. 1–2; abgerufen am 11. März 2025 (englisch).

[9] Inigo Quilez: Computing the SDF of fractals. In: iquilezles.org. 2004; abgerufen am 11. März 2025 (englisch).

[10] Die Division durch $z_{n} (c)$ und $z_{n}^{'} (c)$ ist im Außenbereich $| z_{n} | > 2$ immer möglich, da alle Nullstellen von $z_{n}$ und $z_{n}^{'}$ im Innenbereich $| z_{n} | \leq 2$ liegen (vgl. die Sätze von Gauß-Lucas und Jensen).

[11] Mikael Hvidtfeldt Christensen: Distance Estimated 3D Fractals (V): The Mandelbulb & Different DE Approximations. The potential gradient approximation. In: blog.hvidtfeldts.net. 2011; abgerufen am 11. März 2025 (englisch).

[12] Yumei Dang, Louis Kauffman, Daniel Sandin: Hypercomplex Iterations, Distance Estimation and Higher Dimensional Fractals. (PDF; 4,1 MB) Distance Estimation in Complex Space. In: evl.uic.edu. 2002, S. 13–29; abgerufen am 11. März 2025 (englisch).

[14] Phil Thompson: Perturbation Theory and the Mandelbrot set. In: philthompson.me. 2022; abgerufen am 21. Juni 2025 (englisch).

[15] Robert P. Munafo: Perturbation Methods. In: mrob.com. 2023; abgerufen am 21. Juni 2025 (englisch).

[16] Robert P. Munafo: Derivative Extrapolation. In: mrob.com. 2023; abgerufen am 21. Juni 2025 (englisch).

[17] Liegt der Quotient $| ε_{n} | / | 2 z_{n} |$ unterhalb der Maschinengenauigkeit, dann ist der Rundungsfehler bei der Addition von $ε_{n}$ genauso groß wie der Fehler durch die Linearisierung.

[18] Diese Idee lässt sich auf die Ableitung $z_{n + 1}^{'} = 2 z_{n} z_{n}^{'} + 1$ mit ${z_{n^{'} + 1}}^{'} + {ε_{n^{'} + 1}}^{'} = 2 (z_{n} + ε_{n}) ({z_{n}}^{'} + {ε_{n}}^{'}) + 1$ übertragen. Für $| ε_{n} | ≪ | z_{n} |$ erhält man ${ε_{n^{'} + 1}}^{'} = 2 z_{n} {ε_{n}}^{'}$ und ${ε_{n^{'} + k}}^{'} = a_{n, k} {ε_{n}}^{'}$ (Programmbeispiel).

[19] Claude Heiland-Allen: Kalles Fraktaler 2 +. In: mathr.co.uk. 2022; abgerufen am 11. März 2025 (englisch).

[20] Robert P. Munafo: Bivariate Linear Approximation. In: mrob.com. 2023; abgerufen am 21. November 2025 (englisch).

[21] Geoffroy Billotey: Fractalshades: Extended range floating points. In: github.io. 2023; abgerufen am 21. Juni 2025 (englisch).

[22] Robert P. Munafo: Floatexp. In: mrob.com. 2023; abgerufen am 11. März 2025 (englisch).

[23] r allerdings noch nicht das theoretische Limit darstellte, die verwendet Multiplikation war schnell, es gibt aber noch schnellere, siehe Multiplication 32 x 32 bit, base case

[24] Compiler, die direkte Bibliotheksaufrufe erzeugten und bei Vorhandensein einer 32-bit-CPU 32-bit-Befehle nutzten, waren deutlich schneller. Keine Messwerte mehr verfügbar.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[A 1]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]