Das Apfelmännchen

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Books Flat Icon Vector.svg

Dieses Buch steht im Regal Programmierung.

Bildschirmaufnahme des Java-Programms FraktaleMengeAusgabe zur Berechnung von Julia-Mengen. Siehe auch Wikibook Das Apfelmännchen.

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[Bearbeiten]

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.

Beispiel einer Julia-Menge mit dem Parameter c = (-0,5142|0,5142).

Die Mandelbrot-Menge[Bearbeiten]

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.

Die Mandelbrot-Menge in der Darstellung als Apfelmännchen, bei der die negative reelle Achse der Zahlenebene nach oben zeigt.

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

Komplexe Zahlen[Bearbeiten]

Komplexen Zahlenebene mit einer komplexen Zahl in kartesischen Koordinaten (a|b) und als Alternative auch in Polarkoordinaten (r|φ), wobei für den Abstand zum Ursprung (0|0) und für den entgegen dem Uhrzeigersinn gemessenen Winkel zur positiven reellen Achse stehen.

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 , und die komplexe Zahl mit dem Zahlendupel (0|1) entspricht der imaginären Einheitszahl . Das Quadrat von hat den Wert , und das Quadrat von hat den Wert :

Eine beliebige komplexe Zahl kann zum Beispiel als Summe eines reellen Anteils und eines imaginären Anteils dargestellt werden, in dem die Zahl i mit dem imaginären Anteil multipliziert wird:

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;
	}
}
Darstellung der Addition zweier komplexer Zahlen und in der komplexen Zahlenebene.

Die Summe zweier komplexen Zahlen und kann berechnet werden, indem die beiden reellen und die beiden imaginären Anteile jeweils addiert werden:

In Bezug auf die komplexen Zahlen

In Bezug auf die reellen Anteile der komplexen Zahlen:

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

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 einer komplexen Zahl kann mit der folgenden Vorschrift berechnet werden:

In Bezug auf die komplexen Zahlen:

In Bezug auf den reellen Anteil von :

In Bezug auf den imaginären Anteil von :

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 und der Betrag einer komplexen Zahl sind reellwertig (der Imaginäranteil ist also null), und diese können mit Hilfe des Satzes von Pythagoras berechnet werden:

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[Bearbeiten]

Ein quadratisches Polynom kann wie folgt als Funktion des Arguments dargestellt werden:

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

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

mit

Ein quadratische Polynomfolge kann demnach wie folgt dargestellt werden:

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 in der komplexen Zahlenebene dahingehend untersucht, ob der Betrag dieser Folge beschränkt bleibt oder gegen unendlich divergiert. Für jeden Koeffizienten ergibt sich eine andere Julia-Menge.

Bei der Mandelbrot-Menge wird das Verhalten dieser Polynomfolge für alle Koeffizienten in der komplexen Zahlenebene dahingehend untersucht, ob der Betrag dieser Folge mit dem Startwert 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 und 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[Bearbeiten]

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 Methode paint geerbt, mit der die graphische Ausgabe erfolgt.

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 imageio wird dann das Speichern der unkomprimierten Bilddatei bewerkstelligt.

Mit den folgenden vier Konstanten der Klasse kann beim Aufruf des Konstruktors festgelegt werden, ob die berechneten fraktalen Mengen angezeigt oder gespeichert werden sollen:

	// Klassenkonstanten
	final public static boolean DontDisplay = false;
	final public static boolean Display = true;
	final public static boolean DontSave = false;
	final public static boolean Save = true;

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 pixelProEinheit: Die Anzahl der Bildpunkte pro Längeneinheit
	 * @param display: Für die Konstanten DontDisplay oder Display
	 * @param save: Für die Konstanten DontSave oder Save
	 */
	public FraktaleMengeAusgabe (KomplexeZahl c,
			double minX, double maxX, double minY, double maxY, long pixelProEinheit,
			boolean display, boolean save)

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"

Mit dem folgenden Java-Code kann beispielsweise eine Julia-Menge mit dem Koeffizienten c = (-0.5142|0.5142) berechnet, graphisch ausgegeben und gespeichert werden. Die parameterlose, öffentliche Methode init () muss aufgerufen werden, um die entsprechende fraktale Menge zu berechnen und gegebenenfalls darzustellen oder zu speichern.

	// Für Julia-Mengen ist der komplexwertige Parameter c konstant und ungleich (0, 0).
	// Für die Mandelbrot-Menge ist der komplexwertige Parameter c auf (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;
	long pixelProEinheit = 300;
	FraktaleMengeAusgabe fraktaleMengeAusgabe =
		new FraktaleMengeAusgabe (c, minRe, maxRe, minIm, maxIm, pixelProEinheit, FraktaleMengeAusgabe.Display, FraktaleMengeAusgabe.Save);
	fraktaleMengeAusgabe.init ();

Nachwort[Bearbeiten]

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[Bearbeiten]

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.

Siehe auch[Bearbeiten]

Literatur[Bearbeiten]

  • 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

Zusammenfassung des Projekts[Bearbeiten]

100% fertig „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.