Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
ich bin blutiger Anfänger, deshalb kenne ich auch nicht besonders viele
Fachausdrücke. Darum entschuldige ich mich schon mal für falsche Aussagen meinerseits.
Ich habe ein Programm geschrieben, welches einen Zylinder in zweidimensionale Quadrate aufteilt und die vier Koordinaten jedes einzelnen Quadrates berechnet.
Danach habe ich mir gedacht es wäre schön wenn mein Programm nicht auf einen kreisrunden Querschnitt beschränkt ist sondern durch vorher eingegebene Koordinaten,
welche durch eine Spline verbunden sind, jede beliebige Querschnittsform generiert.
Das habe ich in Prinzip auch geschafft aber dafür werden einige Schleifen immer wieder
durchlaufen, um die gleichen Hilfsgrößen zu bekommen was sehr sehr viel Zeit kostet (ca. eine halbe Stunde).
Ist es möglich die Hilfsgrößen einmal zu berechnen und danach zu speichern damit sie immer wieder abgerufen werden können(Die Hilfsgrößen sind mit einem Index versehen).
wovon hängen diese hilfsgrößen ab, haben die ne abhängigkeit zum spline, sprich zum genutzten querschnitt, oder ist das wie zB. PI etwas konstantes, oder etwas was aus anderen spline-unabhängigen werten errechnet wird?!
Klar geht das. Mach ne Membervariable in der das Ergebniss gespeichert wird, solange nichts an den Sachen geändert wird von denen das Ergebniss abhängt kann immer die Membervariable zurückgegeben werden anstatt es neu zu berechnen. Beispielcode:
Java:
class A{
private Koordinaten koordinaten;
private int length;
private boolean lengthChanged = true;
public void setKoordinaten(Koordinaten koordinaten){
this.koordinaten = koordinaten;
lengthChanged = true;
}
public int getLength(){
if(lengthChanged){
// komplizierte Berechnung von length
this.length = dasErgebnissDieserKompliziertenBerechnung
lengthChanged = false;
}
return length;
}
}
Ist nur ein Beispiel.
Wenn du mehrere Zwischenergebnisse speichern willst kannste entweder mehrere Membervariablen machen
oder (wegen dem von dir angedeuteten index) du machst en Array
Die Hilfsgrößen müssen berechnet werden, um die Splinefunktion zu bekommen und diese wollte ich nur einmal berechnen lassen und danach speichern und nach bedarf abfragen.
Es sind keine Konstanten wie PI.
Irgendwie kriege ich es einfach nicht hin. ich habe mal einer meiner Schleifen als Beispiel mit dran gehängt.
Code:
int Iterationsschritte=30; //Anzahl der Iterationsschritte
int Schritt=0;
//Randbedingungen für die Iteration, welche bei jedem Schritt gültig sind
m[0]=0;
m[8]=0;
//Schleife für die Iteration
while(Schritt<Iterationsschritte)
{
i=1;
//Schleife um m[i] zu berechnen
while(i<(n-1))
{
//Für den ersten Iterationsschritt ist es notwendig m[i+1] Null zu
//setzen, da noch keiner berechnet wurde. Nach der ersten
//Iteration wird der Wert aus dem vorherigen genommen und so eine
//immer größer werdene Genauigkeit erreicht.
if (Schritt==1)
{
m[i+1]=0;
}
m[i]=((c[i]-h[i-1]*m[i-1]-h[i]*m[i+1])*Math.pow(2*(h[i-1]+h[i]), -1));
i++;
}
Schritt++;
}
ich würde jetzt gerne jeden m -Wert nach seiner Berechnung speichern
Ist "m" eine Membervaraible oder hast du "m" lokal in der Methode angelegt? Wenn es eine Membervariable ist, dann wird das Ergebniss doch bereits abgespeichert.
Ansonsten gilt: Desto mehr Code du postest, desto mehr kann dir geholfen werden.
Übrigens: Variablen- und Methodennamen schreibt man im camelCase (d.h. 1. Buchstabe klein), Klassennamen im CamelCase
(siehe dazu die Java Coding Convention)
wieviel zeilen hat denn die klasse wo das alles drinsteht?
nicht das du uns erschlägst, aber vielleicht ist sie ja überschaubar und dann würde es helfen wenn du einfach die ganze Klasse mal in Java! - Tags packst
uff die Baustelle wird immer größer .. pass auf ich bau dir grad .. h m und c so um dass sie nur 1x berechnet werden ... so das bedeutet aber du musst an einer zentralen Stelle diese Berechnung anstoßen und schiebst dann einfach die Klasseninstanzen davon an die jeweilige Stellen wo sie gebraucht werden. Da machst dann nur sowas wie: m.getPolarkoordinate(index);
analog das noch für die Klasse Datenpunkte, die kannst ja mal noch reinschieben, weil diese betrifft es ja auch .. Alpha - Gamma sollen aber dann stets neu berechnet werden auf basis der vorher berechneten Daten in m h und c?!
so also .. h m und c wären nun konsistent zu meinem erdachten konzept, sehen aus wie folgt:
Java:
class h extends Polarkoordinaten {
private double[] h;
private int n;
private int berechnen;
public h (int berechnen, int n) {
this.n = n;
this.berechnen = berechnen;
this.h = new double[n];
calculateHValues();
}
private void calculateHValues() {
int i=0;
double phi_plus = 0;
double phi = 0;
while (i < (n-1)) {
phi_plus = new Datenpunkte((i+1),1).getPolarkoordinaten(i+1); //fix Daten-Klasse
phi = new Datenpunkte((i),1).getPolarkoordinaten(i);//fix Daten-Klasse
h[i] = phi_plus - phi;
i++;
}//while
/* analog
for (int i=0; i < (n-1); i++) {
<Berechnungen>
}
*/
}//calculateHValues
public double getPolarkoordinaten(int index) {
return h[index];
}
}
Java:
class c extends Polarkoordinaten {
private h hValues;
private double[] c;
private int n;
private int berechnen;
public c (int berechnen, int n, h hValues) {
this.hValues = hValues;
this.n = n;
this.berechnen = berechnen;
this.c = new double[n];
calculateCValues();
}
private void calculateCValues() {
double r_plus;
double r;
double r_minus;
double h_minus;
double h;
int i=1;
while (i < (n-1)) {
h = hValues[i];
h_minus = hValues[i-1];
r_plus = new Datenpunkte((i+1),2).getPolarkoordinaten(i+1); //fix Konstruktor
r = new Datenpunkte((i),2).getPolarkoordinaten(i); //fix Konstruktor
r_minus = new Datenpunkte((i-1),2).getPolarkoordinaten(i-1); //fix Konstruktor
//kann man bestimmt noch besser schreiben, aber ich hab sie erstma übernommen
c[i] = (double) (6*Math.pow(h,-1)*(r_plus-r)-6*Math.pow(h_minus,-1)*(r-r_minus));
i++;
}//while
//wieder mit for-schleife lösbar, liest sich in meinen augen besser
}//calculateCValues
public double getPolarkoordinaten(int index) {
return c[index];
}
}
Java:
class m extends Polarkoordinaten {
//zentrale Stelle zum aendern, brauchst net erst im Code wuehlen
private static final int MAXSTEPS = 30;
private h hValues;
private c cValues;
private double[] m;
private int n;
private int berechnen;
public m (int berechnen, int n, h hValues, c cValues) {
this.berechnen = berechnen;
this.hValues = hValues;
this.cValues = cValues;
this.m = new double[n+1];
calculateMValues();
}
private void calculateMValues() {
double h;
double h_minus;
double c;
int step = 0;
int i = 0;
m[0] = 0;
//m[2] = 0; ersetzt doch die Anweisung unten in der while-schleife oder? probier mal aus!
m[n-1] = 0;
while (step < MAXSTEPS) {
i = 1;
while (i < (n-1)) {
c = cValues.getPolarkoordinaten(i);
h = hValues.getPolarkoordinaten(i);
h_minus = hValies.getPolarkoordinaten(i-1);
//laesst sich oben ersetzen!?
if (step == 1)
m[i+1] = 0;
m[i] = ((c-h_minus*m[i-1]-h*m[i+1])*Math.pow(2*(h_minus+h), -1));
i++;
}//while
step++;
}//while
}
public double getPolarkoordinaten(int index) {
return (double) m[index];
}
}
so das würde bedeuten, deine Klasse Polarkoordinaten hat statt getPolarkoordinaten() nun eine Methode getPolarkoordinaten(int index). Das bedeutet natürlich das sämtliche Aufrufe der Werte über diese Methode gehen, und aber auch in Beta etc. angepasst werden müssen. An einer zentralen Stelle erstellst du einfach für h m und c je EINE Instanz. Der Konstruktor dieser Klassen kümmert ich um die initiale Berechnung er Werte. Danach brauchst nur noch mit getPolarkoordinaten(int index) arbeiten.
Die Datenpunkte-Klasse muss noch ähnlich wie h m und c umgebaut werden, damit mein Source klappt. Das hat dann wieder auch Änderungen in zB Alpha zur Folge. Dennoch macht es den Code äußerst lesbarer als vorher^^
Ich hab das nicht getestet oder dergleichen, ich hoffe das nicht allzuviele Fehler drin sind in den 3 Klassen. Sicherlich wird durch die neue Methode erstmal Eclipse oder wer auch immer meckern zwecks Oberklasse und Nutzung in Alpha, Beta etc. aber das musst eben fix anpassen, dann sollte das schon in etwa dem entsprechen was du gern wolltest ^^
sind schon recht viele Änderungen drin, aber so wird daraus n akzeptables Konzept, von den Einsparungen durch einmaliges Berechnen ganz zu schweigen ^^
Wenn dir noch etwas unklar sein sollte, frag ruhig nach, aber ich denk ich bin erstma im Bett
bis späda
edit: das berechnen im Konstruktor war mir net ganz klar, das wird wohl erst durch Datenklasse ersichtlich, schmeiss es raus, wo du es nich brauchst
beim Erstellen der Instanzen von h m und c .. erst h erstellen, dann an c übergeben, und die beiden dann an m übergeben, sollte denk ich klar sein
