Vérifier si un flottant est un entier

Question

Comment puis-je vérifier si un float contient une valeur entière ? Jusqu'à présent, j'ai utilisé :

float f = 4.5886;
if (f-(int)f == 0)
     printf("yes\n");
else printf("no\n");

Mais je me demande s'il existe une meilleure solution, ou si celle-ci présente des inconvénients (ou de nombreux inconvénients).

Answer 1

En dehors des bonnes réponses déjà données, vous pouvez également utiliser ceilf(f) == f ou floorf(f) == f . Les deux expressions renvoient true si f est un nombre entier. Ils renvoient également false pour les NaNs ( Les NaNs comparent toujours des valeurs inégales ) et true pour ±infini, et n'ont pas le problème de déborder le type entier utilisé pour contenir le résultat tronqué, car floorf() / ceilf() retourner float s.

Answer 2

Gardez à l'esprit que la plupart des techniques présentées ici sont valables en supposant que l'erreur d'arrondi due aux calculs antérieurs n'est pas un facteur. Par exemple, vous pourrait utiliser roundf comme ceci :

float z = 1.0f;

if (roundf(z) == z) {
    printf("integer\n");
} else {
    printf("fraction\n");
}

Le problème avec cette technique et d'autres techniques similaires (telles que ceilf , le casting à long ) est que, bien qu'ils fonctionnent parfaitement pour les constantes de nombres entiers, ils échouent si le nombre est le résultat d'un calcul qui a été sujet à une erreur d'arrondi en virgule flottante. Par exemple :

float z = powf(powf(3.0f, 0.05f), 20.0f);

if (roundf(z) == z) {
    printf("integer\n");
} else {
    printf("fraction\n");
}

Imprime "fraction", même si (3 1/20 ) 20 devrait être égal à 3, car le résultat réel du calcul a fini par être 2.9999992847442626953125 .

Toute méthode similaire, qu'elle soit fmodf ou autre, est soumis à cela. Dans les applications qui effectuent des calculs complexes ou sujets aux arrondis, on souhaite généralement définir une certaine valeur de "tolérance" pour ce qui constitue un "nombre entier" (cela vaut pour les comparaisons d'égalité en virgule flottante en général). Nous appelons souvent cette tolérance epsilon . Par exemple, disons que nous pardonnons à l'ordinateur jusqu'à +/- 0,00001 d'erreur d'arrondi. Alors, si nous testons z nous pouvons choisir un epsilon de 0.00001 et faire :

if (fabsf(roundf(z) - z) <= 0.00001f) {
    printf("integer\n");
} else {
    printf("fraction\n");
}

Vous ne voulez pas vraiment utiliser ceilf ici, car par exemple ceilf(1.0000001) est 2 et non 1, et ceilf(-1.99999999) est -1 et non -2.

Vous pourriez utiliser rintf à la place de roundf si vous préférez.

Choisissez une valeur de tolérance adaptée à votre application (et oui, parfois la tolérance zéro est appropriée). Pour plus d'informations, consultez cet article sur comparaison de nombres à virgule flottante .

Answer 3

if (fmod(f, 1) == 0.0) {
  ...
}

N'oubliez pas math.h et libm .

Answer 4

Stdlib float modf (float x, float *ipart) divise en deux parties, vérifie si la valeur de retour (partie fractionnaire) == 0.

Answer 5

if (f <= LONG_MIN || f >= LONG_MAX || f == (long)f) /* it's an integer */