web-dev-qa-db-fra.com

Comment initialiser un float à sa valeur max / min?

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

Il existe également des infinis positifs et négatifs pour les flotteurs, devrais-je les utiliser à la place? Si oui, comment est-ce que je le note dans mon code?

c++primitive-types
90
Faken

Vous pouvez utiliser std::numeric_limits qui est défini dans <limits> Pour trouver la valeur minimale ou maximale des types (tant qu'une spécialisation existe pour le type). Vous pouvez également l'utiliser pour récupérer l'infini (et mettre un - Devant 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 basse possible. En d'autres termes, la valeur positive la plus proche de 0 pouvant ê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 les std::max_element et les fonctions min_element (définies dans <algorithm>) Qui peuvent constituer un meilleur choix pour trouver la valeur la plus grande ou la plus petite dans un tableau.

141
Yacoby

Vous pouvez soit utiliser -FLT_MAX (Ou -DBL_MAX) Pour le nombre négatif de magnitude maximale et FLT_MAX (Ou DBL_MAX) Pour des valeurs positives. Cela vous donne la plage de valeurs possibles (ou doubles) float.

Vous ne voulez probablement pas utiliser FLT_MIN; il correspond au plus petit nombre positif de magnitude pouvant être représenté avec un float, et non à la valeur la plus négative pouvant être représentée avec un float.

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

37
MSN

Il n'y a pas vraiment besoin d'initialiser au plus petit/plus grand possible pour trouver le plus petit/plus 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 comporte un min_element et un max_element, leur utilisation nécessiterait une double analyse des données, ce qui pourrait poser problème si le tableau est volumineux. Les normes récentes ont résolu ce problème en ajoutant un std::minmax_element, qui fait la même chose que le find_extrema ci-dessus (recherche du minimum et du maximum d'éléments d'une collection en un seul passage).

Éditer: Résoudre le problème de la recherche de la plus petite valeur non nulle dans un tableau de signes non signés: observez que les valeurs non signées "bouclent" lorsqu'elles atteignent une valeur extrême. Pour trouver la plus petite valeur différente de zéro, nous pouvons en soustraire une de chaque valeur pour la comparaison. Toutes les valeurs nulles "encapsulent" la plus grande valeur possible pour le type, mais la relation entre les autres valeurs sera conservée. Une fois que nous avons terminé, nous ajoutons évidemment un retour à la valeur 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 cela utilise toujours le premier élément pour la valeur initiale, mais nous n’avons toujours pas besoin de code de "cas spécial" - étant donné que cela encapsulera la plus grande valeur possible, toute valeur non nulle comparera 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 autre que zéro.

17
Jerry Coffin

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

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.

5
Bill

Puis-je vous suggérer d'initialiser vos variables "max and min so far" non pas à l'infini, mais au premier nombre du tableau?

4
Thomas Padron-McCarthy