Float ungenauigkeit bei iir Filter unterschiede visual studio und CC Studio von TI

Hallo,
Ich arbeite testweise mit dem Visual Studio 2005

Ich habe folgenden 10 poligen IIR Filter mit 2 Koeffizienten.

int main()

{
	float koef1=0.92; //filter koeffizient 1
	float koef2=1-0.92; //Filter koeffizient 2

	//zwischenspeicher
	static float fa_wert1=0;
	static float fa_wert2=0;
	static float fa_wert3=0;
	static float fa_wert4=0;
	static float fa_wert5=0;
	static float fa_wert6=0;
	static float fa_wert7=0;
	static float fa_wert8=0;
	static float fa_wert9=0;
	static float fa_wert10=0;

	long e_wert=100000000; //eingagnswert
	long fa_erg=0;  //ergebnis

	for(;;)
	{
		fa_wert1 = koef1 * fa_wert1 + koef2 * e_wert;
		fa_wert2 = koef1 * fa_wert2 + koef2 * fa_wert1;
		fa_wert3 = koef1 * fa_wert3 + koef2 * fa_wert2;
		fa_wert4 = koef1 * fa_wert4 + koef2 * fa_wert3;
		fa_wert5 = koef1 * fa_wert5 + koef2 * fa_wert4;
		fa_wert6 = koef1 * fa_wert6 + koef2 * fa_wert5;
		fa_wert7 = koef1 * fa_wert7 + koef2 * fa_wert6;
		fa_wert8 = koef1 * fa_wert8 + koef2 * fa_wert7;
		fa_wert9 = koef1 * fa_wert9 + koef2 * fa_wert8;
		fa_wert10 = koef1 * fa_wert10 + koef2 * fa_wert9;
		fa_erg = (long)fa_wert10;
		printf("e=%d\n",fa_erg);
	}
}

Wenn ich nun als Eingangswert fest immer 100 000 000 nehme kommt das Ergebnis nie an 100 Millionen ran sondern bleibt fest bei 99 999 760. Ich denke das liegt an der Ungenauigkeit von Float.

Frage 1 kann mir hierzu jemand mehr sagen?

Wenn ich dasselbe mit dem CC-Studio und einem DSP von TI (TMS320f2812) mache, erhalte ich nie mehr als 99 999 048

Diese Ungenauigkeit ist mir einfach zu groß. Laut Datenblatt arbeitet der TI Prozessor nach IEEE 32 Bit

Frage 2 Ich denke Visual Studio doch sicher auch oder?

Frage 3 Warum dann die großen Unterschiede?

Frage 4 kann ich die Ungenauigkeit durch kompiler einstellungen verringern oder bleibt mir nur der weg über „long double“ was aber einfach viel zu lange dauert bis er die Rechnung gemacht hat.

Vielen dank für eure Antworten

Tachyon

Deine Ausgangsposition ist bereits mist. IEEE 754 32-Bit Floats haben 23 Bit für die Mantisse und nochmal 8 Bit für den Exponenten. Durch die Wahl Deines gigantisch großen Einganswertes in Verbindung mit mit dem Algo und den Koeffizienten bleibt da nur noch eine rumzappelnde Nachkommastelle übrig. Deine Dynamik ist auch bei Gleitkammazahlen begrenzt. Darüber solltest Du Dir im Klaren sein. Lege den Input auf einen vernünftigen Arbeitspunkt, dann klappt das auch, mit dem Filtern.

oder nimm

double

als typ, der ist genauer

Tachyon schrieb:

Lege den Input auf einen vernünftigen Arbeitspunkt, dann klappt das auch, mit dem Filtern.

Ich bezweifle, dass ein anderer Arbeitspunkt da wesentlich besser ist.

Ich frage mich was ihr erwartet. Wie groß ist denn der Fehler der da gemacht wird? Das ist doch lächerlich...

der Eingang kommt von einem 20 bit wandler das heißt ich habe eben nunmal werte bis zu ca. ner Million. Runterteilen möchte ich den eingangswert ja auch nicht (Informationsverlust) und da long durch den Algo ja zu klein ist bleibt mir ja nur noch die Gleitkommatypen. Das ist das problem....

Aber warum bringt mir hier jeder Rechner ein anderes Ergebniss float ist ja durch IEEE 754 32-Bit festgelegt, dann müsste ich doch überall das gleiche ergebniss erhalten.

'float' ist immer übelst ungenau. hat der DSP 'ne floating point unit, die mit doubles rechnen kann? dann nimm 'double'. hat er's nicht, dann könntest du vielleicht den filter umbauen, dass er mit fixed-points rechnet. das kann aber 'ne ziemliche fummelei werden. schau doch erstmal, welche rechenfeatures der DSP bereitstellt. vielleicht bietet der hersteller auch 'ne library an für schnelle und präzise berechnungen.

ok der TI DSP hat double aber das hat wie float IEEE 32 BIT. Somit ist das in diesem Fall das gleiche. Was er anbietet ist long double IEEE 64 Bit aber das braucht zum rechnen einfach viel zu lange.

Die Algo in fix koma umzustellen wird schwierig da bei long (32 bit) bei ca 4,2 Milliarden ende ist und durch den Algo die schnell erreicht sind.

bleibt also noch long long was sicher wieder net so schnell ist.

JA mein Ti biete mir ne mathe Bibliothek an deren maximum liegt aber bei 1ner Milliarte also weniger wie long.

ok ich merke schnell grosse genauigkeit und eine grosse bandbreite geht halt net...

aber warum rechnen manche Rechner (hab verschiedene Probiert z.B visual studio am pc halt) genauer imd andere nicht so genau.
nach IEEE 754 32 Bit müssten doch alle genau gleich rechnen...

Tachyon

Irgendwie habe ich das Gefühl, dass Du versuchst, die 20 Bit, die Dir Dein A/D-Wandler liefert, direkt so zu benutzen. Das ist doch irgendwie Quark.
Der Wandler wird doch irgendeinen Spannungshub haben. Entweder, Du normierst Deine Einfangswerte auf den Spannungshub, und rechnest mit den normierten Werten, oder Du betreibst Integer-Arithmetik.
Die 20 Bit Integers mal eben so direkt und unreflektiert in ein Floating-Point IIR zu schicken ist Blödsinn.