Ich hab das SIMPSON Verfahren zur numerischen Annäherung eines Integrals in C++ versucht zu programmieren.
Ein vergleichbares Programm hatte ich bereits auf meinem Taschenrechner(TI Voyage 200) programmiert. Dieser hat eine Genauigkeit von 12 Stellen, welche alerdings nicht ausgeschöpft werden können, da das Teil einfach zu langsam rechnet.
Nun wollte ich das Programm halt portieren und um eine höher Genauigkeit zu erzielen.

Zunächst mal der wichtige Teil von Quellcode:

#include<iostream.h>
#include<math.h>
#include"Numerik.h" //Da ist die Klasse SIMPSON drin

double SIMPSON::f(double x){return exp(x);} //f(x) = e^x

double SIMPSON::Berechne(double a, double b, int n)	//Hauptfunktion(a = Untere Grenze, b = Obere Grenze, n = Zerlegungszahl) 
{
	int i=0;	//Laufvariable
	double su=0,sg=0,x=0;	//Hilfsvariablen

	if(n%2==1){ cout << "n muss durch 2 teilbar sein!" << endl; return 0;}
	if(f==0){ cout << "ERROR: Funktion f nicht definiert!" << endl; return 0;}

	h = (b-a)/n;	//Schrittweite festlegen

	for(i=1;i<n-1;i++)
	{
		x = a+i*h;	//x Wert aus Startpunkt a und i*Schrittweite berechnen
		if(i%2==0)	sg += f(x);		//Fktwerte mit geradem Index i in sg summieren
		else		su += f(x);		//Fktwerte mit ungerad. Index i in su summieren
	}

	return (f(a) + 4*su + 2*sg + f(b))*h/3;	//Rückgabe des Endwertes mit SIMPSON Gewichtung
}

double SIMPSON::Fehler_Ergebnis(double a, double b, int n)
{
	return ((Berechne(a,b,n) - Berechne(a,b,n/2))/15);	//SIMPSON Fehlerformel für Delta n
}

Mein Problem ist die Zerlegungszahl n. Je größer sie ist desto genauer wird das Ergebnis. Allerdings steigt dabei auch gleichzeitig der Rechenaufwand.
Das Phänomen was ich nun beobachten konnte ist, dass wenn ich z.B auf meinem TI ∫e^x dx von 0 bis 1 berechne, ich bereits mit n = 40 eine Genauigkeit auf 9 Stellen erhalte. Um eine Vergleichbare Genauigkeit mit meinem C++ Programm zu erhalten muss ich etwa n = 10000000 setzen.
Die beiden Programme unterscheiden sich wirklich nur in der Programmiersprache nicht in der Funktionsweise.
Im Endeffekt funktionier das Programm ja auch. Allerdings nicht mit der Effizient die ich mir erhofft hatte.

Sieht jemand vlt den Fehler wodurch ich die Genauigkeit verliere. Mein Ziel war es eigentlich eine Ganuigkeit von 12 Stellen zu erreichen. Sollte doch mit den doubles kein Problem geben oder? Ansonsten bin ich für alle Kritiken und Vorschläge offen!

Dankeschön!

for(i=1;i<=n-1;i++)

Deshalb benötigte man auch dieses hohe n, da der am Ende immer einen Summanden weggelassen hat, was das Ergebnis natürlich verfälschte.
Jetzt funktioniert es wie es soll.
Sorry für den überflüssigen Post hier

/closed