Wie initialisiere ich einen Float auf seinen Max / Min-Wert?

Wie kann ich einen absoluten Maximal- oder Minimalwert für einen Float oder Double fest codieren? Ich möchte das Maximum / Min eines Arrays ermitteln, indem ich einfach das größte Array durchlaufe und abfange.

Es gibt auch positive und negative Unendlichkeiten für Schwimmer. Soll ich diese stattdessen verwenden? Wenn ja, wie bezeichne ich das in meinem Code?

Sie können std::numeric_limitsden in definierten <limits>Wert verwenden, um den minimalen oder maximalen Wert von Typen zu ermitteln (sofern für den Typ eine Spezialisierung vorhanden ist). Sie können es auch verwenden, um die Unendlichkeit abzurufen (und ein -Vorzeichen für die negative Unendlichkeit zu setzen).

#include <limits>

//...

std::numeric_limits<float>::max();
std::numeric_limits<float>::min();
std::numeric_limits<float>::infinity();

Wie in den Kommentaren angegeben, wird min()der niedrigstmögliche positive Wert zurückgegeben. Mit anderen Worten, der positive Wert, der 0 am nächsten kommt und dargestellt werden kann. Der niedrigstmögliche Wert ist das Negativ des maximal möglichen Werts.

Es gibt natürlich die std::max_elementFunktionen und min_element (definiert in <algorithm>), die eine bessere Wahl sein können, um den größten oder kleinsten Wert in einem Array zu finden.

Sie können entweder -FLT_MAX(oder -DBL_MAX) für die negative Zahl mit maximaler Größe und FLT_MAX(oder DBL_MAX) für positiv verwenden. Dies gibt Ihnen den Bereich möglicher Float- (oder Double-) Werte.

Sie möchten wahrscheinlich nicht verwenden FLT_MIN; Sie entspricht der kleinsten positiven Zahl, die mit einem Float dargestellt werden kann, nicht dem negativsten Wert, der mit einem Float dargestellt werden kann.

FLT_MINund FLT_MAXentsprechen std::numeric_limits<float>::min()und std::numeric_limits<float>::max().

Es ist nicht wirklich erforderlich, auf möglichst klein / groß zu initialisieren, um das kleinste / größte im Array zu finden:

double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
    if (array[i] < smallest)
        smallest = array[i];
    if (array[i] > largest0
        largest= array[i];
}

Oder wenn Sie es mehr als einmal tun:

#include <utility>

template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
    std::pair<typename iter::value_type, typename iter::value_type> ret;
    ret.first = ret.second = *begin;
    while (++begin != end) {
        if (*begin < ret.first)
           ret.first = *begin;
        if (*begin > ret.second)
           ret.second = *begin;
   }
   return ret;
}

Der Nachteil der Bereitstellung von Beispielcode - ich sehe, dass andere bereits die gleiche Idee vorgeschlagen haben.

Beachten Sie, dass der Standard zwar ein min_element und ein max_element enthält, für deren Verwendung jedoch ein zweimaliges Durchsuchen der Daten erforderlich ist. Dies kann ein Problem sein, wenn das Array überhaupt groß ist. Neuere Standards haben dies durch Hinzufügen eines a behoben std::minmax_element, das dasselbe wie find_extremaoben tut (finden Sie sowohl die minimalen als auch die maximalen Elemente in einer Sammlung in einem einzigen Durchgang).

Bearbeiten: Behebung des Problems, den kleinsten Wert ungleich Null in einem Array von vorzeichenlosen Werten zu finden: Beachten Sie, dass vorzeichenlose Werte "umlaufen", wenn sie ein Extrem erreichen. Um den kleinsten Wert ungleich Null zu finden, können wir für den Vergleich jeweils einen subtrahieren. Alle Nullwerte werden auf den größtmöglichen Wert für den Typ "umgebrochen", aber die Beziehung zwischen anderen Werten bleibt erhalten. Nachdem wir fertig sind, fügen wir dem gefundenen Wert offensichtlich einen hinzu.

unsigned int min_nonzero(std::vector<unsigned int> const &values) { 
    if (vector.size() == 0)
        return 0;
    unsigned int temp = values[0]-1;
    for (int i=1; i<values.size(); i++)
        if (values[i]-1 < temp)
            temp = values[i]-1;
    return temp+1;
}

Beachten Sie, dass hierfür immer noch das erste Element für den Anfangswert verwendet wird, wir jedoch keinen "Sonderfall" -Code benötigen. Da dieser Wert auf den größtmöglichen Wert umgebrochen wird, wird jeder Wert ungleich Null als kleiner verglichen. Das Ergebnis ist der kleinste Wert ungleich Null oder genau dann 0, wenn der Vektor keine Werte ungleich Null enthält.

Um das Minimum eines Arrays manuell zu ermitteln, müssen Sie den Mindestwert von float nicht kennen:

float myFloats[];
...
float minimum = myFloats[0];
for (int i = 0; i < myFloatsSize; ++i)
{
  if (myFloats[i] < minimum)
  {
    minimum = myFloats[i];
  }
}

Und ähnlicher Code für den Maximalwert.

Darf ich vorschlagen, dass Sie Ihre Variablen "max und min bisher" nicht auf unendlich, sondern auf die erste Zahl im Array initialisieren?