fenv(3) Library Functions Manual fenv(3) NOM feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag, fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv, feupdateenv, feenableexcept, fedisableexcept, fegetexcept - Gestion des exceptions et des arrondis des nombres flottants BIBLIOTHEQUE Bibliotheque de math (libm, -lm) SYNOPSIS #include int feclearexcept(int excepts); int fegetexceptflag(fexcept_t *flagp, int excepts); int feraiseexcept(int excepts); int fesetexceptflag(const fexcept_t *flagp, int excepts); int fetestexcept(int excepts); int fegetround(void); int fesetround(int rounding_mode); int fegetenv(fenv_t *envp); int feholdexcept(fenv_t *envp); int fesetenv(const fenv_t *envp); int feupdateenv(const fenv_t *envp); DESCRIPTION Ces onze fonctions ont ete definies dans la norme C99, et decrivent la gestion des arrondis des nombres flottants et des exceptions (depassement, division par zero, etc.) sur les nombres flottants. Exceptions L'exception divide-by-zero (division par zero) se produit quand une operation sur des nombres finis donne un resultat infini. L'exception overflow (depassement) se produit quand un resultat doit etre represente par un nombre flottant, mais que sa valeur absolue est trop grande pour etre representee par un nombre flottant. L'exception underflow (soupassement) se produit quand un resultat doit etre represente par un nombre flottant, mais que sa valeur absolue est trop petite pour etre representee en nombre flottant. L'exception inexact se produit quand le resultat arrondi d'une operation n'est pas egal au resultat en precision infinie. Elle peut se declencher quand les exceptions overflow ou underflow se produisent. L'exception invalid se produit quand il n'y a pas de resultat bien defini pour une operation, comme << 0/0 >> ou << infini-infini >> ou << sqrt(-1) >>. Gestion des exceptions Les exceptions sont representees de deux manieres : en tant qu'un unique bit (exception presente ou absente), et ces bits correspondent, de maniere dependant de l'implementation, avec une position au sein d'un entier, et aussi en tant que structure opaque pouvant contenir plus d'informations concernant l'exception (eventuellement l'adresse du code declenchant l'erreur). Chacune des macros FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW, FE_UNDERFLOW est definie lorsque l'implementation gere l'exception correspondante. Les bits sont alors definis, ainsi on peut appeler, par exemple, les fonctions de gestion des exceptions avec un argument entier FE_OVERFLOW|FE_UNDERFLOW. D'autres exceptions peuvent etre supportees. La macro FE_ALL_EXCEPT est un masque au format OU binaire correspondant a toutes les exceptions supportees. La fonction feclearexcept() efface les exceptions supportees representees par les bits de son argument. La fonction fegetexceptflag() stocke une representation de l'etat des exceptions contenues dans son argument excepts dans l'objet opaque *flagp. La fonction feraiseexcept() declenche les exceptions supportees, representees par les bits de son argument excepts. La fonction fesetexceptflag() definit l'etat des exceptions representees par l'argument excepts a la valeur *flagp. Cette valeur doit etre le resultat d'un appel prealable a fegetexceptflag() avec un dernier argument contenant tous les bits dans excepts. La fonction fetestexcept() renvoie un mot dont les bits definis sont egalement les bits definis dans l'argument excepts et pour lesquels l'exception correspondante est definie. Mode d'arrondis Le mode d'arrondi determine comment le resultat des operations en virgule flottante doit etre traite quand le resultat ne peut pas etre represente exactement dans la mantisse. Plusieurs modes d'arrondis peuvent etre fournis : arrondi au plus proche (le mode par defaut), arrondi vers le haut (vers l'infini positif), arrondi vers le bas (vers l'infini negatif) et l'arrondi vers zero. Chacune des macros FE_TONEAREST, FE_UPWARD, FE_DOWNWARD et FE_TOWARDZERO est definie lorsque l'implementation gere la definition et la lecture de la direction d'arrondi correspondante. La fonction fegetround() renvoie la macro correspondant au mode d'arrondi en cours. La fonction fesetround() definit le mode d'arrondi tel qu'il est specifie par son argument et renvoie zero en cas de succes. C99 et POSIX.1-2008 specifient un identifiant, FLT_ROUNDS, defini dans , qui indique le mode d'arrondi de l'implementation pour les additions en virgule flottante. Cet identifiant peut prendre une des valeurs suivantes : -1 Le mode d'arrondi est indetermine. 0 L'arrondi se fait vers 0. 1 L'arrondi se fait vers le nombre le plus proche. 2 L'arrondi se fait vers l'infini positif. 3 L'arrondi se fait vers l'infini negatif. Les autres valeurs sont dependantes des machines, et ne sont pas des modes d'arrondi standard. La valeur de FLT_ROUNDS devrait refleter le mode d'arrondi en cours tel qu'il est configure par fesetround() (mais consultez la section des BOGUES). Environnement de virgule flottante L'environnement de virgule flottante, y compris les modes de controle et les drapeaux d'etat, peuvent etre manipules sous forme d'un objet opaque de type fenv_t. L'environnement par defaut est represente par FE_DFL_ENV (de type const fenv_t *). Il s'agit de la configuration de l'environnement au demarrage d'un programme, et elle est definie par ISO C comme ayant un arrondi au plus proche, toutes les exceptions effacees et un mode sans arret (continuer en presence des exceptions). La fonction fegetenv() sauve l'environnement de travail en cours en virgule flottante dans l'objet *envp. La fonction feholdexcept() effectue la meme chose, puis efface tous les drapeaux d'exceptions, et bascule si possible sur un mode sans arret (continuer en presence des exceptions). Elle renvoie zero en cas de succes. La fonction fesetenv() recharge l'environnement de travail en virgule flottante a partir de l'objet *envp. Cet objet doit etre valide, c'est-a-dire etre le resultat d'un appel a fegetenv() ou feholdexcept(), ou egal a FE_DFL_ENV. Cet appel ne declenche pas d'exception. La fonction feupdateenv() installe l'environnement de virgule flottante represente par l'objet *envp, sauf que les exceptions deja declenchees ne sont pas effacees. Apres l'appel de cette fonction, les exceptions declenchees seront un OU binaire entre l'ensemble precedent, et celui contenu dans *envp. Comme precedemment, l'objet *envp doit etre valide. VALEUR RENVOYEE Ces fonctions renvoient 0 en cas de succes et une valeur non nulle en cas d'erreur. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |feclearexcept(), | Securite des threads | MT-Safe | |fegetexceptflag(), | | | |feraiseexcept(), | | | |fesetexceptflag(), | | | |fetestexcept(), fegetround(), | | | |fesetround(), fegetenv(), | | | |feholdexcept(), fesetenv(), | | | |feupdateenv(), feenableexcept(), | | | |fedisableexcept(), fegetexcept() | | | +---------------------------------+--------------------------+---------+ STANDARDS C11, POSIX.1-2008, IEC 60559 (IEC 559:1989), ANSI/IEEE 854. HISTORIQUE C99, POSIX.1-2001. glibc 2.1. NOTES Notes de la glibc Si possible, la bibliotheque GNU C definit une macro FE_NOMASK_ENV qui represente un environnement ou toutes les exceptions declenchees entrainent une interception. La presence de cette macro peut etre testee en utilisant #ifdef. Elle n'est definie que si _GNU_SOURCE est definie. Le standard C99 ne definit pas de methode pour positionner les bits individuels dans le masque de virgule flottante, par exemple pour intercepter des drapeaux particuliers. Depuis la glibc 2.2, la glibc gere feenableexcept() et fedisableexcept() pour definir individuellement des interceptions de virgules flottantes, et fegetexcept() pour demander l'etat. #define _GNU_SOURCE /* Voir feature_test_macros(7) */ #include int feenableexcept(int excepts); int fedisableexcept(int excepts); int fegetexcept(void); Les fonctions feenableexcept() et fedisableexcept() activent (desactivent) les interceptions pour chaque exception representee par excepts et renvoient l'ensemble precedent des exceptions activees lorsqu'elles reussissent, et -1 sinon. La fonction fegetexcept() renvoie l'ensemble des exceptions actuellement activees. BOGUES C99 specifie que la valeur de FLT_ROUNDS devrait refleter les changements du mode d'arrondi en cours, tels qu'il est configure par fesetround(). Actuellement, ce n'est pas le cas : FLT_ROUNDS prend toujours la valeur 1. VOIR AUSSI math_error(7) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Cedric Boutillier Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.12 23 juillet 2024 fenv(3)