Le comportement de la division par zéro en virgule flottante

Question

Pensez à

#include <iostream>
int main()
{
    double a = 1.0 / 0;
    double b = -1.0 / 0;
    double c = 0.0 / 0;
    std::cout << a << b << c; // to stop compilers from optimising out the code.    
}

J'ai toujours pensé que a sera +Inf, b sera -Inf, et c sera NaN. Mais j'ai également entendu des rumeurs selon lesquelles le comportement de la division par zéro en virgule flottante est, à strictement parler, le suivant indéfini et donc le code ci-dessus ne peut pas être considéré comme du C++ portable. (Cela oblitère théoriquement l'intégrité de ma pile de code de plus d'un million de lignes. Oups).

Qui a raison ?

Je suis satisfait de la note mise en œuvre définie mais je parle de manger des chats, d'aspirer des démons comportement indéfini ici.

Answer 1

La norme C++ n'impose pas la norme IEEE 754, car celle-ci dépend essentiellement de l'architecture matérielle.

Si le matériel/compilateur implémente correctement le standard IEEE 754, la division fournira les INF, -INF et NaN attendus, sinon... ça dépend.

Undefined signifie que c'est l'implémentation du compilateur qui décide, et il y a de nombreuses variables à cela comme l'architecture matérielle, l'efficacité de la génération de code, la paresse du développeur du compilateur, etc.

Source :

La norme C++ stipule qu'une division par 0.0 est undefined

Norme C++ 5.6.4

... Si le deuxième opérande de / ou % est zéro, le comportement est indéfini.

Norme C++ 18.3.2.4

...statique constexpr bool is_iec559 ;

...56. Vrai si et seulement si le type adhère à la norme IEC 559.217

...57. Significatif pour tous les types de virgule flottante.

Détection C++ de IEEE754 :

La bibliothèque standard inclut un modèle pour détecter si IEEE754 est supporté ou non :

statique constexpr bool is_iec559 ;

#include <numeric>
bool isFloatIeee754 = std::numeric_limits<float>::is_iec559();

Que faire si IEEE754 n'est pas supporté ?

Cela dépend, généralement une division par 0 déclenche une exception matérielle et provoque l'arrêt de l'application.

Answer 2

Citation : Référence cpp :

Si le second opérande est zéro, le comportement est indéfini, sauf si une division en virgule flottante a lieu et que le type supporte l'arithmétique en virgule flottante IEEE (cf. std::numeric_limits::is_iec559 ), alors :

• si un opérande est NaN, le résultat est NaN

• diviser un nombre non nul par ±0,0 donne l'infini correctement signé et FE_DIVBYZERO est soulevé

• diviser 0.0 par 0.0 donne NaN et FE_INVALID est soulevé

Nous parlons ici d'une division en virgule flottante, il est donc nécessaire de définir l'implémentation de la division. double la division par zéro est indéfinie.

Si std::numeric_limits<double>::is_iec559 est true et c'est "habituellement true " alors le comportement est bien défini et produit les résultats attendus.

Un pari plutôt sûr serait de se poser un.. :

static_assert(std::numeric_limits<double>::is_iec559, "Please use IEEE754, you weirdo");

... près de votre code.

Answer 3

La division par zéro, à la fois en nombres entiers et en virgule flottante, est un comportement non défini. [expr.mul]p4 :

L'opérateur binaire / donne le quotient, et l'opérateur binaire % donne le reste de la division de la première expression par la seconde. de la première expression par la seconde. Si le deuxième opérande de / ou % est zéro, le comportement est indéfini. ...

Bien que la mise en œuvre puisse optionnellement prendre en charge Annexe F qui possède une sémantique bien définie pour la division par zéro en virgule flottante.

Nous pouvons voir dans ce rapport de bogue de Clang clang sanitizer considère la division par zéro en virgule flottante de la CEI 60559 comme non définie. que même si la macro __STDC_IEC_559__ est définie, elle est définie par les en-têtes du système et, au moins pour clang, elle ne supporte pas Annexe F et donc pour clang reste un comportement non défini :

L'annexe F de la norme C (support IEC 60559 / IEEE 754) définit la division par zéro en virgule flottante, mais clang (3.3 et 3.4 Debian snapshot) la considère comme indéfinie. Ceci est incorrect :

Le soutien de l'annexe F est facultatif, et nous ne le soutenons pas.

if STDC_IEC_559

Cette macro est définie par les en-têtes de votre système, pas par nous. un bogue dans les en-têtes de votre système. (FWIW, GCC ne supporte pas complètement Annex F non plus, IIRC, donc ce n'est même pas un bug spécifique à Clang).

Ce rapport de bogue et deux autres rapports de bogue UBSan : La division par zéro en virgule flottante n'est pas indéfinie et clang devrait supporter l'annexe F de l'ISO C (IEC 60559 / IEEE 754) indique que gcc est conforme à Annexe F par rapport à la division par zéro en virgule flottante.

Bien que je sois d'accord que ce n'est pas à la bibliothèque C de définir STDC_IEC_559 sans condition, le problème est spécifique à clang. GCC ne supporte pas complètement l'annexe F, mais au moins son intention est de la supporter par défaut et la division est bien définie avec elle si le mode d'arrondi n'est pas changé. De nos jours, ne pas supporter l'IEEE 754 (au moins les fonctionnalités de base comme la gestion de la division par zéro) est considéré comme un mauvais comportement.

Ceci est soutenu par la gcc Sémantique des mathématiques à virgule flottante dans le wiki GCC ce qui indique que -sans-signal-nans est la valeur par défaut qui est en accord avec la optimisations gcc options documentation qui dit :

La valeur par défaut est -fno-signaling-nans.

Il est intéressant de noter que UBSan pour clang, la valeur par défaut est d'inclure float-divide-by-zero sous -fsanitize=undefined tandis que gcc n'est pas :

Détecter la division par zéro en virgule flottante. Contrairement à d'autres options similaires, -fsanitize=float-divide-by-zero n'est pas activé par -fsanitize=undefined, car la division par zéro en virgule flottante peut être un moyen légitime d'obtenir des infinis et des NaN.

Voir vivre pour clang et vivre pour gcc .

Answer 4

La division par 0 est comportement indéfini .

Extrait de la section 5.6 de la Norme C++ (C++11) :

Le binaire / donne le quotient, et l'opérateur binaire % opérateur donne le reste de la division de la première expression par la seconde. seconde. Si le deuxième opérande de / ou % est égal à zéro, le comportement est indéfini. Pour les opérandes intégraux, le / donne le quotient algébrique avec toute partie fractionnaire éliminée ; si le quotient a/b est représentable dans le type du résultat, (a/b)*b + a%b est égal à a .

Aucune distinction n'est faite entre les opérandes entiers et les opérandes à virgule flottante pour la fonction / opérateur. La norme indique seulement que la division par zéro est indéfinie sans tenir compte des opérandes.

Answer 5

Dans [expr]/4 nous avons

Si pendant l'évaluation d'une expression, le résultat n'est pas défini mathématiquement ou pas dans l'intervalle des valeurs représentables pour son type, le comportement est indéfini . [Note : la plupart des implémentations existantes du C++ ignorent les débordements d'entiers. Le traitement de la division par zéro, de la formation d'un reste à l'aide d'un diviseur nul et de toutes les exceptions en virgule flottante varie selon les machines et est généralement réglable par une fonction de bibliothèque. -fin de la note ]

C'est moi qui souligne

Selon la norme, il s'agit donc d'un comportement non défini. Elle poursuit en disant que certains de ces cas sont en fait gérés par l'implémentation et sont configurables. Elle ne dit donc pas qu'il s'agit d'un comportement défini par l'implémentation, mais elle vous fait savoir que les implémentations définissent certains de ces comportements.