Verschachtelte Funktionen. Hilfe!

[Anonym]

Hallo!
Ich versuche gerade eine dreidimensionale numerische Integration zu implementieren. Dazu habe ich folgende Funktion

typedef double (*ftyp) (double );
double intgerate(ftyp function, double x_min, double x_max);

umgesetzt, die ein einfaches eindimensionales Integral der Funktion function(x) ausrechnet.
Nun versuchte ich damit eine Funktion int_3d zu implementieren, die ein Integral der Funktion func(x, y, z) ausrechnet:

typedef double (*f3typ) (double ,double ,double );
double int_3d(f3typ func, double x1, double x2, double y1, double y2, double z1, double z2)
{
double g(double x, double y){
double f_z(double z){
return func(x, y, z);
}
return integrate(f_z, z1, z2);
}

double h(double x){
double f_y(double y){
return g(x, y);
}
return integrate(f_y, y1, y2);
}

return integrate(h, x1, x2);
}

Natürlich ist so eine verschachtelte Definition nicht zulässig. Wie könnte man das trotzdem programmieren? Ich bin für jede Hilfe sehr dankbar.
Vielen Dank im voraus.
Ray.

[Anonym]

Hi Ray,
ich würde zuerst die Funktion integrate anders implementieren, da du eine mehrdimensionale Integration hast.
Z.B.
double integrate(f3typ, double x, double y, double z, double max, int n);
Wobei n angibt, in welcher „Dimension“ integriert wird (und x,y oder z dabei als min gesetzt werden).

Auch wenn 2 Parameter im Moment der Integration „festgehalten“ werden, so braucht man sie dennoch. Mit globalen Variablen zu arbeiten halte ich für nicht sinnvoll. Oder man definiert sich geeignete Methoden eines Klassenobjects (knifflig).

Gruß Frank

[Hasenfu]

Hi Ray

Um ein Volumen-Integral einer Funktion f(x,y,z) zu berechnen, wird nach allen 3 Variablen einzeln integriert und dabei jeweils so getan, als wären die anderen Variablen konstant. Wir integrieren also z.B. zunächst nach x und erhalten

g(y,z) = int_x1^x2 f(x,y,z) dx

Dabei soll „int_x1^x2 …“ bedeuten: „Integral von x1 bis x2 …“ Danach integrierst du z.B. über y und erhälst:

h(z) = int_y1^y2 g(y,z) dy

Und am Ende integrierst du über z und bist fertig:

Ergebnis = int_z1^z2 h(z) dz

Die Variablenreihenfolge bei der Integration kannst du frei wählen.

So, jetzt sehe ich ein Problem bei deiner Integration. Wenn du nach der ersten Variablen integrierst, dann musst du programmiertechnisch deiner Funktion für y und z feste, bestimmte Werte mitgeben. Mathematisch musst du y und z allerdings als Parameter behandeln, die zwar einen festen, aber beliebigen Wert haben. Du müsstest daher eigentlich eine sog. „symbolische Integration“ durchführen, wenn dein Ergebnis korrekt sein soll.

Oft ist es so, dass die 3 Variablen x, y und z selbst wieder Funktionen einer Variablen, z.B. von der Zeit t sind:

x=x(t), y=y(t) und z=z(t)

In diesem Fall kannst du diese in die Funktion f(x,y,z) einsetzen und bekommst dann eine Funktion F(t), die nur von einer einzigen Variablen abhängt. Dieses F(t) kannst du dann nummerisch vom entsprechenden t1 bis zum entsprechenden t2 integrieren

cu Stefan.

[Anonym]

Danke!
Hallo!
Vielen Dank für die Antworten! Ich hab danach noch bei www.nr.com die pdf-Version von „Numerical Recipes“ gefunden und dieses Programm doch irgendwie hingekriegt. Vielleicht ist das Programm durch den Einsatz der static-Variablen nicht optimal geschrieben, es scheint aber zu funktionieren. Die Funktion int3d hat dann als Parameter eine andere Funktion func; Funktionen y_min(x), y_max(x), z_min(x,y), z_max(x,y), die die entsprechenden Integrationsgrenzen zurückgeben; x_min, x_max und die Genauigkeit n (je höher n, desto besser).
MfG, Ray.

static double x_saved,y_saved;
static double (*int_func)(double,double,double);
static double (*y_min)(double);
static double (*y_max)(double);
static double (*z_min)(double,double);
static double (*z_max)(double,double);
static int n_wert;

double int3d(double (*func)(double , double, double),double (*y_minNew)(double),double (*y_maxNew)(double),double (*z_minNew)(double,double),double (*z_maxNew)(double,double), double x_min, double x_max, int n)
{
double f1(double x);
int_func=func;
y_min = y_minNew;
y_max = y_maxNew;
z_min = z_minNew;
z_max = z_maxNew;
n_wert = n;
return integrate(f1,x_min,x_max,n);
}

double f1(double x)
{
double f2(double y);
x_saved=x;
return integrate(f2,y_min(x),y_max(x),n_wert);
}

double f2(double y)
{
double f3(double z);
y_saved=y;
return integrate(f3,z_min(x_saved,y),z_max(x_saved,y),n_wert);
}

double f3(double z)
{
return (*int_func)(x_saved,y_saved,z);
}