Minimalwertspeicher für Messwerte

[Dirk F. (dirkf)]

Hallo,
ich möchte eine Logik programmieren, die aus einem Datenstrom mit 
Messwerten  die beiden kleinsten Werte speichert.
Wenn der kleinste Messwert zwei mal im Datenstrom kommt, dann sollen 
beide Speicher diesen Wert erhalten:

Würde das so gehen ?

Init:   I_d_min1[i]  = 100;     // Minimalwertspeicher initialisieren
        I_d_min2[i]  = 100;
     
        
Loop:        
        // I_d[i] = aktueller Messwert
        // I_d_min1[i]    Minimalwertspeicher 1
        // I_d_min2[i]    Minimalwertspeicher 2
        
        // Wenn aktueller Wert kleiner als die beiden Speicher ist
        if ((I_d[i] < I_d_min1[i]) && (I_d[i] < I_d_min2[i]) )  
            {
            // Wenn Speicher1 > Speicher 2 
            if (I_d_min1[i] > I_d_min2[i])
               //dann Speicher 1 überschreiben 
               I_d_min1[i] = I_d[i];
            else
               //sonst Speicher 2 überschreiben 
               I_d_min2[i] = I_d[i];   
            }
        
        else 
            {
             // Wenn aktueller Wert kleiner Speicher 1 und größer Speicher2
            if ((I_d[i] < I_d_min1[i]) && (I_d[i] > I_d_min2[i]) )  
                // dann Speicher 1 überschreiben
                 I_d_min1[i] = I_d[i]; 
            // Wenn aktueller Wert kleiner Speicher 2 und größer Speicher1
            if ((I_d[i] < I_d_min2[i]) && (I_d[i] > I_d_min1[i]) )  
                // dann Speicher 2 überschreiben
                 I_d_min2[i] = I_d[i]; 
            }

[Rainer W. (rawi)]

Dirk F. schrieb:
> Würde das so gehen ?

Nimm einen Debugger und guck es dir an, indem du alle möglichen Fälle 
durchspielst.
Zwei Vergleichsoperationen sollte reichen: Vergleich des neuen Wertes 
mit Min2 und danach Vergleich Min2 mit Min1.

[Norbert (der_norbert)]

Dirk F. schrieb:
> ich möchte eine Logik programmieren, die aus einem Datenstrom mit
> Messwerten  die beiden kleinsten Werte speichert.

Wenn man sich seine Wünsche und Anforderungen in reiner Textform 
aufschreibt und sie durchdenkt, dann wird sehr vieles sehr viel 
schneller klar.

Erst wenn man Klarheit erlangt hat, kommt der Programmier-Editor zum 
Einsatz.

[Rainer W. (rawi)]

Norbert schrieb:
> Wenn man sich seine Wünsche und Anforderungen in reiner Textform
> aufschreibt ...

Ja, nee. Die Textaufgabe muss man dann als erstes wieder als 
übersichtliche logische Struktur darstellen, z.B. in Form eines 
Nassi-Shneiderman-Diagramms.
Dort sieht man relativ klar, ob man alle Fälle abgedeckt hat und kann 
das dann ziemlich direkt in Programmcode umsetzen. Bevor man sich an den 
eigentlichen Programmcode macht, sollte man die Testszenarien klar 
formulieren, so dass man vollständige Tests für den Code vorliegen hat, 
bevor die erste Programmzeile für das eigentliche Programm im Editor 
landet.

[Norbert (der_norbert)]

Rainer W. schrieb:
> z.B. in Form eines
> Nassi-Shneiderman-Diagramms.
> Dort sieht man relativ klar, ob man alle Fälle abgedeckt hat und kann
> das dann ziemlich direkt in Programmcode umsetzen.

Finde ich gut.
Insbesondere für so komplexe Aufgaben wie die Ermittlung zweier MIN 
Werte. ;-)

[Rainer W. (rawi)]

Norbert schrieb:
> Insbesondere für so komplexe Aufgaben wie die Ermittlung zweier MIN
> Werte. ;-)

Wenn ich den Umfang des oben gezeigten Programmcodes sehe, sind solche 
grundlegenden Überlegungen, egal wie einfach das Problem ist, hier nicht 
fehl am Platz und offenbaren dann schnell mögliche Vereinfachungen.

[Helmut H. (helmuth)]

min1=10, min2=12
I_d[i] ist 10
erwartet: min2 wird 10
laut obigem Code: min2 wird nicht geändert.

[Bruno V. (bruno_v)]

In anderen Worten: Deine Lösung ist falsch und zu komplex. Zudem in 
einer unbekannten Pseudosprache, die vielleicht Sinn macht, in z.B. C 
aber nicht. Pseudocode ist zwar OK, aber x[i] sollte die Bedeutung eines 
Arrays haben, während spezielle Werte z.B. x_min heißen sollten.

Der übliche Weg wäre für mich: Ein Papier und ein paar Kritzeleien. Je 
weniger vertraut Du damit bist, umso mehr echte 
Worte/Gleichungen/Pseudocode sind notwendig.

[Norbert (der_norbert)]

Eine schöne Aufgabe für eine Ruby Goldberg Min Min Machine…

#!python
#!/usr/bin/python3
# vim: fileencoding=utf-8: ts=4: sw=4: expandtab:

def RGMMM():    # Ruby Goldberg Min Min Machine
    min1,min2 = 100,100
    def inner(x):
        nonlocal min1,min2
        if x < min1:
            min1 = x
            if min1 < min2:
                min1,min2 = min2,min1
        return min2,min1
    return inner

rgmmm = RGMMM()
for x in range(5,-1,-1):
    print(rgmmm(x))

rgmmm = RGMMM()
for x in range(3):
    print(rgmmm(x))

rgmmm = RGMMM()
print(rgmmm(9))
print(rgmmm(6))
print(rgmmm(7))
print(rgmmm(8))
print(rgmmm(2))
print(rgmmm(2))

[Dirk F. (dirkf)]

Hallo,
danke für die vielen Hinweise, besonders von Rainer W.
Hier die vereinfachte Version::

    void Minimalwerte (int *aktuell, int *Speicher1, int *Speicher2 )
        {
        // Minimalwertspeicher zwei tiefsen Werte
        // Speicher1 = tiefster Wert
        // Speicher2 = zweit tiefster Wert
        
        if (aktuell < Speicher1)  
            {
            Speicher1 = aktuell;
            return;
            }
 
        if (aktuell < Speicher2  && aktuell >= Speicher1  )  
            {
            Speicher2 = aktuell;
            }
        }  // End function

[Bruno V. (bruno_v)]

es fehlt weiterhin speicher2=speicher1 für einen neuen Spitzenwert

[Rainer W. (rawi)]

Dirk F. schrieb:
> Hier die vereinfachte Version::
> ...
>
> if (aktuell < Speicher1)
>   {...
>    return;}
> ...
> if (aktuell < Speicher2  && aktuell >= Speicher1  )

Du vergleichst immer noch ein Mal zu viel.
Wenn beim ersten Vergleich die Bedingung nicht erfüllt ist, d.h.

aktuell >= Speicher1

 ist, musst du das beim zweiten Vergleich nicht noch einmal prüfen.

[Bruno V. (bruno_v)]

void mw (int x, int *m1, int *m2 )
{
    if (x < *m2)  
    {
        if(x < *m1) {*m2 = *m1; m1 = x;}
        else        {*m2 =           x;}
    }
}

Zum Verständnis sind wie in der Mathematik kurze Namen besser. Im 
späteren Code reduzieren längere Namen die Beschreibung.

[Dirk F. (dirkf)]

Danke Bruno und Rainer.

Diese Version ist getestet und läuft:

    void Minimalwerte (int *aktuell, int *Speicher1, int *Speicher2 )
        {
        // Minimalwertspeicher zwei tiefsen Werte
        // Speicher1 = tiefster Wert
        // Speicher2 = zweit tiefster Wert
        
        if (*aktuell < *Speicher1)  
            {
            *Speicher2 = *Speicher1;
            *Speicher1 = *aktuell;
            return;
            }
 
        if (*aktuell < *Speicher2  && *aktuell >= *Speicher1  )  
            {
            *Speicher2 = *aktuell;
            }
        }  // End function

[Rainer W. (rawi)]

Dirk F. schrieb:
> Diese Version ist getestet und läuft:

Auch hier hast du die Vergleichsoperation zwischen dem aktuell Wert und 
dem in Speicher1 überflüssigerweise noch doppelt drin.

[Dirk F. (dirkf)]

Dirk F. schrieb:
> && *aktuell >= *Speicher1

Ja stimmt. Das kann entfallen.

Aber bei 200 MHz Prozessor und 2 MB Flash, 50 us Zykluszeit........... 
was solls....

[Rainer W. (rawi)]

Dirk F. schrieb:
> Aber bei 200 MHz Prozessor und 2 MB Flash, 50 us Zykluszeit...........
> was solls....

Welche Bedeutung solche Optimierung im Algorithmus hat, hängt immer 
davon ab, ob die Optimierung im Compiler solchen redundanten Code noch 
erkennen und rausschmeißen kann und welchen Anteil der Code an der 
Prozessorauslastung trägt. Wenn der zu 99% mit leeren Schleifen 
beschäftigt ist, spielt es natürlich keine Rolle. Dann ist es nur schade 
um die vergeudeten Resourcen.

Die Struktur deines Codes mit dem doppelten Ausgang aus der Funktion 
lässt diese Doppelabfrage sowieso nicht erkennen. Besser lesbar wäre, 
wenn die zweite Abfrage im else-Zweig der ersten stände und das 'return' 
nicht mitten drin.

[Falk B. (falk)]

Dirk F. schrieb:
>> && *aktuell >= *Speicher1
>
> Ja stimmt. Das kann entfallen.

Es MUSS entfallen, denn!

> Aber bei 200 MHz Prozessor und 2 MB Flash, 50 us Zykluszeit...........
> was solls....

Nein! Man läßt keinen sinnlosen, irreführend Code stehen! Erst recht 
nicht, wenn man WEIß, daß es so ist!

Google clean code

Strukturierte Programmierung auf Mikrocontrollern