data - long double c++



comment initialiser un flottant à sa valeur max/min? (4)

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 simplement en parcourant et en attrapant le plus grand.

Il y a aussi l'infini positif et négatif pour les flottants, devrais-je les utiliser à la place? Si oui, comment puis-je le signaler dans mon code?


Answer #1

Il n'y a pas vraiment besoin de s'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 d'autres ont déjà suggéré la même idée.

Notez que, bien que la norme ait un élément min_element et un élément max_element, l'utilisation de ceux-ci nécessiterait de balayer deux fois les données, ce qui pourrait poser problème si le tableau est grand. Les standards récents ont résolu cela en ajoutant un std::minmax_element , qui fait la même chose que find_extrema ci-dessus (trouver les éléments minimum et maximum dans une collection en une seule passe).

Éditer: Résoudre le problème de trouver la plus petite valeur non nulle dans un tableau de non signé: observez que les valeurs non signées "enveloppent" quand elles atteignent un extrême. Pour trouver la plus petite valeur non nulle, nous pouvons en soustraire une de chaque pour la comparaison. Toutes les valeurs nulles seront "enveloppées" à la plus grande valeur possible pour le type, mais la relation entre les autres valeurs sera conservée. Après que nous ayons fini, nous en 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 "cas particulier" - puisque cela ira à 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 pas de valeurs non nulles.


Answer #2

Pour trouver manuellement le minimum d'un tableau, vous n'avez pas besoin de connaître la valeur minimum 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.


Answer #3

Vous pouvez soit utiliser -FLT_MAX (ou -DBL_MAX ) pour le nombre négatif maximum et FLT_MAX (ou DBL_MAX ) pour le positif. Cela vous donne la plage de valeurs flottantes (ou doubles) possibles.

Vous ne voulez probablement pas utiliser FLT_MIN ; il correspond au plus petit nombre positif de magnitude qui peut être représenté avec un flotteur, pas la valeur la plus négative représentable avec un flotteur.

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


Answer #4

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 - en face 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 les fonctions std::max_element et min_element (définies dans <algorithm> ) qui peuvent être un meilleur choix pour trouver la valeur la plus grande ou la plus petite dans un tableau.





primitive-types