Das Apfelmännchen

Dieses Buch steht im Regal Programmierung.

Dieses Buch hat eine Druckversion.

Dieses Wikibook beschäftigt sich mit der softwaretechnischen Erstellung von fraktalen Mengen mit der Hilfe von strukturierten Java-Programmen, insbesondere mit der Berechnung von Julia-Mengen und der Mandelbrot-Menge. Letztere wird wegen der Ähnlichkeit ihrer geometrischen Form zu einer Figur aus verschieden großen Äpfeln auch Apfelmännchen genannt.

Julia-Mengen

Julia-Mengen sind nach dem französischen Mathematiker Gaston Maurice Julia (* 1893; † 1978) benannt, der diese 1917 fast gleichzeitig mit dem ebenfalls französischen Mathematiker Pierre Fatou (* 28. 1878; † 1929) beschrieben hatte.

Zoomfahrt in eine Julia-Menge in der komplexwertigen z-Ebene mit der komplexwertigen Polynomfunktion zweiten Grades

p(z)=z^{2}+c

und den Parametern
c_re = c_im = -0.5251993

Die Mandelbrot-Menge

1979 begann der französisch-US-amerikanische Mathematiker Benoît Mandelbrot (* 1924; † 2010) damit, an fraktalen Julia-Mengen weiterzuforschen. Mit Hilfe von Computern und Software konnte er bestimmte Eigenschaften von Julia-Mengen graphisch darstellen und entdeckte dabei die nach ihm benannte Mandelbrot-Menge.

Siehe auch Wikibook Komplexe Zahlen / Anwendung in der Mathematik / Mandelbrot-Menge

Komplexe Zahlen

Komplexe Zahlen bestehen aus einem reellen Anteil und einem imaginären Anteil, die beide durch eine reelle Zahl repräsentiert werden können, die orthogonal in einer Zahlenebene dargestellt werden können. Hierbei wird in der Regel der reelle Anteil auf der horizontalen Achse und der imaginäre Anteil auf der vertikalen Achse aufgetragen. Jede komplexe Zahl hat auf diese Weise einen bestimmten Ort in der komplexen Zahlenebene, die nach dem deutschen Mathematiker Carl Friedrich Gauß (* 1777; † 1857) auch Gaußsche Ebene genannt wird.

Die komplexe Zahl mit dem Zahlendupel (1|0) entspricht der reellen Einheitszahl $1$ , und die komplexe Zahl mit dem Zahlendupel (0|1) entspricht der imaginären Einheitszahl $i$ . Das Quadrat von $1$ hat den Wert $1$ , und das Quadrat von $i$ hat den Wert $-1$ :

1^{2}=1

i^{2}=-1

Eine beliebige komplexe Zahl $z$ kann zum Beispiel als Summe eines reellen Anteils $a=z_{re}$ und eines imaginären Anteils $b=z_{im}$ dargestellt werden, in dem die Zahl i mit dem imaginären Anteil multipliziert wird:

z=z_{re}+i\cdot z_{im}=a+i\cdot b

In einer Java-Klasse KomplexeZahl können diese beiden Attribute folgendermaßen programmiert werden:

public class KomplexeZahl 
{
	// Die beiden Instanzvariablen re und im sind die Datenfelder des Datentyps KomplexeZahl
	public double re; // Realteil der komplexen Zahl
	public double im; // Imaginaerteil der komplexen Zahl

	/*
	 * Konstruktor zum Initialisieren einer Instanz einer komplexen Zahl
	 * @param re: Realteil der komplexen Zahl
	 * @param im: Imaginaerteil der komplexen Zahl
	 */
	public KomplexeZahl (double re, double im)
	{
		this.re = re;
		this.im = im;
	}
}

Die Summe $z_{s}$ zweier komplexen Zahlen $z_{1}$ und $z_{2}$ kann berechnet werden, indem die beiden reellen und die beiden imaginären Anteile jeweils addiert werden:

In Bezug auf die komplexen Zahlen

z_{s}=z_{1}+z_{2}=a+i\cdot b+c+i\cdot d=(a+c)+i\cdot (b+d)

In Bezug auf die reellen Anteile der komplexen Zahlen:

z_{s,re}=z_{1,re}+z_{2,re}=a+c

In Bezug auf die imaginären Anteile der komplexen Zahlen:

z_{s,im}=z_{1,im}+z_{2,im}=b+d

In der Java-Methode addiereZu ist diese Rechenvorschrift implementiert:

	/*
	 * Addiert komplexerSummand zu komplexeZahl und speichert das Ergebnis in komplexeZahl
	 * @param komplexeZahl: komplexe Zahl, zu der addiert wird
	 * @param komplexerSummand: komplexe Zahl, die zu komplexeZahl addiert wird
	 */
	public static void addiereZu (KomplexeZahl komplexeZahl, KomplexeZahl komplexerSummand)
	{
		double reSumme = komplexeZahl.re + komplexerSummand.re;
		double imSumme = komplexeZahl.im + komplexerSummand.im;

		komplexeZahl.re = reSumme;
		komplexeZahl.im = imSumme;
	}

Das Quadrat $q$ einer komplexen Zahl $z$ kann mit der folgenden Vorschrift berechnet werden:

In Bezug auf die komplexen Zahlen:

q=z^{2}

In Bezug auf den reellen Anteil von $q$ :

q_{re}=z_{re}^{2}-z_{im}^{2}

In Bezug auf den imaginären Anteil von $q$ :

q_{im}=2\cdot z_{re}\cdot z_{im}

Die Java-Methode quadriere multipliziert eine komplexe Zahl mit sich selbst:

	/*
	 * Quadriert eine komplexe Zahl
	 * @param komplexeZahl: komplexe Zahl, die quadriert werden soll
	 */
	public static void quadriere (KomplexeZahl komplexeZahl)
	{
		double re2 = (komplexeZahl.re * komplexeZahl.re) - (komplexeZahl.im * komplexeZahl.im);
		double im2 = 2 * komplexeZahl.re * komplexeZahl.im;

		komplexeZahl.re = re2;
		komplexeZahl.im = im2;
	}

Das Betragsquadrat $b^{2}$ und der Betrag $b$ einer komplexen Zahl $z$ sind reellwertig (der Imaginäranteil ist also null), und diese können mit Hilfe des Satzes von Pythagoras berechnet werden:

b^{2}=|z|^{2}=z_{re}^{2}+z_{im}^{2}

b=|z|={\sqrt {z_{re}^{2}+z_{im}^{2}}}

Die folgende Methode betragsquadrat ermittelt das Betragsquadrat einer komplexen Zahl:

	/*
	 * Berechnet das Betragsquadrat einer komplexen Zahl
	 * @param komplexeZahl: komplexe Zahl, deren Betragsquadrat bestimmt werden soll
	 * @return: reelwertiges Betragsquadrat der komplexen Zahl
	 */
	public static double betragsquadrat (KomplexeZahl komplexeZahl)
	{
		double betragsquadrat = (komplexeZahl.re * komplexeZahl.re) + (komplexeZahl.im * komplexeZahl.im);
		return betragsquadrat;
	}

Mit dem folgenden Java-Programm in der Java-Klasse KomplexeZahl können die oben aufgeführten Rechenoperationen durchgeführt werden:

→ Java-Programm "KomplexeZahl"

Siehe auch:

Quadratische Polynome

Ein quadratisches Polynom $p_{c}$ kann wie folgt als Funktion $p_{c}(z)$ des Arguments $z$ dargestellt werden:

p_{c}(z)=z^{2}+c

Hierbei können das Argument $z$ und der Koeffizient $c$ auch komplexe Zahlen sein.

Bei einer Polynomfolge wird das nächste Glied mit dem Index $n+1$ nach der folgenden Vorschrift aus dem aktuellen Glied mit dem Index $n$ berechnet:

z_{n+1}=p_{c}(z_{n})

mit

0\leq n;n\in \mathbb {N} _{0}

Ein quadratische Polynomfolge $p_{c}$ kann demnach wie folgt dargestellt werden:

z_{n+1}=p_{c}(z_{n})=z_{n}^{2}+c

Dieser Algorithmus ist in der folgenden Java-Methode berechneNaechstesPolynomglied umgesetzt:

	/*
	 * Berechnung des nächsten Polynomglieds mit z(n+1) = z(n)^2 + c
	 * @param z: Variable z des Polynoms
	 * @param c: Variable c des Polynoms
	 */
	private static void berechneNaechstesPolynomglied (KomplexeZahl z, KomplexeZahl c)
	{
		KomplexeZahl.quadriere (z);
		KomplexeZahl.addiereZu (z, c);
	}

Bei den Julia-Mengen wird das Verhalten dieser Polynomfolge für alle Startwerte $z_{0}$ in der komplexen Zahlenebene dahingehend untersucht, ob der Betrag dieser Folge beschränkt bleibt oder gegen unendlich divergiert. Für jeden Koeffizienten $c$ ergibt sich eine andere Julia-Menge.

Bei der Mandelbrot-Menge wird das Verhalten dieser Polynomfolge für alle Koeffizienten $c$ in der komplexen Zahlenebene dahingehend untersucht, ob der Betrag dieser Folge mit dem Startwert $z_{0}=0$ beschränkt bleibt oder gegen unendlich divergiert.

In einem Computerprogramm kann diese Beschränktheit mit einer kopfgesteuerten Schleife abgeschätzt werden, die prüft, ob der Betrag der Polynomfolge nach einer vorgegebenen Anzahl von Schleifendurchläufen einen ebenfalls vorgegebenen reellen Betrag nicht überschritten hat. Hier ein Beispiel mit der Methode iterationszahlBisSchranke in der Programmiersprache Java, das für beliebige komplexwertige Zahlen $z$ und $c$ aufgerufen werden kann:

	/*
	 * Ermittelt die Iterationszahl bis zum Erreichen einer Schranke oder einer maximalen Iterationszahl
	 * @param z: Variable z des Polynoms
	 * @param c: Variable c des Polynoms
	 * @return: Iterationszahl bis zum Erreichen von schrankeZ2 oder 
	 *          maximaleAnzahlDerIterationen, wenn schrankeZ2 nicht ueberschritten wurde
	 */
	private static int iterationszahlBisSchranke (KomplexeZahl z, KomplexeZahl c)
	{
		// Konstanten
		final int maximaleAnzahlDerIterationen = 100; // Maximale Anzahl zur Ermittlung der Divergenz der Polynomfolge	
		final int schrankeZ2 = 4; // Schranke fuer das Betragsquadrat von z zur Ermittlung der Divergenz der Polynomfolge

		// Zaehlvariable
		int zaehler = 0;
		while ((zaehler < maximaleAnzahlDerIterationen) && (KomplexeZahl.betragsquadrat (z) < schrankeZ2))
		{
			berechneNaechstesPolynomglied (z, c);
			zaehler++;
		}
		return zaehler;
	}

Es hat sich als praktisch erwiesen, für die Schranke der Beträge von z den Wert 2 beziehungsweise für die Betragsquadrate von z den Wert 4 zu wählen. Dicht an der Grenze der zusammenhängenden Gebiete kann es zu Polynomfolgen kommen, die langsam divergieren, so dass durch eine Erhöhung der maximalen Anzahl der Iterationen unter Umständen eine höhere Genauigkeit bei der Berechnung und Darstellung erreicht werden kann. Dies verlängert dann allerdings die Laufzeit der Berechnungen entsprechend.

Mit dem folgenden Java-Programm mit der Klasse FraktaleMenge können die oben erwähnten Rechenoperationen durchgeführt werden:

→ Java-Programm "FraktaleMenge"

Ausgabe

Es wäre schade, wenn die Ergebnisse der oben aufgeführten Algorithmen nicht sichtbar gemacht werden können. Hierzu dient die unten in diesem Abschnitt abrufbare Java-Klasse FraktaleMengeAusgabe, die die Eigenschaften der Java-Klasse JFrame aus dem Java-Paket swing des Java-Moduls javax erbt. Dadurch wird aus der Oberklasse Window aus dem Java-Paket awt (Abkürzung für "abstract window toolkit") auch die öffentliche, typengebundene Methode paint geerbt, mit der die graphische Ausgabe erfolgt:

java.awt.Component
- java.awt.Container
  - java.awt.Window
    - java.awt.Frame
      - javax.swing.JFrame
        FraktaleMengeAusgabe

Mit Hilfe der Java-Klasse BufferedImage aus dem Java-Paket awt kann die Graphik auch gespeichert werden. Hierzu wird mit der Java-Klasse Iterator aus dem Java-Paket util wird die Bilddateiart PNG ausgewählt. Mit einigen Klassen aus dem Java-Paket javax.imageio wird dann das Speichern der unkomprimierten Bilddatei bewerkstelligt.

Mit dem Konstruktor FraktaleMengeAusgabe muss eine neu erzeugte Instanz der Klasse initialisiert werden:

	/* Konstruktor fuer die Initialisierung von Instanzen der Klasse FraktaleMengeAusgabe.
	 * @param c: Komplexwertiger Koeffizient der quadratischen Polynome
	 * @param minX: Kleinster x-Wert der rechteckigen Darstellung der fraktalen Menge
	 * @param maxX: Groesster x-Wert der rechteckigen Darstellung der fraktalen Menge
	 * @param minY: Kleinster y-Wert der rechteckigen Darstellung der fraktalen Menge
	 * @param maxY: Groesster y-Wert der rechteckigen Darstellung der fraktalen Menge
	 * @param bildhoehe: Die Anzahl der Bildpunkte in der Bildhoehe
	 * @param shiftFactor: Anteil des verschobenen oder gezoomten Bildausschnitts
	 */
	public FraktaleMengeAusgabe (KomplexeZahl c,
			double minX, double maxX, double minY, double maxY, int bildhoehe,
			double shiftFactor)

Die folgenden öffentlichen, klassengebundenen Methoden stehen zur Laufzeit zur Verfügung:

Modifikator	Methode	Beschreibung
void	center ()	Zentriert die Menge auf den Ursprung (0, 0)
KomplexeZahl	getComplexParameter ()	Gibt den komplexwertigen Parameter der fraktalen Menge zurück
int	getKeyCode ()	Gibt den Code der gedrückten Taste zurück (siehe java.awt.event.KeyEvent @Field Summary / Fields)
double	getMaxX ()	Gibt den maximalen reellen Wert der Menge zurück
double	getMaxY ()	Gibt den maximalen imaginären Wert der Menge zurück
double	getMinX ()	Gibt den minimalen reellen Wert der Menge zurück
double	getMinY ()	Gibt den minimalen imaginären Wert der Menge zurück
double	getShiftFactor ()	Gibt den aktuellen Verschiebungs- und Zoomfaktor in Anteilen des Bildausschnitts zurück
void	init ()	Initialisiert die Menge
void	repaint ()	Erneuert die Darstellung der Menge
void	saveFile ()	Speichert die Menge in einer PNG-Datei
void	setBorders (double minX, double maxX, double minY, double maxY)	Setzt die minimalen und maximalen reelen (X) und imaginären (Y) Koordinaten
void	setComplexParameter (KomplexeZahl c)	Setzt den komplexwertigen Parameter der fraktalen Menge
void	setShiftFactor (double shiftFactor)	Setzt den Verschiebungs- und Zoomfaktor in Anteilen des Bildausschnitts festlegen; der Faktor muss größer als 0 und kleiner als 1 sein
void	shiftDown ()	Ausschnitt wird nach unten verschoben
void	shiftLeft ()	Ausschnitt wird nach links verschoben
void	shiftRight( )	Ausschnitt wird nach rechts verschoben
void	shiftUp ()	Ausschnitt wird nach oben verschoben
void	zoomIn ()	In den Ausschnitt hineinzoomen
void	zoomOut ()	Aus dem Ausschnitt herauszoomen

Mit dem folgenden Java-Programm mit der Klasse FraktaleMengeAusgabe können die fraktalen Mengen angezeigt oder als graphische PNG-Datei gespeichert werden:

→ Java-Programm "FraktaleMengeAusgabe"

Aufruf des Programms

Die parameterlose, öffentliche Methode init () muss aufgerufen werden, um die entsprechende fraktale Menge zu berechnen und gegebenenfalls darzustellen oder zu speichern.

Mit dem folgenden Java-Code kann beispielsweise eine Julia-Menge mit dem Koeffizienten c = (-0.5142|0.5142) berechnet und graphisch ausgegeben werden:

	// Für Julia-Mengen ist der komplexwertige Parameter c auf einen für die Julia-Menge spezifischen Wert ungleich (0, 0) zu setzen.
	final KomplexeZahl c = new KomplexeZahl (-0.5142, 0.5142); // Julia-Menge
	double minRe = -2.2;
	double maxRe = 2.2;
	double minIm = -2.2;
	double maxIm = 2.2;
	double shiftFactor = 0.1;
	int bildhoehe = 1024;
	FraktaleMengeAusgabe fraktaleMengeAusgabe = new FraktaleMengeAusgabe (c, minRe, maxRe, minIm, maxIm, bildhoehe, shiftFactor);
	fraktaleMengeAusgabe.init ();

Mit dem folgenden Java-Code kann die Mandelbrot-Menge berechnet und graphisch ausgegeben werden:

	// Für die Mandelbrot-Menge ist der komplexwertige Parameter c auf (0, 0) zu setzen.
	final KomplexeZahl c = new KomplexeZahl (0, 0); // Mandelbrot-Menge
	double minRe = -2.2;
	double maxRe = 2.2;
	double minIm = -2.2;
	double maxIm = 2.2;
	double shiftFactor = 0.1;
	int bildhoehe = 1024;
	FraktaleMengeAusgabe fraktaleMengeAusgabe = new FraktaleMengeAusgabe (c, minRe, maxRe, minIm, maxIm, bildhoehe, shiftFactor);
	fraktaleMengeAusgabe.init ();

Mit dem Aufruf der klassengebundenen Methode safeFile () kann beispielsweise der aktuelle Ausschnitt der im Objekt fraktaleMengeAusgabe der Klasse FraktaleMengeAusgabe gespeicherten Menge als PNG-Datei gespeichert werden:

		fraktaleMengeAusgabe.saveFile ();

Mit der beispielhaften Methode centerAt0Key (FraktaleMengeAusgabe fraktaleMengeAusgabe) kann die Darstellung der Instanz fraktaleMengeAusgabe der Klasse FraktaleMengeAusgabe modifiziert werden. Das folgende Code-Beispiel bringt den Ursprungspunkt (0, 0) der Menge in die Mitte der graphischen Darstellung, wenn die Taste "0" (entweder auf der Haupttastatur (java.awt.event.KeyEvent.VK_0) oder auf dem Nummernblock (java.awt.event.KeyEvent.VK_NUMPAD0)) niedergedrückt ist:

	private static void centerAt0Key (FraktaleMengeAusgabe fraktaleMengeAusgabe)
	{
		int keyCode = fraktaleMengeAusgabe.getKeyCode ();
		if ((keyCode == java.awt.event.KeyEvent.VK_0) || (keyCode == java.awt.event.KeyEvent.VK_NUMPAD0))
		{
			fraktaleMengeAusgabe.center ();
		}
		fraktaleMengeAusgabe.repaint ();
	}

Nachwort

Die hier angegebenen strukturierten Programmbeispiele können ohne große Umstände in jede andere strukturierte Programmiersprache übertragen werden. Durch die Modifikation und Ergänzung der angegebenen Algorithmen können sicherlich auch leicht ähnlich geartete Programmieraufgaben gelöst werden. Es wäre erfreulich, wenn dieses Wikibook zu einem besseren und tieferen Verständnis der strukturierten Programmierung und als Einstieg in die Mathematik fraktaler Mengen beitragen kann.

Widmung

Diese Zusammenstellung ist dem deutschen Mathematiker und Physiker Reinhart Behr (* 1928; † 2003) gewidmet. Der Hauptautor dankt ihm für seine Offenheit und Ansprechbarkeit als Gymnasiallehrer der Beethoven-Oberschule in Berlin-Lankwitz und für seine immerwährende Bereitschaft zur Förderung und Bildung seiner Schüler. Er konnte mit seinem beeindruckenden und breitgefächerten Wissen sowie mit der ihm eigenen und hervorragenden Didaktik auch anspruchsvolle Fragen meist aus dem Stand und umfassend beantworten.

Literatur

Heinz-Otto Peitgen und Dietmar Saupe: The Science of Fractal Images, Springer, Heidelberg, 1988, ISBN 0-387-96608-0.
Reinhart Behr: Der Weg zur fraktalen Geometrie, Ernst Klett Schulbuchverlag, Stuttgart, 1989, ISBN 3-12-722410-9

Siehe auch

Zusammenfassung des Projekts

„Das Apfelmännchen“ ist nach Einschätzung seiner Autoren zu 100 % fertig

Zielgruppe: Informatiker, Mathematiker
Lernziele: Erstellung fraktaler Julia-Mengen und der Mandelbrot-Menge mit einem Java-Programm.
Buchpatenschaft/Ansprechperson: Benutzer:Bautsch
Sind Co-Autoren gegenwärtig erwünscht? Ja, sehr gerne. Korrekturen von offensichtlichen Fehlern direkt im Text; Inhaltliches bitte per Diskussion.
Richtlinien für Co-Autoren: Wikimedia-like.