94 votes

comment initialiser un flotteur à sa valeur max/min ?

Comment coder en dur une valeur maximale ou minimale absolue pour un float ou un double ? Je veux rechercher le maximum/minimum d'un tableau en itérant simplement et en attrapant le plus grand.

Il existe également des infinis positifs et négatifs pour les flottants, dois-je les utiliser à la place ? Si oui, comment dois-je l'indiquer dans mon code ?

145voto

Yacoby Points 29771

Vous pouvez utiliser std::numeric_limits qui est défini dans <limits> pour trouver la valeur minimale ou maximale des types (pour autant qu'une spécialisation existe pour le type). Vous pouvez également l'utiliser pour retrouver l'infini (et mettre un - devant pour l'infini négatif).

#include <limits>

//...

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

Comme indiqué dans les commentaires, min() renvoie la valeur positive la plus faible possible. En d'autres termes, la valeur positive la plus proche de 0 qui peut être représentée. La valeur la plus basse possible est le négatif de la valeur maximale possible.

Il y a bien sûr le std::max_element et min_élément (définies dans <algorithm> ) qui peut être un meilleur choix pour trouver la plus grande ou la plus petite valeur dans un tableau.

40voto

MSN Points 30386

Vous pouvez soit utiliser -FLT_MAX (ou -DBL_MAX ) pour le nombre négatif de magnitude maximale et FLT_MAX (ou DBL_MAX ) pour le positif. Vous obtenez ainsi la gamme des valeurs possibles des flottants (ou des doubles).

Vous ne voulez probablement pas utiliser FLT_MIN ; il correspond au plus petit nombre positif d'amplitude pouvant être représenté par un flottant, et non à la valeur la plus négative pouvant être représentée par un flottant.

FLT_MIN et FLT_MAX correspondent à std::numeric_limits<float>::min() et std::numeric_limits<float>::max() .

17voto

Jerry Coffin Points 237758

Il n'y a pas vraiment besoin d'initialiser au plus petit/grand possible pour trouver le plus petit/grand dans le tableau :

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

Ou, si vous le faites plus d'une fois :

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

L'inconvénient de fournir un exemple de code - je vois que d'autres ont déjà suggéré la même idée.

Notez que, bien que la norme dispose d'un min_element et d'un max_element, leur utilisation nécessiterait un double balayage des données, ce qui pourrait poser problème si le tableau est de grande taille.

Edit : Aborder le problème de la recherche de la plus petite valeur non nulle dans un tableau de non signés : observez que les valeurs non signées "s'enroulent" lorsqu'elles atteignent un extrême. Pour trouver la plus petite valeur non nulle, nous pouvons soustraire un de chaque valeur pour la comparaison. Toutes les valeurs nulles seront "enveloppées" jusqu'à la plus grande valeur possible pour le type, mais la valeur relation entre les autres valeurs seront conservées. Une fois que nous avons terminé, nous ajoutons évidemment un à la valeur que nous avons trouvée.

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

Notez que ceci utilise toujours le premier élément pour la valeur initiale, mais nous n'avons toujours pas besoin de code pour les "cas spéciaux" -- puisque le vecteur s'enroulera autour de la plus grande valeur possible, toute valeur non nulle sera comparée comme étant plus petite. Le résultat sera la plus petite valeur non nulle, ou 0 si et seulement si le vecteur ne contient aucune valeur non nulle.

5voto

Bill Points 7824

Pour trouver manuellement le minimum d'un tableau, vous n'avez pas besoin de connaître la valeur minimale d'un flottant :

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

Et un code similaire pour la valeur maximale.

4voto

Puis-je suggérer que vous initialisiez vos variables "max et min jusqu'à présent" non pas à l'infini, mais au premier nombre du tableau ?

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X