Newton-Fraktal erstellen < Java < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Aufgabe | | In einem Grafikprogramm (mit Java geschrieben) zu einem Polynom (mit der vorerst maximalen x-Potenz 6) ein Newton-Fraktal erstellen. |
Hallo Leute, ich wende mich mit einer heiklen Sache an euch:
Ich arbeite an einem hübschen Grafikprogramm, das unter anderem das Newton-Fraktal erstellen können soll.
Dazu gehört natürlich erst einmal die Interpretation einer Eingabe (String) als Funktion. Das an sich soll nicht zu komplex erarbeitet sein, sondern Polynome mit folgenden Regeln erkennen:
- Es ist ein nicht zwingend natürlicher Faktor vor jedem x möglich ( mit und ohne *) - Also z.B. "-3.5", "7", "101.379", "-3" o.ä.
- Nach dem x kommt direkt das Hochzeichen und eine natürliche Zahl als Potenz
-> Sie soll aber maximal 6 sein, damit ich maximal 6 Nullstellen und damit 6 unterschiedliche Farben brauche.
- Keine Klammern (Es können nur - + * interpretiert werden)
- Potenzen können zweimal auftauchen (werden dann einfach addiert)
Das habe ich schon soweit und das Ableiten ist dann auch keine große Hürde mehr.
Darauf folgt dann, nachdem ich die Funktion und deren Ableitung habe, die Erstellung des Fraktals.
Hier stoße ich auf meine erste Frage:
Wie genau funktioniert das? Das Newtonverfahren ist mir bekannt und ich kann auch schon per while-Schleife von einem beliebigen x-Wert zu einer Nullstelle der Funktion finden.
Doch welche Werte muss ich hier, abhängig von den Pixelkoordinaten als Startwert einsetzen?
Im Moment nehme ich einfach die Breite mal die Höhe des Bildes, fange dann beim Pixel[0;0] im Minus-Bereich an und inkrementiere jedesmal, wenn ich zum nächsten Pixel gehe.
(In der Mitte des Bildes ist mein Startwert logischerweise dann 0)
Abhängig von der Nullstelle und der benötigten Schritte, um zur Nullstelle zu gelangen erstelle ich eine Farbe.
-> Jede Nullstelle gibt eine andere Farbe
-> Umso mehr Schritte nötig, um dunkler wird die Farbe
Wenn ich mir dann (nach 10 Sekunden Berechnung für das Fraktal von [mm] "x^3 [/mm] - x") das Bild ausgeben lasse, entsteht ein Farbverlauf von oben nach unten. Oben ist es hell, gegen Mitte wird es dunkler und ab der Mitte nach unten hin wechselt es die Farbe und wird wieder heller.
Den Quellcode poste ich jetzt lieber nicht, um noch mehr zu verwirren. Wenn das aber jemand will, mach ich das :)
Wenn das ganze ein bisschen verwirrend klingt, bitte nicht einfach den Thread wegklicken, denn diese Funktion ist mir sehr wichtig. Also fragt bei mir nochmal nach im Falle von Unverständlichem :P
Gruß, Thomas
PS: Ich habe iwo gelesen, dass die Startwerte teilweise im Bereich der komplexen Zahlen liegen (?)
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 09:33 Mo 11.06.2012 | | Autor: | felixf |
Moin!
Ich glaube dein Hauptproblem ist das Fraktal selber: du scheinst nicht genau zu wissen, wie das Fraktal definiert ist.
Die Darstellung des Fraktals mit Farben ist der zweite Schritt, der erste Schritt ist dass du weisst wie das Fraktal entsteht.
Das Fraktal ist eine Teilmenge der komplexen Zahlen. Auf dem Bildschirm sieht man normalerweise einen rechteckigen Aussschnitt der komplexen Zahlenebene. Ohne komplexe Zahlen wirst du hier also nicht viel machen koennen.
> Darauf folgt dann, nachdem ich die Funktion und deren
> Ableitung habe, die Erstellung des Fraktals.
> Hier stoße ich auf meine erste Frage:
>
> Wie genau funktioniert das? Das Newtonverfahren ist mir
> bekannt und ich kann auch schon per while-Schleife von
> einem beliebigen x-Wert zu einer Nullstelle der Funktion
> finden.
Du arbeitest hier offenbar auf dem reellen Zahlenstrahl. Du wirst jedoch in der komplexen Ebene arbeiten muessen. Dort funktioniert das Newton-Verfahren genauso, nur das du hier mit komplexen Zahlen rechnen musst.
> Doch welche Werte muss ich hier, abhängig von den
> Pixelkoordinaten als Startwert einsetzen?
Sagen wir mal, die $x$-Koordinate geht von [mm] $x_{min}$ [/mm] bis [mm] $x_{max}$, [/mm] und die $y$-Koordinate von [mm] $y_{min}$ [/mm] bis [mm] $y_{max}$.
[/mm]
Der Punkt $(x, y)$ soll jetzt einer komplexen Zahlen $z [mm] \in \IC$ [/mm] entsprechen. Wenn auf dem Bildschirm etwa der Ausschnitt der komplexen Zahlen $z$ mit [mm] $\Re [/mm] z [mm] \in [/mm] [-1, 1]$ und [mm] $\Im [/mm] z [mm] \in [/mm] [-1, 1]$ dargestellt werden soll, muss also $z = [mm] (\frac{x - x_{min}}{x_{max} - x_{min} + 1} \cdot [/mm] 2 + -1) + [mm] (\frac{y - y_{min}}{y_{max} - y_{min} + 1} \cdot [/mm] 2 + -1) [mm] \cdot [/mm] i$ sein.
Das ist der Startwert fuer das Newton-Verfahren an dem Pixel $(x, y)$.
Du startest das Verfahren einmal von diesem Punkt aus, und dann von einem sehr wenig modifizierten (etwa der Startwert, der zum Pixel $(x + 0.001, y)$ gehoeren wuerde). Du schaust, wie aehnlich/verschieden sich die beiden Folgen entwickeln.
Sind sie nach sagen wir 50 Iterationen immer noch nah beieinander, liegt der Punkt nicht in der Newton-Menge. Wenn sie weit auseinander sind, gehoert der Punkt zur Newton-Menge.
Damit bekommst du eine Schwarz/Weiss-Faerbung des Bildschirms: die eine Farbe (die den Grossteil des Bildschirms einnimmt) kennzeichnet den Rest, und die andere Farbe die Newton-Menge. Das ist das eigentliche Newton-Frakal.
Das Einfaerben des Fraktals, so dass eins der bekannten schoenen Bilder herauskommt, ist dann eine andere Aufgabe.
LG Felix
|
|
|
| |
|
Wenn ich mit Zahlen aus dem komplexen Zahlenbereich rechne, dann ist das doch in der Regel sqrt(-i). Sonst wüsste ich gerade keine andere Zahl.
Problem ist dann doch, wie das Programm damit rechnen kann, oder? Wenn der plötzlich in der Rechnung sowas wie Wurzel aus negativen Zahlen stehen hat, wirft der doch sofort ne Exception.
Und zweitens dauert die Berechnung wohl auch Jahrhunderte, oder?
Wenn ich 400x500 verschiedene Pixel habe und dann auch noch im Tausendstel-Bereiche unterscheiden muss, muss er erstens evtl. mit langen Kommazahlen rechnen, zweitens hat er dann ja 1000x500x400 Berechnung oder habe ich gerade dazu was falsch verstanden hast.
Wenn du ne gute "Lektüre" hast... Ich würde mich mit dem Thema gerne tiefer befassen und vorallem diese Berechnung gänzlich verstehen, weil das ganze Grafikprogramm in meiner BLL behandelt werden soll :)
Gruß, Thomas
PS: Wie kommst du auf die Formel von z (abhängig von den x- und y-Werten)?
|
|
|
| |
|
In deiner Bestimmung von z abhängig von x, x_min und x_max benutzt du auch die komplexe Konstante i. Wie soll ich die denn problem los im Programmcode darstellen und unterscheidet sich die Formel nicht von der Funktion, denn dann müsste ich dafür auch noch einen Algorithmus zur Herleitung iwie basteln... :S
|
|
|
| |
|
Ich möchte ja keinen zuspamen, aber ich hätte da noch eine Anmerkung zu meiner gerade gestellten Frage, was die Konstante i betrifft:
Auf ![[]](/images/popup.gif) dieser Seite wird grundsätzlich auch das Newton-Verfahren im komplexen Zahlenbereich behandelt. (Ein direktes Beispiel zur Herangehensweise auch nochmal auf Seite 8)
Für z wird erst einmal [mm] x_0 [/mm] und [mm] x_1*i (x_1 [/mm] für den imaginären Berech der komplexen Zahl) eingetzt umgstellt und dann verenfachert.
Soll ich das in meinem Programm etwa auch noch einbauen? :S
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 22:43 Fr 15.06.2012 | | Autor: | leduart |
Hallo
mit deinem "rechnen mit sqrt{-1}" gibst du eigentlich zu erkennen, dass du mit komplexen zahlen nicht umgehen kannst.
also müsstestst du das erstmal lernen, und dann routinen schreiben- fals in deinem Java noch kein objekt komplexe zahlen existiert, die genau dieses objekt mit addition Multiplikation usw. erschaffen. erst dann kannst du komplex rechnen, dein Computer stößt dabei nie auf sqrt{-1}, sondern nur auf zahlenpaare (a,b) mit der Bedeutung a+ib.
wirkliche Fraktale bekommst du aber nur für komplexe zahlen. mit der reellen newtoniteration kann man höchstens etwas wie ein Feigenbaum diagramm hinkriegen, indem man die Newtoniteration für p(x)=c macht, als abszisse c wählt und als Ordinate x Werte, die iteriert werden.
die 2 bilder zeigen dir, wie das dann aussieht.
Iteriert wurden (200mal) alle Werte für x auf den 6 linien in Bild 1 die Farben zeigen für welches c Bereich.
iteriert wurde für [mm] f(x)=(x^2-3)^2-c=0
[/mm]
[Dateianhang nicht öffentlich]
[Dateianhang nicht öffentlich]
Gruss leduart
Dateianhänge:
Anhang Nr. 1 (Typ: png) [nicht öffentlich]
Anhang Nr. 2 (Typ: png) [nicht öffentlich]
|
|
|
| |
|
Das komplexen Zahlen mit einem "reellen" und einem imaginären Teil funktionieren, hab ich gestern, als ich mir ein bisschen dazu durch gelesen habe, auch schon verstanden. Dadurch werden die Funktion f(z) eigentlich zu §-dimensionalen Funktionen f(a, b).
Sprich ich setze für z überall "a + b*i" ein. Dann kann ich z.B. i² zu -1 umformen und i³ zu -i verwandeln, aber dann habe ich in den Funktionen immer noch diese Konstante i stehen, mit der ich wirklich nicht umzugehen weiß :/
Ich dachte nämlich sofort, als ich das gelesen habe, dass a & b einfach durch die x- & y-Werte eines Pixels im Bild bestimme und Finde dann zu dieser Funktion immer die Nullstelle, aber, dadurch dass ich noch nicht mit dem i umgehen kann in meiner "Logik", brauche ich da unbedingt einen Denkanstoss oder eine gute Lektüre :)
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 00:24 Sa 16.06.2012 | | Autor: | leduart |
Hallo
die komplexen zahlen werden in der sog. gaussschen Zahlenebene dargestellt, dadurch bekommst du ja erst ein 2d bild, dabei wird der imaginäre Teil in y - der reelle in x Richtung aufgetragen 3+4i hat also die Koordinaten (3,4) die addition wie bei vektoren also a+ib+c+id=(a+c)+i(b+d) multiplikation wie üblich bei Klammerrechnung:
(a+ib)*(c+id)=(ac-bd)+i*(ad+cb) usw, das ist was du deinem programm beibringen musst.
mit z=x+iy definiert man [mm] \overline{z}=x-iy [/mm] das konjugiert komplexe zu z.
[mm] 1/z=overline{z}/|z|^2 [/mm] mit [mm] |z|^2=x^2+y^2
[/mm]
das sind alle operationen, die du für das newtonverfahren brauchst, und als erstes for das objekt komplex implementieren - oder fertig suchen- musst.
gruss leduart
|
|
|
| |
|
Ich versuche dann mal kurz zur Übersicht, alle Schritte in meinem Programm zu wiederholen, damit ich weiß, wie es am Ende funktionieren soll und was jetzt noch fehlt:
1.) String (z.B: [mm] "x^3 [/mm] - x") als Funktion interpretieren und Ableitung bilden.
2.) In der Funktion f(z) statt "z" die Umschreibung "x+y*i" einsetzen und umstellen.
3.1) Für jeden Pixel x und y als Variablen einsetzen und (bei mir per While-Schleife) mit dem Newton-Verfahren die Nullstelle verfahren.
3.2) Abhängig von der getroffenen Nullstelle und den benötigten Schritte dem Pixel eine Farbe geben.
Wenn ich z.B. "f(z) = z³ - 2z + 2" behandle
1.)
->f(z) = z³ - 2z + 2
->f'(z) = 3z² - 2
2.)
-> f(x, y) = (x + y*i)³ - 2*(x + y*i) + 2
Nach Umstellen:
-> f(x, y) = x³ - 3*x*y² - 2*x + 2 + i*( -y³ - 2y + 3*x²*y)
Ich muss für das Newton-verfahren auch nochmal bei der Ableitung Schritt 2) durchführen, oder?
Aber so oder so ist mir dann noch nicht klar geworden, wie ich theoretisch mit dem i umgehe. Schließlich muss ich x & y in der Funktion und ihrer Ableitung einsetzen, um auf den nächsten z-Wert zu kommen, und dann hab ich ja wieder etwas unbestimmtes (weil komplexe Zahl).
Als Beispiel bei Koordinate [1, 2]:
f(1, 2) = 1 - 12 + i * (- 8 - 4 + 6) = -11 - 6*i
Im Newton-verfahren würd ich, um den nächsten z-Wert zu bekommen, also folgendes ausrechnen:
z = z - f(x, y) / f'(x, y)
bei [1, 2] also:
z = z - f(1, 2) / f'(1,2)
Bloß kommt da sicher ein riesiger Brei raus... :S
Kannst du mir kurz sagen, was in meiner "Anleitung" falsch ist.
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 14:01 Sa 16.06.2012 | | Autor: | leduart |
Hallo
ich hatte doch gesagt, du musst deinem programm beibringen, was komplexe zahlen sind, was es aber fast sicher schon in Javabibliotheken gibt, erst dann kannst du mit dem Newton anfangen. und direkt mit komplexen Zahlen (x,y) rechnen.
dann gibt es auch keinen "Brei"
Gruss leduart
|
|
|
| |
|
Tschuldige, wenn wie da iwie aneinander vorbei reden oder ich es nicht ganz verstehe.
Inwiefern kann ich ihm denn "beibringen" damit zu rechnen? Ein Objekt "komplexeZahl", dass dann aus a & b besteht, erzeugen? Ich dachte eig, ich kann das alles direkt machen, ohne eine extra Klasse zu bauen und einfach mit den Variablen a & b, sprich x & y, zu rechnen.
Vll. kannst mir das ein bisschen praktisch erklären (auch wenn ich nicht weiß, wie du das machn könntest :P)
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 21:32 So 17.06.2012 | | Autor: | leduart |
Hallo
du musst doch komplexe Zahlen addieren, multiplizieren potenzieren und dividieren können, ausserdem den Betrag, willst du das jedesmal neu ausführlich hinschreiben?
das geht natürlich erinnert aber eher an ein basic programm. hast du nachgesehen, ob es die Klasse complex nicht schon gibt?
aber ich will dir hier nicht programmieren beibringen, du solltest aber erstmal ein kleineres komplexes Programm schreiben, um auszuprobieren wie du damit umgehen kannst.
Hier ein Bsp:
links sind linien im Koordinatennetz, rechts ihre Bilder bei der Abbildung [mm] z^2
[/mm]
[Dateianhang nicht öffentlich]
Gruss leduart
Dateianhänge:
Anhang Nr. 1 (Typ: png) [nicht öffentlich]
|
|
|
| |
|
Meinste so eine Klasse?
________________________________________________________________________
// cmplx = a + b*i
public class Cmplx{
// reeller Zahlenbereich (a)
public double a;
// imaginärer Zahlenbereich (b * sqrt(-1))
public double b;
public Cmplx(){
this(0, 0);
}
public Cmplx(double a, double b){
this.a = a;
this.b = b;
}
public void add(Cmplx c2){
this.a += c2.a;
this.b += c2.b;
}
public void sub(Cmplx c2){
this.a -= c2.a;
this.b -= c2.b;
}
public void multiply(Cmplx c2){
this.a *= c2.a;
this.b *= c2.b;
}
public void divide(Cmplx c2){
this.a /= c2.a;
this.b /= c2.b;
}
}
________________________________________________________________
Gruß, Thomas
PS: Sry, aber konnte die Java-Funktion in dem Forum nicht finden :/
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 15:02 Mo 18.06.2012 | | Autor: | felixf |
Moin!
> Meinste so eine Klasse?
In etwa ja, aber:
> public void multiply(Cmplx c2){
> this.a *= c2.a;
> this.b *= c2.b;
> }
>
> public void divide(Cmplx c2){
> this.a /= c2.a;
> this.b /= c2.b;
> }
das tut nicht das was es soll.
> PS: Sry, aber konnte die Java-Funktion in dem Forum nicht
> finden :/
Meinst du [code]...[/code]?
LG Felix
|
|
|
| |
|
Danke für die Rückmeldung.
Und ja mir fällt auch grad auf, dass das nicht ganz richtig.
Ich müsste einen einzelnen Wert zurückgeben. Müssten also beide so aussehen:
| 1: |
| | 2: | // z1 * z2 = (a1 + b1*i)*(a2 + b2*i) = a1*a2 + a1*b2*i + b1*i*a2 - b1*b2
| | 3: | // Zusammengefasst:
| | 4: | // z1 * z2 = a1*a2 - b1*b2 + i * (a1*b2 + b1*a2)
| | 5: | public double multiply(Cmplx c2){
| | 6: | Cmplx c1 = (Cmplx) this.clone();
| | 7: | double a = c1.a * c2.a - c1.b * c2.b;
| | 8: | double b = c1.a * c2.b + c1.b * c2.a;
| | 9: | return new Cmplx(a, b);
| | 10: | }
| | 11: |
| | 12: |
| | 13: | // z1 / z2 = (z1 / z2) * (z2_k / z2_k) = ((a1 + b1*i) / (a2 + b2*i)) * ((a2 - b2*i) / (a2 - b2*i))
| | 14: | // z1 / z2 = (a1*a2 + a1*b2*i + b1*a2*i - b1*b2) / (a2*a2 + b2*b2)
| | 15: | // Zusammengefasst:
| | 16: | // z1 / z2 = (a1*a2 - b1*b2) / (a2*a2 + b2*b2) + i * (a1*b2 + b1*a2) / (a2*a2 + b2*b2)
| | 17: | public double divide(Cmplx c2){
| | 18: | Cmplx c1 = (Cmplx) this.clone();
| | 19: | double a = (c1.a * c2.a - c1.b * c2.b) / (c2.a * c2.a + c2.b * c2.b);
| | 20: | double b = (c1.a * c2.b + c1.b * c2.a) / (c2.a * c2.a + c2.b * c2.b);
| | 21: | return new Cmplx(a, b);
| | 22: | }
|
So sollte es richtig sen :D
|
|
|
| |
|
Hallo beastofchaos,
> Danke für die Rückmeldung.
>
> Und ja mir fällt auch grad auf, dass das nicht ganz
> richtig.
> Ich müsste einen einzelnen Wert zurückgeben. Müssten
> also beide so aussehen:
>
> | 1: |
| | 2: | > // z1 * z2 = (a1 + b1*i)*(a2 + b2*i) = a1*a2 + a1*b2*i +
| | 3: | > b1*i*a2 - b1*b2
| | 4: | > // Zusammengefasst:
| | 5: | > // z1 * z2 = a1*a2 - b1*b2 + i * (a1*b2 + b1*a2)
| | 6: | > public double multiply(Cmplx c2){
| | 7: | > Cmplx c1 = (Cmplx) this.clone();
| | 8: | > double a = c1.a * c2.a - c1.b * c2.b;
| | 9: | > double b = c1.a * c2.b + c1.b * c2.a;
| | 10: | > return new Cmplx(a, b);
| | 11: | > }
| | 12: | >
| | 13: | >
| | 14: | > // z1 / z2 = (z1 / z2) * [mm](z2_k[/mm] / [mm]z2_k)[/mm] = ((a1 + b1*i) /
| | 15: | > (a2 + b2*i)) * ((a2 - b2*i) / (a2 - b2*i))
| | 16: | > // z1 / z2 = (a1*a2 + a1*b2*i + b1*a2*i - b1*b2) / (a2*a2
| | 17: | > + b2*b2)
| | 18: | > // Zusammengefasst:
| | 19: | > // z1 / z2 = (a1*a2 - b1*b2) / (a2*a2 + b2*b2) + i *
| | 20: | > (a1*b2 + b1*a2) / (a2*a2 + b2*b2)
| | 21: | > public double divide(Cmplx c2){
| | 22: | > Cmplx c1 = (Cmplx) this.clone();
| | 23: | > double a = (c1.a * c2.a - c1.b * c2.b) / (c2.a * c2.a
| | 24: | > + c2.b * c2.b);
| | 25: | > double b = (c1.a * c2.b + c1.b * c2.a) / (c2.a * c2.a
| | 26: | > + c2.b * c2.b);
| | 27: | > return new Cmplx(a, b);
| | 28: | > }
| | 29: | > |
>
Hier muss es doch so lauten:
public double divide(Cmplx c2){
Cmplx c1 = (Cmplx) this.clone();
double a = (c1.a * c2.a + c1.b * c2.b) / (c2.a * c2.a + c2.b * c2.b);
double b = (c1.b * c2.a - c1.a * c2.b) / (c2.a * c2.a + c2.b * c2.b);
return new Cmplx(a, b);
}
> So sollte es richtig sen :D
Gruss
MathePower
|
|
|
| |
|
Jap, Vorzeichen vergessen bei der dritten binomischen Formel :)
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 15:19 Mo 18.06.2012 | | Autor: | leduart |
Hallo
ich hab in google javaclass complex eingegeben und sofort
das klick hier
gefunden.
google biete aber noch viele weitere an!
Gruss leduart
|
|
|
| |
|
Nicht so viel mehr, wie ich jetzt aufgeschrieben habe in der Antwort zu felixf, oder? Bzw. den Rest mach ich gerade...
Außerdem: Da ich diese Programm in meinem Abi nächstes Jahr vorstelle, möchte ich lieber die Klassen nicht kopieren, wenn du verstehst ;) Vorallem, wo ich es jetzt selbst eigentlich geschafft habe.
Meine Klasse Cmplx:
| 1: |
| | 2: | // cmplx = a + b*i
| | 3: | public class Cmplx{
| | 4: | // reeller Zahlenbereich (a)
| | 5: | public double a;
| | 6: | // imaginärer Zahlenbereich (b * sqrt(-1))
| | 7: | public double b;
| | 8: |
| | 9: | public Cmplx(){
| | 10: | this(0, 0);
| | 11: | }
| | 12: |
| | 13: | public Cmplx(double a, double b){
| | 14: | this.a = a;
| | 15: | this.b = b;
| | 16: | }
| | 17: |
| | 18: | // z1 - z2 = a1 + a2 + (b1 + b2) * i
| | 19: | public Cmplx plus(Cmplx c2){
| | 20: | return new Cmplx(this.a + c2.a, this.b + c2.b);
| | 21: | }
| | 22: |
| | 23: | // z1 - z2 = a1 - a2 + (b1 - b2) * i
| | 24: | public Cmplx minus(Cmplx c2){
| | 25: | return new Cmplx(this.a - c2.a, this.b - c2.b);
| | 26: | }
| | 27: |
| | 28: | // z1 * z2 = (a1 + b1*i)*(a2 + b2*i) = a1*a2 + a1*b2*i + b1*i*a2 - b1*b2
| | 29: | // Zusammengefasst:
| | 30: | // z1 * z2 = a1*a2 - b1*b2 + i * (a1*b2 + b1*a2)
| | 31: | public Cmplx times(Cmplx c2){
| | 32: | double a = this.a * c2.a - this.b * c2.b;
| | 33: | double b = this.a * c2.b + this.b * c2.a;
| | 34: | return new Cmplx(a, b);
| | 35: | }
| | 36: |
| | 37: | // z1 / z2 = (z1 / z2) * (z2_k / z2_k) = ((a1 + b1*i) / (a2 + b2*i)) * ((a2 - b2*i) / (a2 - b2*i))
| | 38: | // z1 / z2 = (a1*a2 - a1*b2*i + b1*a2*i + b1*b2) / (a2*a2 + b2*b2)
| | 39: | // Zusammengefasst:
| | 40: | // z1 / z2 = (a1*a2 + b1*b2) / (a2*a2 + b2*b2) + i * (- a1*b2 + b1*a2) / (a2*a2 + b2*b2)
| | 41: | public Cmplx divide(Cmplx c2){
| | 42: | double a = (this.a * c2.a + this.b * c2.b) / (c2.a * c2.a + c2.b * c2.b);
| | 43: | double b = (- this.a * c2.b + this.b * c2.a) / (c2.a * c2.a + c2.b * c2.b);
| | 44: | return new Cmplx(a, b);
| | 45: | }
| | 46: |
| | 47: | // z1 * scalar = a*scalar + b*scalar*i
| | 48: | public Cmplx times(double scalar){
| | 49: | return new Cmplx(this.a * scalar, this.b * scalar);
| | 50: | }
| | 51: |
| | 52: | // 1 / z1 = 1/z1 * z1_k/z1_k
| | 53: | // 1 / z1 = (a1 - b1*i) / (a1*a1 + b1*b1)
| | 54: | // Zusammengefasst:
| | 55: | // 1 / z1 = a1 / (a1*a1 + b1*b1) + i * b1 / (a1*a1 + b1*b1)
| | 56: | public Cmplx reciprocal(){
| | 57: | double a = this.a / (this.a*this.a + this.b*this.b);
| | 58: | double b = this.b / (this.a*this.a + this.b*this.b);
| | 59: | return new Cmplx(a, b);
| | 60: | }
| | 61: |
| | 62: | // z1_k = a - b*i
| | 63: | public Cmplx conjugate(){
| | 64: | return new Cmplx(this.a, -this.b);
| | 65: | }
| | 66: |
| | 67: | public double real(){
| | 68: | return this.a;
| | 69: | }
| | 70: |
| | 71: | public double imaginary(){
| | 72: | return this.b;
| | 73: | }
| | 74: |
| | 75: | @Override
| | 76: | public Cmplx clone(){
| | 77: | return new Cmplx(this.a, this.b);
| | 78: | }
| | 79: | }
|
Die Methoden exp(), cos(), sin(), tan() brauch ich für mine Bedürfnisse nicht, oder? Mache ja schließlich nur Polynome.
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 20:46 Mo 18.06.2012 | | Autor: | leduart |
Hallo
wenn du schon das alles hast, würde ich zur Vereinfachung und Übersichtlichkeit des eigentlichen programms noch [mm] z^2, [/mm] bis [mm] z^6 [/mm] definieren, (evt auch die ableitung von [mm] z^n) [/mm] aber sonst ist es jetzt ok. vielleicht noch direkt plot complex, damit du nicht immer in re und im zerlegen musst,
gruss leduart
|
|
|
| |
|
1. Reicht denn dafür nicht einfach diese Funktion "pow()"?
| 1: |
| | 2: | public Cmplx pow(int exponent){
| | 3: | Cmplx c = new Cmplx(1, 1);
| | 4: | for (int i = 0; i < exponent; i++){
| | 5: | c = c.times(this);
| | 6: | }
| | 7: | return c;
| | 8: | }
|
2. Was meinst du mit "evt auch die ableitung von [mm] z^n"?
[/mm]
Ne Methode die mir dann n*z^(n-1) zurückgibt?
Da könnt ich mir das direkt im Programm auch so schreiben, oder?
-> z = z.pow(n-1).times(n)
3. Was meinst du mit "plot complex"? Wo muss ich denn die beiden Variablen "zerlegen"?
Sorry, aber ich bin gerne ein bisschen begriffsstutziger, anstatt dass ich so tue, als hätte ich alles verstanden :D
Gruß und Gute Nacht, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 13:21 Di 19.06.2012 | | Autor: | leduart |
Hallo
Da das ja ne selbständige Arbeit werden soll, möchte ich ungern noch viel mehr zu deinen Programmteilen sagen.
ich schlage vor, du rechnest bzw. programmierst mal los und frägst nur, wenn du gar nicht weiterkommst. Allerdings sollten dann Teile des Programms schon funktionieren .
Alles ohne Erprobung von Teilen zu überblicken ist zu viel Arbeit für Helfer. Wir freuen uns, wenn du am ende das programm hier vorführst, bzw einen link dazu angist, und natürlich beantwortet jemand der es kann einzelne Fragen.
Aber du bist ja noch bei der Planung, und da solltest du schon mal erst selbst experimentieren.
gruss leduart
|
|
|
| |
|
Hab jetzt doch noch eine gute "Lektüre" gefunden (von der HU Berlin):
Newton-Fraktale
Demnach muss ich folgendes machen:
1. In der Funktion für z den Term "a+b*i" einsetzen und umstellen, so dass ich wieder einen reellen und einen imaginären Teil habe - dann aber in einer dreidimensionalen Funktion.
2. Die erste Ableitung von a und b durch die "Jacobi-Matrix" bilden.
3. Die Nullstellen durch das Newton-Verfahren ermitteln
3. Mit der Funktion und ihrer 1. Ableitung das Newton-Verfahren anwenden für die x- und y-Werte im Bereich [-1; 1].
(Testweise mach hier mal Schritte in Hundertsteln)
4. Abhängig von der getroffen Nullstelle und den benötigten Schritten dem Pixel mit den jeweiligen x- und y-Wert eine Farbe geben.
Zumindest hab ich in der Theorie jetzt schon mal einen Arbeitsplan! :D
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 13:07 Mo 18.06.2012 | | Autor: | leduart |
Hallo
du solltest komplexe Zahlen als (a,b) behandeln, als Klasse oder jedesmal einzeln.
dein java weiss ja nichts von i
am besten complex(re,im)
angenommen du hast complex definiert,
complex z1= (re1,im1), z2=(re2,im2)
dann brauchst du z.B, die funktion mult
mit z1 mult.z2=(re1*re2-im1*im2,re1*im2+re2*im2)
entsprechend länger 1/z
und z1+z2 und abs(z)
am besten direkt noch [mm] z^2,z^3,...z^n [/mm] n so hoch es bei dir vorkommmt.
schreib doch erst mal ein miniprogramm, was z1,z2 plottet, dann z1+z2,z1-z2, z1*z2, 1/z1, z1/z2
Dein Arbeitsplan ist schon ok, aber die Schwierigkeit ist ja die Umsetzung mit den komplexen Zahlen. in deinem kleinen programmauschnitt wo du die mult und division beschreibst, sind die falsch!
Gruss leduart
|
|
|
| |
|
1. Diese Methode wäre doch bei Polynomen doch auch ganz gut, oder?
| 1: |
| | 2: | public Cmplx pow(int exponent){
| | 3: | Cmplx c = new Cmplx(1, 1);
| | 4: | for (int i = 0; i < exponent; i++){
| | 5: | c = c.times(this);
| | 6: | }
| | 7: | return c;
| | 8: | }
|
2. Wo genau fang ich an komplexen Zahlen zu benutzen?
Schließlich wandle ich zuerst den String um in eine Funktion, dann bilde ich davon die Ableitung.
Dann hatte ich bei meiner bisherigen Idee von nur reellen Zahlen gleich angefangen mit der For-Schleife, um die einzelnen Pixel ab zu arbeiten:
// For-Schleife für alle x- und y-Werte:
->// Anfangswert x bestimmen
->// While-Schleife:
-> ->// Newton-Verfahren (bis die Differenz 0.5 beträgt)
->// Herausfinden, welche Nullstelle getroffen wurde
->// Abhängig von den Schritten in der While-Schleife die Helligkeit bestimmen
->// Pixel anmalen mit der Farbe der Nullstelle und der bestimmten Helligkeit
Um das Newton-Verfahren jetzt für komplexe Zahlen anzuwenden, müsste ich erstmal die mehrdimensionale Funktion ableiten können. Dazu muss ich fragen, ist es nötig, dass ich meine Klasse "Funktion" an komplexe Zahlen anpasse? Ich befürchte schon, aber dann muss ich meine bisherige ja ganz wegschmeißen... :S
Ich red zu viel...Also kurz und einfach: Was wäre jetzt der nächste Schritt, nachdem mein Programm mit komplexen Zahlen rechnen kann und was gibt es da zu beachten? (Ich vermute mal die Funktion-Klasse schreiben)
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 21:33 Mo 18.06.2012 | | Autor: | leduart |
Hallo
die Regeln beim Ableiten von komplexen fkt sind genau die von reellen, d.h, [mm] f(z)=z^n f'(z)=n*z^{n-1}
[/mm]
du musst jetzt nur deine polynome direkt mit komplexen zahlen schreiben.
die allgemeine Eingabe für einen user kannst du ja am Ende zufügen, mach das ganze erst mal für eine bestimmte Funktion
allgmein brauchst du eine funktionsklasse, eher eine polynomklasse, da ich deine reelle nicht kenn weiss ich nicht wieviel du übernehmen kannst,
du kannst direkt bei deiner complexen Klasse noch poly definieren. oder polyn für polyno m vom grad n
ich würde erst mal das ganze für ein festes polynom machen, erst dann allgemein- aber das ist meine methode zu programmieren. deine mußt du selbst rausfinden.
Gruss leduart
|
|
|
| |
|
Also hier meine Funktion-Klasse, falls du mal rein schaun willst:
| 1: |
| | 2: | public class Function{
| | 3: | private double[] coefficents;
| | 4: | private boolean generateException;
| | 5: |
| | 6: | // Funktion als String
| | 7: | // z.B.: f = "f(x) = 7.3 * x^3 - x"
| | 8: | public Function(String f){
| | 9: | this(f, false);
| | 10: | }
| | 11: |
| | 12: | // Für jeden Polynomgrad (1...coefficents.length) der Faktor
| | 13: | // z.B.: coefficents = new double[]{5.0, 3.5, 0, 4.7}
| | 14: | // -> f(x) = 5.0 + 3.5 * x + 4.7 * x^3
| | 15: | public Function(double[] coefficents){
| | 16: | this(coefficents, false);
| | 17: | }
| | 18: |
| | 19: | public Function(String f, boolean generateException){
| | 20: | this.coefficents = interpretate(f);
| | 21: | this.generateException = generateException;
| | 22: | }
| | 23: |
| | 24: | public Function (double[] coefficents, boolean generateException){
| | 25: | this.coefficents = coefficents;
| | 26: | this.generateException = generateException;
| | 27: | }
| | 28: |
| | 29: | // Höchste vorkommende Potenz ermitteln
| | 30: | public int getGrade(){
| | 31: | return coefficents.length - 1;
| | 32: | }
| | 33: |
| | 34: | // X-Wert in der Funktion einsetzen
| | 35: | public double getY(double X){
| | 36: | double Y = 0.0;
| | 37: | for (int i = 0; i < coefficents.length; i++){
| | 38: | Y += coefficents[i] * Math.pow(X, i);
| | 39: | }
| | 40: | return Y;
| | 41: | }
| | 42: |
| | 43: | // Ist ein "in" der Funktion aufgetreten?
| | 44: | public boolean generatingException(){
| | 45: | return generateException;
| | 46: | }
| | 47: |
| | 48: | // Neues Funktion-Objekt mit der Ableitung erzeugen
| | 49: | public Function getDerivativeFunction(int grade){
| | 50: | return new Function(getDerivative(grade), generateException);
| | 51: | }
| | 52: |
| | 53: | // Berechnet die Koeffizienten für die "grade"ste Ableitung
| | 54: | public double[] getDerivative(int grade){
| | 55: | if (grade < 1){
| | 56: | generateException = true;
| | 57: | return null;
| | 58: | }
| | 59: | else if(grade > coefficents.length - 1){
| | 60: | return new double[]{0};
| | 61: | }
| | 62: | double[] coeffs = coefficents;
| | 63: | double[] derivative = null;
| | 64: | for(int g = 0; g < grade; g++){
| | 65: | derivative = createDerivative(coeffs);
| | 66: | coeffs = derivative;
| | 67: | }
| | 68: | return derivative;
| | 69: | }
| | 70: |
| | 71: | // Bildet die erste Ableitung (entspricht "getDerivative(1)")
| | 72: | private double[] createDerivative(double[] coeffs){
| | 73: | double[] derivative = new double[coeffs.length -1];
| | 74: | for(int i = 0; i < derivative.length; i++){
| | 75: | derivative[i] = coeffs[i+1]*(i+1) ;
| | 76: | }
| | 77: | return derivative;
| | 78: | }
| | 79: |
| | 80: | // siehe "toString(int derivative)"
| | 81: | public String toString(){
| | 82: | return toString(0);
| | 83: | }
| | 84: |
| | 85: | // Erzeugt einen String, der die Funktion in allbekannter Schreibweise darstellt
| | 86: | // z.B.: "f(x) = x^4 + 3.12*x^2 - x + 5.4
| | 87: | //
| | 88: | // "derivative" gibt an, um die wie vielste Ableitung es sich handelt
| | 89: | // z.B.: toString(2) -> "f''(x)=...."
| | 90: | public String toString(int derivative){
| | 91: | String pre = "f";
| | 92: | for (int i = 0; i < derivative; i++){
| | 93: | pre += "'";
| | 94: | }
| | 95: | pre += "(x) =";
| | 96: |
| | 97: | String f = "";
| | 98: | if (generateException){
| | 99: | f = "Fehlerhaft Eingabe!";
| | 100: | }
| | 101: | else{
| | 102: | for(int i = coefficents.length - 1; i >= 0; i--){
| | 103: | if (coefficents[i] != 0){
| | 104: | if (coefficents[i] > 0 && f.length() > 0){
| | 105: | f += " + " + Math.round(coefficents[i]);
| | 106: | }
| | 107: | else if(coefficents[i] < 0){
| | 108: | f += " - " + Math.round(coefficents[i] * (-1));
| | 109: | }
| | 110: | else{
| | 111: | f += " " + Math.round(coefficents[i]);
| | 112: | }
| | 113: | f += (i > 0) ? " * x" : "";
| | 114: | f += (i > 1) ? "^" + i : "";
| | 115: | }
| | 116: | }
| | 117: | }
| | 118: |
| | 119: | return pre + f;
| | 120: | }
| | 121: |
| | 122: | // Verwandelt einen String in ein Funktion-Objekt
| | 123: | // Einheitliche Schreibweise:
| | 124: | // "Faktor(double) * x ^ Potenz(int)"
| | 125: | public double[] interpretate(String f){
| | 126: | String s;
| | 127: | int cursor = 0;
| | 128: | int grade = 0;
| | 129: | int maxGrade = 0;
| | 130: | double coeff = 0;
| | 131: | double[] coeffs;
| | 132: | ArrayList<Double> tempCoeffs = new ArrayList<Double>();
| | 133: | ArrayList<Integer> tempGrades = new ArrayList<Integer>();
| | 134: |
| | 135: | f = f.replaceAll(" ", "");
| | 136: | f = f.replaceAll("\\*", "");
| | 137: | f = f.replace("-", "+-");
| | 138: | if (f.startsWith("f(x)=")){
| | 139: | f = f.substring(5);
| | 140: | }
| | 141: | String[] parts = f.split("\\+");
| | 142: |
| | 143: | for(int i = 0; i < parts.length; i++){
| | 144: | s = parts[i];
| | 145: | if(s.length() > 0){
| | 146: | if (s.startsWith("-") && s.charAt(1) == 'x'){
| | 147: | s = s.substring(0, 1) + '1' + s.substring(1);
| | 148: | }
| | 149: | else if (s.charAt(0) == 'x'){
| | 150: | s = '1' + s;
| | 151: | }
| | 152: | cursor = s.indexOf('x');
| | 153: | if ((cursor >= 0 && s.length() > cursor + 1 && s.charAt(cursor + 1) != '^')){
| | 154: | generateException = true;
| | 155: | return null;
| | 156: | }
| | 157: | if (cursor == -1){
| | 158: | grade = 0;
| | 159: | try{
| | 160: | coeff = Integer.parseInt(s);
| | 161: | } catch(NumberFormatException e){
| | 162: | generateException = true;
| | 163: | return null;
| | 164: | }
| | 165: | }
| | 166: | else{
| | 167: | coeff = Double.parseDouble(s.substring(0, cursor));
| | 168: | if (s.length() > cursor + 1){
| | 169: | grade = Integer.parseInt(s.substring(cursor + 2));
| | 170: | }
| | 171: | else{
| | 172: | grade = 1;
| | 173: | }
| | 174: | }
| | 175: |
| | 176: | tempGrades.add(grade);
| | 177: | tempCoeffs.add(coeff);
| | 178: | maxGrade = Math.max(maxGrade, grade);
| | 179: | }
| | 180: | }
| | 181: |
| | 182: | coeffs = new double[maxGrade + 1];
| | 183: | for(int i = 0; i < tempGrades.size(); i++){
| | 184: | coeffs[tempGrades.get(i)] += tempCoeffs.get(i);
| | 185: | }
| | 186: |
| | 187: | return coeffs;
| | 188: | }
| | 189: | }
|
Was würdest du jetzt daran umändern bzw. was muss ich machen?
Außerdem: Ich hab doch nur eine Nullstelle, wenn a und b gleich 0 sind, oder?
Und wie würdest du die "4" Ableitungen in der Klasse einbinden?
Gruß und Gute Nacht, Thomas
|
|
|
| |
|
Ich habe jetzt mir auch auf dem Papier schon alle Schritte aufgeschrieben und fang gleich mit dem Programm eiren na, aber ich habe eine Fragen noch zur Jacobi-Matrix.
Die entsteht ja, wenn ich von der dreidimensionalen Funktion f(rel, imag) ableiten will.
Im Newton-Verfahren heißt es nun: x2 = x1 - f(x1) / f'(x1)
In komplexen Bereich wäre das: (a2, b2) = (a1, b1) - f(a1, b1) / J(a1, b1)
Ich kann zwar nun mit komplexen Zahlen rechnen, aber die Jacobi-Matrix enthält ja 4 Terme, wie gehe ich damit um?
So wie ich das sehe, muss ich das unmögliche tun und sozusagen einen zweidimensionalen Vektor durch einen vierdimensionalen Vektor teilen.
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 16:39 Di 19.06.2012 | | Autor: | leduart |
Hallo
die jakobi matrix darfst du vergessen, im nenner steht einfach f'(z) und ich hab dir gesagt, wie man das berechnet
(durch Matrices kann man übrigens nicht teilen, du hast da irgendwoher ne falsche Formel)
du hast ja inzwischen komplexe rechnungren, deshalb solltest du die konsequent benutzen und nicht f(x,y)
also [mm] z1=z_0+f(z_0)/f'(z_0)
[/mm]
wobei z und f(z) complex sind.
Gruss leduart
|
|
|
| |
|
Aber die Frage ist dann, was ist f'(z)
Die Ableitung von f(z) bilde ich ja, indem ich von f(a, b) die Jakobi-Matrix bilde, oder?
z2 = z1 - f(z) / f'(z)
ist in meinen Augen nichts anderes als:
(a2, b2) = (a1, b1) - f(a1, b1) / f'(a1,b1)
Dann habe ich noch eine Frage: Ich hab ja die Funktion mit x als reelle Zahl definiert. Jetzt muss ich aber für x eine komplexe Zahl einfügen, was ja nichts anderes bedeutet, als dass ich (a+b*i) überall einsetze, wo x steht.
Am Ende habe ich dann eine Funktion, in der die Variablen a, b (und i) vorkommen.
Ich dachte mir, dass ich für so eine kompliziert aufgebaute Funktion erstmal die Klasse Term schreibe, die den Faktor (mit Vorzeichen), die Potenz über a und die über b enthält. So wird aus new Term(1, 2, 1) -> [mm] a^2 [/mm] * b
Wenn ich dann im Code z.B. stehen habe:
[mm] "3ab^2 [/mm] - [mm] b^3 [/mm] - b"
mache ich aus diesen drei Subtermen
new Term(3, 1, 2);
new Term(-1, 0, 3);
new Term(-1, 0, 1);
Jetzt muss ich meinem Programm nur noch die Binomische Formel für n=2...6 beibringen und dann kann ich f(x) zu f(z) umformen, oder?
Gruß, Thomas
|
|
|
| |
|
Um zu verdeutlichen, was ich meine:
Ich habe jetzt schon einiges geschafft. Es existieren nun folgende Klassen:
Cmplx:
- Enthält die Variablen a und b
- Soll für eine komplexe Zahl stehen
Term:
- Steht für einen Teilterm in einer komplexen Funktion (z.B.: "5 * [mm] a^3 [/mm] * [mm] b^2 [/mm] * i")
-> Besteht aus den Variablen factor, a_pot, b_pot, i_pot
Function:
- Stellt eine normale Funktion da (z.B. "f(x) = [mm] x^3 [/mm] - x")
CmplxFunction:
- Stellt eine Funktion im komplexen Zahlenbereich dar
-> Wandelt mit Hilfe der binomischen Formel (und damit des Binomialkoeffizienten) f(x) in f(a + b*i)
Um das ganze auszuprobieren, hab ich das hier getestet:
| 1: |
| | 2: | // Die Komplexe Funktion aus "f(x) = x^3 - x" erzeugen
| | 3: | CmplxFunction cf = new CmplxFunction(new Function("f(x) = x^3 - x"));
| | 4: |
| | 5: | // Die Funktion f(a + b*i) ausgeben
| | 6: | System.out.println(cf.toString());
| | 7: | // Ausgabe in der Konsole:
| | 8: | // f(a + b*i) = a^3 + 3.0 * a^2 * b * i - 3.0 * a * b^2 - b^3 * i - a - b * i
| | 9: |
| | 10: | // Testweise einen Wert ausprobieren (hier die komplexe Zahl z = 0.5 + 2 * i)
| | 11: | System.out.println(cf.getValue(new Cmplx(0.5, 2)).toString());
| | 12: | // Ausgabe in der Konsole:
| | 13: | // -6.375 + -8.5 * i
|
Auch wenn ihr den Code nicht habt, denk ich, es ist sehr verstänbdlich, was ich nun schon habe.
Wie gesagt, fehlt mir nur noch ein Ansatz, wie ich f'(a+b*i) sprich die Jacobi-Matrix im Newton-Verfahren anwende.
Freu mich auf Hilfe :)
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 23:11 Di 19.06.2012 | | Autor: | leduart |
hallo
ich verstehe nicht ganz: du hast doch jetzt die klasse komplex geschaffen, und mußt deshalb nach eingabe von complex z als Paar dich nie mehr mit a+ib rumplagen. du kannst f wie die fkt f(x9 definieren, nur kannst du nicht einfach [mm] z^2 [/mm] schreiben sondern deine power und times benutzen statt * und +.
wozu hast du denn sonst die komplexe Klasse?
dann hat f'(z) nichts mit Jakobimatrix zu tun sondern einfach wie ich schrieb f'(z) also wäre [mm] f(z)=z^2+a [/mm] dann wäre deine iteration: z complex
[mm] z1=z_0+(z_0^2+a)/2z_0
[/mm]
entsprechend für längere Polynome.
bist du neu am objekt orientierten programmieren? also an java? ich versteh nämlich nicht, warum du nach Schaffung der klasse witer von f(a,b) bzw a+ib redest.
die bin. formel brauchst du nicht! du kannst doch einfach z1times z2 oder (z1.plusz2).times (z1.plus z2) schrieben usw.
Gruss leduart
Gruss ledart
|
|
|
| |
|
Ja ich hatte in dieser Anleitung davon gelesen, wie man das machen könnte :P
Aus Seite 8 wird auch nochmal ein Beispiel gezeigt.
Aber ich denke, ich weiß jetzt, was du meinst
Das heißt also für das Beispiel [mm] "z^3 [/mm] - z", dass die Ableitung [mm] 3*z^2 [/mm] - 1 ist und ich nicht einzeln nach a und b ableiten muss (wodurch diese Matrix enstehen würde).
Tschuldige, aber wieso leicht, wenn es auch schwer geht hihi :)
Ich setz mich gleich ran und meld mich dann spätestens morgen wieder mit Ergebnissen
Gruß, Thomas
|
|
|
| |
|
Hier könnt ihr euch mein Programm mal runterladen.
Es klappt super und ist so ziemlich alles was ich will... außer, dass ich ja noch abhängig von den Schritten die Dunkelheit verändern will.
Es können maximal 40 Steps sein (wobei es in der Regel zwischen 0 und 20 sind) und die Differenz von x1 und x2 ist maximal 0.1 für mein Newton-Verfahren.
Wir würdet ihr jetzt "brightness" bestimmen?
Gruß, Thomas
Dateianhänge:
Anhang Nr. 1 (Typ: java) [nicht öffentlich]
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 15:20 Mi 20.06.2012 | | Autor: | leduart |
Hallo
kannst du das direkt als .jar hochladen oder verlinken?
gruss leduart
|
|
|
| |
|
1. Ja, ist hier jetzt drinne
2. Hab ich für die Helligkeit jetzt eine Formel und eine Scrollbar eingerichtet. Denn an sich sieht es cool aus, wnen man as Fraktal mal etwas stärker verdunkelt oder erhellt darstellt. Das könnt ihr ja jetzt gleich selbst ausprobieren.
Was mich daran nervt ist halt, dass er solange braucht und ich die ScrollBar nicht flüssig bedienen kann.
Kann ich iwie mittels eines seperaten Threads die Berechnungen im Hintergrund laufen lassen und jedesmal, wenn der Wert sich ändert abbrechen und neu starten lassen?
Oder was wäre eure Idee, damit nicht das ganze Programm warten muss, bis die Berechnungen abgeschlossen sind? :)
3. Das Fraktal sieht iwie noch ein bisschen ungenau aus. Hab viel ausprobiert, aber meines ähnelt diesem hier kaum :S
Gruß, Thomas
Dateianhänge:
Anhang Nr. 1 (Typ: jar) [nicht öffentlich]
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 00:46 Fr 22.06.2012 | | Autor: | felixf |
Moin!
> Was mich daran nervt ist halt, dass er solange braucht und
> ich die ScrollBar nicht flüssig bedienen kann.
> Kann ich iwie mittels eines seperaten Threads die
> Berechnungen im Hintergrund laufen lassen und jedesmal,
> wenn der Wert sich ändert abbrechen und neu starten
> lassen?
Klar.
Du musst dich dafuer aber etwas mit Thread-Programmierung auseinandersetzen. Das ist nicht ganz so einfach wie es vielleicht auf dem ersten Blick aussieht.
> Oder was wäre eure Idee, damit nicht das ganze Programm
> warten muss, bis die Berechnungen abgeschlossen sind? :)
Verwende Threads :)
> 3. Das Fraktal sieht iwie noch ein bisschen ungenau aus.
> Hab viel ausprobiert, aber meines ähnelt
> diesem
> hier kaum :S
Ich hab das auch mal probiert (mit dem Polynom [mm] x^3-1), [/mm] und es ist tatsaechlich teils recht anders.
Woran das liegt ist schwer zu sagen, ohne das Programm selber zu sehen (also den Quelltext). Ich vermute, irgendwo verrechnest du dich bzw. hast eine Formel falsch implementiert.
LG Felix
|
|
|
| |
|
Na im Grunde genommen hat es die selbe Form und funktioniert so wie es soll, aber bei deren Muster-Fraktal haben die die Helligkeit so eingesetzt, dass es mehr "abgerundet" aussieht. Und vorallem sind bei den Verdrehungen zur Mitte hin die Ränder weiß, bei mir sind da nur farbige Stellen. Weiß gibt es bei mir nur an den drei Nullstellen direkt (was ja auch logisch ist).
Im Anhang mein Programm mit dem Muster-Bild im Vergleich :)
Gruß, Thomas
Dateianhänge:
Anhang Nr. 1 (Typ: png) [nicht öffentlich]
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 21:20 So 01.07.2012 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 12:20 Fr 22.06.2012 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
| |
|
Hier jetzt das vollständige Programm im Anhang.
Viel Spaß damit!!
Gruß, Thomas
Dateianhänge:
Anhang Nr. 1 (Typ: jar) [nicht öffentlich]
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 16:47 Do 21.06.2012 | | Autor: | leduart |
Hallo
bei mir läuft das nicht, mac system , jnormalerweise laufen richtige .jar
Fehlermeldung:
21.06.12 16:40:24 [0x0-0x9a49a4].com.apple.JarLauncher[32337] SystemFlippers: didn't consume all data for long ID 0 (pBase = 0x1001101d0, p = 0x1001101d4, pEnd = 0x1001101d8)
21.06.12 16:40:24 [0x0-0x9a49a4].com.apple.JarLauncher[32337] SystemFlippers: didn't consume all data for long ID 0 (pBase = 0x100111320, p = 0x100111324, pEnd = 0x100111328)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] Exception in thread "main"
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] java.lang.UnsupportedClassVersionError: Bad version number in .class file
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.defineClass1(Native Method)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.defineClass(ClassLoader.java:676)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.net.URLClassLoader.defineClass(URLClassLoader.java:260)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.net.URLClassLoader.access$100(URLClassLoader.java:56)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.net.URLClassLoader$1.run(URLClassLoader.java:195)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.security.AccessController.doPrivileged(Native Method)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.loadClass(ClassLoader.java:317)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:280)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
21.06.12 16:40:25 [0x0-0x9a49a4].com.apple.JarLauncher[32337] at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:375)
21.06.12 16:42:06 firefox[20661] Looked for URLs on the pasteboard, but found none.
21.06.12 16:42:06 firefox[20661] Looked for URLs on the pasteboard, but found none.
das in Eclipse zu laden hab ich keine Lust
Gruss leduart
Gruss leduart
|
|
|
| |
|
Liegt vll. daran, dass du keine aktuelle Java-Version hat. Denn wie es aussieht, wird die Exception im ClassLoader generiert, weil er ne Klasse nicht findet - weil vll in deiner Java-Version nicht vorhanden :/
Gruß, Thomas
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 00:39 Fr 22.06.2012 | | Autor: | felixf |
Moin,
> Liegt vll. daran, dass du keine aktuelle Java-Version hat.
> Denn wie es aussieht, wird die Exception im ClassLoader
> generiert, weil er ne Klasse nicht findet - weil vll in
> deiner Java-Version nicht vorhanden :/
er findet die Hauptklasse nicht, bzw. genauer, kann sie nicht verwenden, da ihre Java-Versionsnummer zu hoch ist. Vermutlich ist die Java-Version von leduart zu alt, wie du auch vermutest.
Bei mir laeuft es uebrigens. (Java 1.6.0_23, OpenJDK Runtime Environment (IcedTea6 1.11pre))
LG Felix
|
|
|
|
![[]](http://upload.wikimedia.org/wikipedia/commons/6/6a/Julia-set_N_z3-1.png){kind=small}
diesem