jak zainicjować wartość zmiennoprzecinkową do wartości maksymalnej / minimalnej?

Jak zakodować bezwzględną wartość maksymalną lub minimalną dla liczby zmiennoprzecinkowej lub podwójnej? Chcę wyszukać maks / min tablicy, po prostu przechodząc przez iterację i przechwytując największą.

Istnieje również dodatnia i ujemna nieskończoność dla pływaków, czy powinienem ich użyć zamiast tego? Jeśli tak, jak mam to oznaczyć w moim kodzie?

Możesz użyć tego, std::numeric_limitsktóry jest zdefiniowany w, <limits>aby znaleźć minimalną lub maksymalną wartość typów (o ile istnieje specjalizacja dla typu). Możesz także użyć go do odzyskania nieskończoności (i wstaw -przed siebie ujemną nieskończoność).

#include <limits>

//...

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

Jak zauważono w komentarzach, min()zwraca najniższą możliwą wartość dodatnią. Innymi słowy, wartość dodatnia najbliższa 0, którą można przedstawić. Najniższa możliwa wartość jest ujemną wartością maksymalnej możliwej wartości.

Istnieją oczywiście funkcje std::max_elementi min_element (zdefiniowane w <algorithm>), które mogą być lepszym wyborem do znalezienia największej lub najmniejszej wartości w tablicy.

Możesz użyć -FLT_MAX(lub -DBL_MAX) dla maksymalnej liczby ujemnej wielkości i FLT_MAX(lub DBL_MAX) dla wartości dodatniej. Daje to zakres możliwych wartości zmiennoprzecinkowych (lub podwójnych).

Prawdopodobnie nie chcesz używać FLT_MIN; odpowiada najmniejszej dodatniej liczbie wielkości, którą można przedstawić za pomocą liczby zmiennoprzecinkowej, a nie najbardziej ujemnej wartości reprezentowanej przez zmiennoprzecinkę.

FLT_MINi FLT_MAXodpowiadają std::numeric_limits<float>::min()i std::numeric_limits<float>::max().

Nie ma rzeczywistej potrzeby inicjalizacji do najmniejszej / największej możliwej wartości, aby znaleźć najmniejszą / największą w tablicy:

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];
}

Lub, jeśli robisz to więcej niż raz:

#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;
}

Wada podania przykładowego kodu - widzę, że inni już zasugerowali ten sam pomysł.

Zauważ, że chociaż standard ma elementy min_element i max_element, użycie ich wymagałoby dwukrotnego przeskanowania danych, co może być problemem, jeśli tablica jest w ogóle duża. Najnowsze standardy rozwiązały ten problem, dodając a std::minmax_element, co robi to samo, co find_extremapowyżej (znajduje zarówno minimum, jak i maksimum elementów w kolekcji w jednym przebiegu).

Edycja: Rozwiązanie problemu znalezienia najmniejszej niezerowej wartości w tablicy bez znaku: zauważ, że wartości bez znaku „zawijają się”, gdy osiągają ekstremum. Aby znaleźć najmniejszą wartość różną od zera, możemy odjąć po jednym dla porównania. Wszelkie wartości zerowe zostaną „zawinięte” do największej możliwej wartości dla typu, ale relacje między innymi wartościami zostaną zachowane. Po zakończeniu oczywiście dodajemy jeden z powrotem do znalezionej wartości.

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;
}

Zauważ, że nadal używa pierwszego elementu jako wartości początkowej, ale nadal nie potrzebujemy żadnego kodu „specjalnego przypadku” - ponieważ będzie on zawijany do największej możliwej wartości, każda wartość niezerowa zostanie porównana jako mniejsza. Wynikiem będzie najmniejsza wartość niezerowa lub 0 wtedy i tylko wtedy, gdy wektor nie zawiera wartości niezerowych.

Aby ręcznie znaleźć minimum tablicy, nie musisz znać minimalnej wartości float:

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

I podobny kod dla maksymalnej wartości.

Czy mogę zasugerować, abyś zainicjował swoje zmienne „max i min do tej pory” nie do nieskończoności, ale do pierwszej liczby w tablicy?