Array glätten

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Array glätten

      Hallo,
      die Standard-Methode um ein Array zu glätten ist
      "MOVING AVERAGE FILTER IMPLEMENTED BY RECURSION", beschrieben z.B. hier:
      dspguide.com/ch15/5.htm
      Ein Basic-Programm für 5Pkte-Glättung (würde gerne mehr nehmen, aber Zeit...) ist in Tabelle 15.2 gezeigt, das fast ohne Änderung in Bascom implementiert werden kann.:
      Glätten.bas
      Das ist sehr effektiv programmiert, weil für jeden Schritt nur der letzte Wert eines Glättungsintervalls herausgenommen wird und nur erste Wert des Intervalls ersetzt werden muss.
      Die Glättung (ich nehme 5Pkte zur Zeit) trotzdem Einiges an Zeit.
      Da springt doch jeder Assembler-Programmierer vor Freude in die Luft!
      Das Intervall muss ungerade lang sein, aber wenn ich die 5 durch 4 oder 8 ersetze, sieht man kaum einen Unterschied, alles ist Statistik...
      Meine Arrays fangen bislang bei 1 an, was etwas unpraktisch ist (wegen der blöden 256), aber ich habe wegen möglicher anderer Interferenzen noch nicht geagt, auf Null umzustellen.
      Hätte jemand Spass daran (will ja keinen Namen nennen)?
      Gruss, elektron
    • Aber warum so kompliziert?
      Am Anfang nimmt man der ersten Wert x4 addiert den 2. Wert und teilt durch 5 (zB.) Für den nächsten Mittelwert nimmt man das Ergebnis, zieht 1/5 ab, addiert den nächsten Wert und teilt durch 5 und so weiter, das läuft bei mir unter gleitenden Mittelwert, oder hab' ich mir da was anderes ausgedacht?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • "Aber warum so kompliziert?"
      Frag' mal die Statistiker...Ich bin keiner, aber kompliziert ist was anderes.
      Zum Testen kannst Du ja mal eine Streuung simulieren und sehen, ob es auf den (oder ein anderen?) Mittelwert hinausläuft.
      Irgendwas kommt immer heraus....
      Im MCS-Forum gibt's auch den gleitenden Mittelwert von Per Svensson. Mittelt tatsächlich, aber nicht auf den Mittelwert, wie ein Benutzer so zeigte. Per schwieg sich leider dazu aus.
    • Michael schrieb:

      Ich kenne die Mittelwertbildung von Svensson nicht, aber es gibt in der Tat verschiedene Möglichkeiten.
      Da ist z.B. die Methode von Tschoeatsch, in der man nur einen Teil des arrays neu berechnet und dann gibt es natürlich noch die klassische der Mittelung aller letzten x Werte.
      Was natürlich zu verschiedenen Ergebnissen führt. Wenn man beispielsweise eine Reihe von gleichen Werten hat und nur einen einzigen 'Ausreißer', dann führt das bei meiner beschriebenen Methode mit 5 Elementen zu einem Sprung beim Ausreißer, der im weiteren Verlauf gleich beim nächsten Wert schon wieder Richtung Durchschnittswert vor dem Ausreißer geht, aber wenn man genau ist, nie mehr auf den Wert vor dem Ausreißer zurück geht. Bei der Mittelung der letzten 5 Werte führt so ein Ausreißer zu einer Änderung Richtung Ausreißer, die über 5 Werte konstant bleibt und danach wieder genau den Wert vor dem Ausreißer einnimmt. Hier wird der Ausreißer 'vergessen', bei mir nicht.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • tschoeatsch schrieb:

      zieht 1/5 ab, addiert den nächsten Wert und teilt durch 5
      Wäre es nicht rechentechnisch schneller statt 5 Werte 4 oder 8 zu nehmen und statt zu dividieren zu shiften? Es ging bei dem Problem ja auch um Zeit und (denke ich) um Rechenleistung zu verringern.

      Gruß Christian
      Wenn das die Lösung ist, möchte ich mein Problem wieder haben.
    • Bei single-Variablen muss man schon wissen, wo man shiften kann, dass eine ordentliche Division raus kommt. Aber ja, vielleicht wird's noch einen Tuck schneller.
      Hier sieht man, wie eine single aufgebaut ist h-schmidt.net/FloatConverter/IEEE754de.html
      (in diesem link hab' ich grad gelernt, dass es eine positive und negative 0 gibt)
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von tschoeatsch ()

    • six1 schrieb:

      um dich zu beruhigen: Es gibt gar keine Null. Das stellt man sich so vor, weil man "etwas" zwischen -1 und +1 vermutet...
      Viele scheinen aber eine 'schwarze Null' zu kennen und reden auch viel davon. Meinen die dann die Schiedsrichter oder was?
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • tschoeatsch schrieb:

      Bei der Mittelung der letzten 5 Werte führt so ein Ausreißer zu einer Änderung Richtung Ausreißer, die über 5 Werte konstant bleibt und danach wieder genau den Wert vor dem Ausreißer einnimmt. Hier wird der Ausreißer 'vergessen', bei mir nicht.
      ja, aber bei einem Sprung ändern sich die Werte langsam (bei x Werten in X Schritten) und linear dem neuen Wert an. Bei der anderen Methode sind die Änderungen weicher aber mit der Gefahr, dass kleine Änderungen nicht wirksam werden (bei Festkomma-Werten)

      tschoeatsch schrieb:

      Viele scheinen aber eine 'schwarze Null' zu kennen und reden auch viel davon. Meinen die dann die Schiedsrichter oder was?
      damit sind keine mathematischen nullen gemeint, die gibt es in allen politischen Färbungen ;)
    • ceperiga schrieb:

      Wäre es nicht rechentechnisch schneller statt 5 Werte 4 oder 8 zu nehmen und statt zu dividieren zu shiften? Es ging bei dem Problem ja auch um Zeit und (denke ich) um Rechenleistung zu verringern.
      Zunächst mal: Die Diskussion ist wohl etwas aus dem Ruder gelaufen.
      Also, bevor Ihr postet, lest doch mal den von mir velinkten Artikel wenigstens kursorisch durch. Da geht's auch um verschiedene Methoden, die unterschiedlich auf Signaländerungen reagieren.
      Das dort zum Schluss vorgestellte Programm setzt die Überlegung auf der vorangehenden Seite (283) in den Algorithmus um. Ich glaub' nicht, dass es etwas effektiveres gibt. Nur wegen der Bascom-Einzeiler-Beschränkung sieht meine gepostete Routine etwas komplizierter aus als "nötig". Vielleicht hatte ja Tschöatsch das Rad neu erfunden.

      Wie dem auch sei,
      Ich bin nun einen Schritt weiter gekommen. Ich glaube, MWS war's, der hatte mir mal im alten Forum eine ASM-Routine zum Array-Summieren eingestellt.
      Dann bräuchte ich wohl hier nicht weiter nach ASM-Routine zu fragen (bin mit dem Testen noch nicht fertig).
      @Ceperiga: Darf ich die hier posten, obwohl ich die genaue Quelle z.Zt. nicht finde?

      Zur obigsten Frage: für diese Methode braucht man ungerade Anzahl von Elementen, wenn man tatsächlich den Mittelwert haben will, brauche ich aber nicht, ein Vielfaches genügt, da ich sowieso zur Darstellung auf GLCD skalieren muss. Daher könnte man die Division zunächst ganz weglassen (falls die Werte noch in den Wertebereich des Y-Arrays passen (hier integer) und dann später GLCD-mäßig Skalieren. Array-Shiften hatte ja galahat gerade dankenswerterweise beigesteuert.

      Gruss, elektron
    • Wenn es um Nachlaufsteuerung geht, dann habe ich gute Erfahrungen mit einer
      proztualen Regelung gemacht.
      Zum Beispiel mit Stabilisierung von Roll und Pitch bei RC-Flugmodellen und
      Drehzahlregelung bei Buerstenlosen E-Motoren. Je nach Abweichung vom Sollwert
      nehme ich einen prozentualen wert des Unterschiedes zur Korrektur.
      Abhaengig von der Wiederholzeit und Traegheit der zu steuernden Einheit.
      Somit wird auch ein oszillieren verhindert und man kann den Gain individuell
      einstellen. Das hat fuer meine Anwendungen immer gut funktioniert.
      So dreht eine Servo nicht mit maximaler Geschwindigkeit wenn es nahe des Zielpunktes ist
      und Uebersteuerung wird verhindert.
      Fuzzy Logik Lizenz war mir zu teuer.
      Nur als Anregung gedacht.
      Gruss
      Hubert