# Mit Hilfe von komplexen Zahlen "Juliamenge + Apfelmenge" bilden



## hanno88 (1. Jul 2009)

Hi, also ich brauch mal eure Hilfe. Ich steig bei soviel Mathematik nich mehr durch.

Also das is meine Klasse mit den komplexen Zahlen, wie wir Sie machen sollten.


```
public class KomplexeZahl
{
	// Speichert den Realteil
	public double   x;
	// Speichert den Imaginärteil
	public double   y;

	/**
	 * Konstruktor
	 * @param r
	 * @param s
	 */
	public KomplexeZahl(double r, double s)
	{
		x = r;
		y = s;
	}

	/**
	 * Private Methode zur Addition von zwei komplexen Zahlen. 
	 *
	 * @param c
	 * @return
	 */
	public KomplexeZahl summe(KomplexeZahl c)
	{
		return new KomplexeZahl(x + c.x, y + c.y);
	}

	/**
	 * Private Methode zur Multiplikation von zwei komplexen Zahlen.
	 *
	 * @param c
	 * @return KomplexeZahl
	 */
	private KomplexeZahl produkt(KomplexeZahl c)
	{
		return new KomplexeZahl(x*c.x - y*c.y, x*c.y + y*c.x);
	}

	/**
	 *
	 * @return Betragsquadrat |Zn^2|
	 */
	public double betragsquadrat() {
		return x*x + y*y;
	}

	/**
	 * Methode zum Ausfuehren des Betragsquadrats bis n.
	 * Also |Zn|^2.
	 *
	 * KomplexeZahl z = new KomplexeZahl(0,0); KomplexeZahl c = new
	 * KomplexeZahl(cX,cY); double z100 = z.betragsQuadratZn(100, c);
	 *
	 * @param n
	 *            vom Typ int
	 * @return
	 */
	public double betragsQuadratZn(int n, KomplexeZahl c)
	{
		double aus = 0;
		int i = 0;
		while (i < n)
		{

			// Plynomfolge zn = z0^2+c
			produkt(new KomplexeZahl(x, y));
			summe(c);
			i++;
		}
		// Betragsquadrat
		aus = betragsquadrat();
		return aus;
	}

	/**
	 *
	 * @param z
	 *            double : Schranke
	 * @param n
	 *            int : Anzahl der maximalen Iterationen
	 * @param c
	 *            KomplexeZahl fuer das naechste Polynomglied
	 *
	 * @return Ganzzahlige Ausgabe der benoetigten Iterationen um ein einen Wert
	 *         groesser gleich Schranke z zu
	 *
	 *
	 */
	public int iterationszahlBisSchrankeZ(double schrankeZ, int n,
			KomplexeZahl c)
	{
		int i = 0;
		double betragsquadrat = 0; //Anzahl der Iterationen
		KomplexeZahl calc = new KomplexeZahl(0, 0); // (0,0), weil Z0 -Mandelbrot bei (0,0)

		//Solange das Betragsquadrat(i) kleiner z und
		while (betragsquadrat <= schrankeZ && i < n)
		{
			calc = produkt(this).summe(c);
			x = calc.x;
			y = calc.y;

			betragsquadrat = c.betragsquadrat();

			i++;
		}

		// Mehr Iterationen als n um z zu erreichen wurden benoetigt.
		if (i == n)
		{
			i = n + 1;
		}

		return i;
	}

}
```


Nun sollen wir unter Verwendung der oberen Klasse, der Klassen "java.awt.Button, java.awt.TextField und einer entsprechenden Wrapper-Klasse 2 kurze Apletts der Juliamenge und Mandelbrotmenge programmieren.

Das klingt ja alles noch einigermaßen ok :lol:

Aber jetzt kommt das was ich nicht verstehe....

Alle Benutzereingaben werden in einer eigenen Klasse zusammengefasst.
     · Die Hintergrundfarbe ist einzugeben (byte rH, gH, bH).
     · Die Startwerte -2 <= sx <= 2 und -2 <= sy <= 2 sowie 
       die Endwerte -2 <= ex <= 2 und -2 <= ey <= 2 der graphischen Darstellung sind  vom Benutzer einzugeben (double).
     · Der Skalierungsfaktor der Darstellung 100 <= f <= 1000 ist vom Benutzer einzugeben.

Die Vordergrundfarbe wird auf schwarz festgelegt (rV = 0, gV = 0, bV = 0).
Die Anzahl der maximalen Iterationen n für einen Punkt wird auf 100 festgelegt.
Die Schranke z wird auf 4 festgelegt.
Für die Koordinatenpaare (x | y) gilt dann sx <= x <= ex und sy <= y <= ey. Diese müssen in die entsprechenden, fortlaufenden Pixel-Koordinaten des graphischen Rechtecks umgerechnet werden (zweidimensionale Koordinatentransformation).

Julia-Menge:
· Die Konstanten -2 <= cx <= 2 und -2 <= cy <= 2 sind vom Benutzer zusätzlich einzugeben (double).
· Der Hintergrund der Graphik wird mit der Hintergrundfarbe gefüllt.
· z0 wird immer auf (x | y) gesetzt.
· Alle Punkte im Rechteck für die |zN|² < z gilt (also betragsquadratZn (n) < z), werden in der Vordergrundfarbe gezeichnet.

Mandelbrot-Menge:
· cx = x und cy = y.
· z0 wird immer auf (0 | 0) gesetzt.
· Wenn die Iterationszahl n+1 beträgt (also iterationszahlBisSchrankeZ (z, n) = (n+1)),
werden die entsprechenden Punkte in der Vordergrundfarbe gezeichnet. Andernfalls wird
eine geeignete Farbe in Abhängigkeit von der zurückgegebenen Iterationszahl, die dann
zwischen 1 und n liegt, und der eingegebenen Hintergrundfarbe bestimmt.

Alle Eingaben sind vor der Weiterverarbeitung zu validieren !

Also das ist die grobe Beschreibung der folgenden Aufgabe zu 1

Ihr sollt mir da jetzt nicht die Aufgabe lösen, aber ich wäre schon dankbar für ein paar codeansätze, was ich da machen soll. Mein Anti-Mathe Hirn streikt da. Saß da die letzten 2 nächte dran aber ich raffs nich :noe:


DANKE!


----------



## Landei (1. Jul 2009)

Keine Panik! Mach doch erst mal den Teil mit den allgemeinen Nutzereingaben. Eine eigene Klasse deshalb, damit diese von _beiden_ Applets verwendet werden kann. Lass erst mal alles, was "Berechnung" heißt, weg und mach nur Eingabe der Werte und Validierung. Dann sehen wir weiter.


----------



## Marco13 (1. Jul 2009)

Du müßtest ggf. etwas präziser werden. Im Moment klingt das, als hätte das mit Mathe nicht so viel zu tun - sondern als sollten einfach ein paar GUI-Komponenten zusammengebastelt werden...


----------



## hanno88 (1. Jul 2009)

Marco du kannst dir ja mal die gesamte aufgabe ansehen, vllt. verstehst du dann besser. (SIEHE ANHANG!)

Das mit der Eingabe ist ne gute Anfangslösung. Nur danach wirds schwer


----------



## Marco13 (2. Jul 2009)

Was da mit Mathe zu tun hat, hast du ja schon. Im wesentlichen fehlt jetzt noch der Eingabekram und das Zeichnen.


----------



## hanno88 (2. Jul 2009)

genau :/
aber ich weiß nich so recht wie ich die EIngabe auf die zu programmierenden klassen julia und Mandelbrot aufbauen soll.

die eingabe in der seperaten klasse sollte machbar sein, aber ich sehe ein problem für mich persönlich die eingabefelder für die juliamende in das aplett mit einzuarbeiten.


----------



## Marco13 (2. Jul 2009)

Das ist immernoch so schwammig. Hast du schonmal ein TextField in einem Applet dargestellt? Und einen Button? Und einen ActionListener an den Button gehängt? Eigentlich würde ich dich ggf. auf ein Tutorial verweisen, aber AWT ist eigentlich veraltet - man sollte eher Swing verwenden (also nicht java.awt.Button sondern javax.swing.JButton - frag' deinen Lehrer am besten mal, ob ihr das dürft - vielleicht ist er ja sogar total begeistert davon  ).


----------



## hanno88 (2. Jul 2009)

also wir haben mal 2 Würfel programmiert mit einem button zum würfeln. Von javax.swing.Jbutton hab ich noch nichts gehört, ich kann ihn ja mal fragen.

Wie würdest du denn weitermachen jetzt? also man findet ja unzählige juliamengen und mandelbrotmengen im inet, aber ich kann da nichts in Verbindung mit meiner 1. Aufgabe anfangen, was wir ja nun sollen.

Ich kann nichts mit den Werten anfangen (z.B. diese -2 bis 2) oder was da gemeint is. Das geht aber vielen von uns so, hab ich gehört. Der Dozent isn Physiker und steht auf Zahlen und Formeln. Das is das problem ^^


----------



## Marco13 (2. Jul 2009)

Nun, die Mandelbrotmenge ist ja ganz grob die Menge der komplexen Zahlen, für die eine bestimmte Bedingung gilt (nämlich dass bei dieser Iteration nie ein Betrag > 2 rauskommt oder so).

Das, was dann auf dem Bildschirm erscheinen soll, ist ja (beim Mandelbrot) schlicht und einfach die "Ebene" der Komplexen Zahlen - und die Pixel, die in der Mandelbrotmenge liegen, sind eingefärbt. 

Man sieht auf dem Bildschirm also eine Menge von Pixeln, und jeder Pixel entspricht einer komplexen Zahl. WELCHER komplexen Zahl ein Pixel entspricht, hängt davon ab, welchen _Ausschnitt_ aus der Zahlenebene man ansieht. Angenommen man hat 4x4 Pixel. Dann hat man so einen quadratischen Ausschnitt

```
----
|A   |
|    |
|    |
|   B|
 ----
```
Der Ausschnitt, den man sieht, ist definiert durch die Position von Pixel A und B. Wenn man z.B. 
sx = -2
sy = 1
ex = 2;
ey = -1
wählt, dann liegt der Pixel A an der Position (-2,1), der Pixel B bei (2,-1), und die anderen Pixel ensprechend eingeteilt dazwischen.

Und genau die Positionen des linken oberen und rechten unteren Pixels soll man eingeben können. In TextFields. Das könnte dann grob so in die Richtung gehen wie

```
class EingabePanel extends Panel implements ActionListener
{
    private TextField sxTextField = new TextField();
    private TextField syTextField = new TextField();
    private TextField exTextField = new TextField();
    private TextField eyTextField = new TextField();

    private Button okButton = new Button("OK");
    
    public EingabePanel()
    {
        setLayout(...);
        add(sxTextField);
        ... usw.

        okButton.addActionListener(this);
        add(okButton);
    }

    public void actionPerformed(ActionEvent e)
    {
        String sxString = sxTextField.getText();
        float sxValue = 0;
        try
        {
            sxValue = Float.parseFloat(sxString);
        }
        catch (NumberFormatException e)
        {
            // Fehlerdialog oder so - Eingabe für sx war keine Zahl
        }
        if (sxValue < -2) 
        {
            // Fehlerdialog oder so - Eingabe für sx war zu klein...
        }



        // Wenn alles passt:
        fraktalBerechner.setArea(sxValue, syValue, exValue, eyValue); // oder so...

    }
}
```


EDIT: Das "-2" in der letzten if-Abfrage war eben genau das aus der Aufgabenstellung:
_Die Startwerte -2 <= sx <= 2 _....


----------



## hanno88 (3. Jul 2009)

danke dir, dann versuch ich das morgen, bzw. heute mal in der Übung einzubauen. Hab auf jedenfall jetzt verstanden was er will.


----------

