Diskussion:Gleitender Mittelwert in C - Versionsgeschichte

RedBaron am 29. Dezember 2009 um 09:58 Uhr

2009-12-29T09:58:13Z

2009-12-29T09:57:13Z

2009-12-29T09:56:34Z

2009-12-29T09:55:53Z

2009-12-29T09:55:15Z

2009-12-29T09:54:35Z

2009-12-29T09:53:54Z

2009-12-29T09:53:07Z

2009-12-29T09:52:51Z

2009-12-29T09:52:30Z

@@ Zeile 15: / Zeile 15: @@
 Also (in C)<br/>
 <code>
-a= 1/2:     y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br/>
+a= 1/2:     y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder: y = (y + x) >> 1 (ist genauer)<br/>
-a= 1/4:     y = (y >> 2) * 3 + (x >> 2)                        y = ((y * 3) >> 2) + (x >> 2)
+a= 1/4:     y = (y >> 2) * 3 + (x >> 2)   oder:                 y = ((y * 3) >> 2) + (x >> 2)

@@ Zeile 2: / Zeile 2: @@
 <code>
+<br/>
-y(t) = a * (y(t-1)) + (1-a) * x
+y(t) = a * (y(t-1)) + (1-a) * x<br/>
+<br/>
-y(t): neuer Schätzwert
+y(t): neuer Schätzwert<br/>
-y(t-1): alter Schätzwert
+y(t-1): alter Schätzwert<br/>
-x: neuer Messwert
+x: neuer Messwert<br/>
-a: Gewicht im Bereich 0..1
+a: Gewicht im Bereich 0..1<br/>
+<br/>
 </code>
 Bei z.B. a=1/2 werden neuer Messwert und alter Schätzwert gleich Gewichtet. Bei 2/3 wird mehr Gewicht auf den alten Schätzwerr gelegt, d.h. die Werte ändern sich bei Spüngen langsamer. Zu empfehlen sind Zweierpotenzen. Dann kann man mit Shift-Operationen auskommen und auf Fließkomma-Verarbeitungen verzichten. Die ist auf µCs äußerst ineffizient.

@@ Zeile 1: / Zeile 1: @@
 Ich empfehle eine Algorithmus, der in etwa einer exponentiellen Glättung entspricht. Dies Methode ist deutlich einfacher zu implementieren und liefert bereits ab dem ersten Messwert sinnvolle Ergebnisse. Nachteil/Vorteil (je nach Applikation) reagiert schneller auf Änderungen.
 y(t) = a * (y(t-1)) + (1-a) * x
@@ Zeile 8: / Zeile 10: @@
 a: Gewicht im Bereich 0..1
 Bei z.B. a=1/2 werden neuer Messwert und alter Schätzwert gleich Gewichtet. Bei 2/3 wird mehr Gewicht auf den alten Schätzwerr gelegt, d.h. die Werte ändern sich bei Spüngen langsamer. Zu empfehlen sind Zweierpotenzen. Dann kann man mit Shift-Operationen auskommen und auf Fließkomma-Verarbeitungen verzichten. Die ist auf µCs äußerst ineffizient.

@@ Zeile 12: / Zeile 12: @@
 Also (in C)<br/>
 <code>
-a= 1/2:     y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
+a= 1/2:     y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br/>
 a= 1/4:     y = (y >> 2) * 3 + (x >> 2)                        y = ((y * 3) >> 2) + (x >> 2)
-</code>
 a = 1/2<br\>
 t   0  1  2  3  4  5  6  7  8  9<br\>
 x   0  0 50 50 50 50 50 50 40 50<br\>
 y   0  0 25 37 43 46 48 49 45 47<br\>
-−
 Du siehst: Extrem effizient. Ein Variable (y) eine Programmzeile. Wenn man höhere Genauigkeit möchte, kann man Festkommazahlen verwenden.

@@ Zeile 10: / Zeile 10: @@
 Bei z.B. a=1/2 werden neuer Messwert und alter Schätzwert gleich Gewichtet. Bei 2/3 wird mehr Gewicht auf den alten Schätzwerr gelegt, d.h. die Werte ändern sich bei Spüngen langsamer. Zu empfehlen sind Zweierpotenzen. Dann kann man mit Shift-Operationen auskommen und auf Fließkomma-Verarbeitungen verzichten. Die ist auf µCs äußerst ineffizient.
-Also (in C)<br\>
+Also (in C)<br/>
 <code>
 a= 1/2:     y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
 a= 1/4:     y = (y >> 2) * 3 + (x >> 2)                        y = ((y * 3) >> 2) + (x >> 2)
-<\code>
+</code>
 a = 1/2<br\>