Hey,
ich habe folgenden Algorithmus um das bestimmte Integral numerisch zu berechnen:
double c = (a + b) / 2.0;
double h3 = abs(b - a) / 6.0;
double result = h3 * (f(a) + 4.0 * f(c) + f(b));
return result;
}
double integrate(Function &f, double a, double b) {
double temp = 0;
double temp2 = 0;
double h = 1;
int i = 0;
int k = 0;
do{
k++;
for (double i = a; i <=b; i += h) {
if (i + h > b) {
temp += simpson(f, i, b);
} else {
temp += simpson(f, i, i + h);
}
}
for (double i = a; i <=b; i += h/1.1) {
if (i +h > b) {
temp2 += simpson(f, i, b/1.1);
} else {
temp2 += simpson(f, i, i + h/1.1);
}
}
h/=10;
printf("%d ", k);
printf("Differenz: %f " ,abs(temp-temp2));
fflush(stdout);
}while(abs(temp-temp2)>EPSN && k<=I_MAX);
printf("Durchläufe: %d ", i);
return temp;
}```
h wird im Moment immer durch 10 geteilt. Vllt ist das etwas zu krass aber gleiche Probleme bestehen mit dem Faktor 2 etc.
Also dadurch, dass das h kleiner wird, müsste das zusammengesetzte Integral mit der Simpsonregel ja immer genauer werden.
Allerdings passiert eher das Gegenteil.
Wenn ich damit das Integral von sin mit den Grenzen 0 und 5 ausrechnen will entwickeln sich die "Differenzen" so:
`1 Differenz: 0.449850 2 Differenz: 0.273352 3 Differenz: 1.155551 4 Differenz: 1.603636 5 Differenz: 2.053291 6 Differenz: 2.503103 `
Danach ist h einfach schon zu klein und es dauert ewig.
Werden praktisch immer größer. Wenn man die Fläche in Rechtecke einteilt und dann addiert, dann müssten sich für so kleine "h" ja die Anzahl dieser Rechtecke ja fast nicht mehr unterscheiden und der Grenzwert gegen einen festen Wert laufen.
Klappt leider für meinen Algorithmus nicht.
Vllt hat einer eine Idee, wie man es hinkriegt dass es genauer wird (anstatt genau das Gegenteil wie jetzt bei mir) und wie man frühzeitig abbrechen kann und nicht ewig läuft. Für kleines Abstände zwischen a und b kann man h ja vllt geschickter wählen also für a=5 und b=10.000 oder so.
Hoffe jemand kann mir da helfen :))
Grüße