perkamon - en to fr translation catalogue (25 entries)

note: type: TH
en: 2017-09-15
fr: 15 septembre 2017

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: math_error - detecting errors from mathematical functions
fr: math_error - Détecter des erreurs des fonctions mathématiques

note: type: Plain text
en: When an error occurs, most library functions indicate this fact by returning a special value (e.g., -1 or NULL).  Because they typically return a floating-point number, the mathematical functions declared in I<E<lt>math.hE<gt>> indicate an error using other mechanisms.  There are two error-reporting mechanisms: the older one sets I<errno>; the newer one uses the floating-point exception mechanism (the use of B<feclearexcept>(3)  and B<fetestexcept>(3), as outlined below)  described in B<fenv>(3).
fr: Quand une erreur se produit, la plupart des fonctions de bibliothèques l'indiquent en renvoyant une valeur spéciale (par exemple, -1 ou NULL). Parce qu'elles renvoient en général un nombre en virgule flottante, les fonctions mathématiques déclarées dans I<E<lt>math.hE<gt>> indiquent une erreur en utilisant d'autres mécanismes. Il y a deux mécanismes d'indication d'erreur : l'ancien configure I<errno> ; le nouveau utilise le mécanisme d'exception de virgule flottante (l'utilisation de B<feclearexcept>(3) et B<fetestexcept>(3), comme explicité ci-dessous) décrit dans B<fenv>(3).

note: type: Plain text
en: A portable program that needs to check for an error from a mathematical function should set I<errno> to zero, and make the following call
fr: Un programme portable qui doit vérifier les erreurs d'une fonction mathématique devrait mettre I<errno> à zéro et effectuer l'appel suivant :

note: type: Plain text
en: before calling a mathematical function.
fr: avant d'appeler une fonction mathématique.

note: type: Plain text
en: Upon return from the mathematical function, if I<errno> is nonzero, or the following call (see B<fenv>(3))  returns nonzero
fr: Après le retour d'une fonction mathématique, si I<errno> est non nul ou si l'appel suivant (consultez B<fenv>(3)) ne renvoie pas zéro :

note: enum { FE_INVALID = 0x01, __FE_DENORM = 0x02, FE_DIVBYZERO = 0x04, FE_OVERFLOW = 0x08, FE_UNDERFLOW = 0x10, FE_INEXACT = 0x20 }; type: Plain text
en: then an error occurred in the mathematical function.
fr: alors une erreur s'est produite dans la fonction mathématique.

note: type: Plain text
en: The error conditions that can occur for mathematical functions are described below.
fr: Les conditions d'erreur qui peuvent se produire pour les fonctions mathématiques sont décrites ci-dessous.

note: type: SS
en: Domain error
fr: Erreur de domaine

note: type: Plain text
en: A I<domain error> occurs when a mathematical function is supplied with an argument whose value falls outside the domain for which the function is defined (e.g., giving a negative argument to B<log>(3)).  When a domain error occurs, math functions commonly return a NaN (though some functions return a different value in this case); I<errno> is set to B<EDOM>, and an "invalid" (B<FE_INVALID>)  floating-point exception is raised.
fr: Une I<erreur de domaine> se produit quand une fonction mathématique reçoit un paramètre dont la valeur se trouve en dehors du domaine de définition de la fonction (par exemple, fournir un paramètre négatif à B<log>(3)). Lorsqu'une erreur de domaine se produit, les fonctions renvoient généralement un NaN (mais certaines fonctions renvoient une valeur différente dans ce cas) ; I<errno> prend la valeur B<EDOM> et une exception de virgule flottante « incorrecte » (B<FE_INVALID>) est levée.

note: type: SS
en: Pole error
fr: Erreur de pôle

note: type: Plain text
en: A I<pole error> occurs when the mathematical result of a function is an exact infinity (e.g., the logarithm of 0 is negative infinity).  When a pole error occurs, the function returns the (signed) value B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, depending on whether the function result type is I<double>, I<float>, or I<long double>.  The sign of the result is that which is mathematically correct for the function.  I<errno> is set to B<ERANGE>, and a "divide-by-zero" (B<FE_DIVBYZERO>)  floating-point exception is raised.
fr: Une I<erreur de pôle> se produit quand le résultat mathématique d'une fonction est un infini (par exemple, le logarithme de 0 est l'infini négatif). Quand une erreur de pôle se produit, la fonction renvoie la valeur (signée) B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL> suivant que la valeur de retour de la fonction est un I<double>, un I<float> ou un I<long double>. Le signe du résultat est celui du résultat correct de la fonction mathématique. I<errno> prend la valeur B<ERANGE> et une exception de virgule flottante de division par zéro (B<FE_DIVBYZERO>) est levée.

note: type: SS
en: Range error
fr: Erreur d'intervalle

note: type: Plain text
en: A I<range error> occurs when the magnitude of the function result means that it cannot be represented in the result type of the function.  The return value of the function depends on whether the range error was an overflow or an underflow.
fr: Une I<erreur d'intervalle> se produit quand le module du résultat de la fonction ne peut pas être représenté par le type utilisé pour le résultat de la fonction. La valeur de retour de la fonction dépend suivant qu'il s'agit d'un dépassement (« overflow ») ou d'un soupassement (« underflow »).

note: type: Plain text
en: A floating result I<overflows> if the result is finite, but is too large to represented in the result type.  When an overflow occurs, the function returns the value B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, depending on whether the function result type is I<double>, I<float>, or I<long double>.  I<errno> is set to B<ERANGE>, and an "overflow" (B<FE_OVERFLOW>)  floating-point exception is raised.
fr: Un I<dépassement> se produit pour le résultat flottant si le résultat est fini, mais trop grand pour être représenté dans le type du résultat. Quand un dépassement se produit, la fonction renvoie la valeur B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, suivant que le type de retour de la fonction est un I<double>, un I<float> ou un I<long double>. I<errno> prend la valeur B<ERANGE> et une exception de virgule flottante de dépassement (B<FE_OVERFLOW>) est levée.

note: type: Plain text
en: A floating result I<underflows> if the result is too small to be represented in the result type.  If an underflow occurs, a mathematical function typically returns 0.0 (C99 says a function shall return "an implementation-defined value whose magnitude is no greater than the smallest normalized positive number in the specified type").  I<errno> may be set to B<ERANGE>, and an "overflow" (B<FE_UNDERFLOW>)  floating-point exception may be raised.
fr: Un I<soupassement> se produit pour le résultat flottant si le résultat est trop petit pour être représenté dans le type du résultat. Quand un soupassement se produit, une fonction mathématique renvoie généralement 0,0 (C99 indique qu'une fonction doit renvoyer « une valeur propre à l'implémentation dont le module n'est pas plus grand que la plus petite valeur normalisée positive du type donné »). I<errno> prend la valeur  B<ERANGE> et une exception de virgule flottante de soupassement (B<FE_UNDERFLOW>) peut être levée.

note: type: Plain text
en: Some functions deliver a range error if the supplied argument value, or the correct function result, would be I<subnormal>.  A subnormal value is one that is nonzero, but with a magnitude that is so small that it can't be presented in normalized form (i.e., with a 1 in the most significant bit of the significand).  The representation of a subnormal number will contain one or more leading zeros in the significand.
fr: Certaines fonctions produisent une erreur d'intervalle si la valeur du paramètre fourni, ou le résultat exact de la fonction, est I<dénormalisé> (« subnormal »). Une valeur dénormalisée est une valeur qui n'est pas nulle, mais dont le module est si petit qu'il ne peut être représenté dans la forme normalisée (c'est-à-dire avec un 1 dans le bit de poids fort de la mantisse). La représentation d'un nombre dénormalisé contiendra un ou plusieurs zéros en tête de la mantisse.

note: http://www.securecoding.cert.org/confluence/display/seccode/FLP32-C.+Prevent+or+detect+domain+and+range+errors+in+math+functions type: Plain text
en: To avoid the complexities of using I<errno> and B<fetestexcept>(3)  for error checking, it is often advised that one should instead check for bad argument values before each call.  For example, the following code ensures that B<log>(3)'s argument is not a NaN and is not zero (a pole error) or less than zero (a domain error):
fr: Pour éviter la complexité d'avoir à utiliser I<errno> et B<fetestexcept>(3) pour la détection d'erreurs, il est souvent recommandé de vérifier la validité des paramètres avant les appels. Par exemple, le code suivant s'assure que le paramètre de B<log>(3) n'est ni un NaN, ni zéro (une erreur de pôle) ou inférieur à zéro (une erreur de domaine) :

note: type: Plain text
en: The B<gcc>(1)  I<-fno-math-errno> option causes the executable to employ implementations of some mathematical functions that are faster than the standard implementations, but do not set I<errno> on error.  (The B<gcc>(1)  I<-ffast-math> option also enables I<-fno-math-errno>.)  An error can still be tested for using B<fetestexcept>(3).
fr: L'option de B<gcc>(1) I<-fno-math-errno> permet d'utiliser des implémentations de certaines fonctions mathématiques plus rapides que les implémentations standard, mais qui ne positionnent pas I<errno> (l'option I<-ffast-math> de B<gcc>(1) active également I<-fno-math-errno>). Une erreur peut toujours être testée en utilisant B<fetestexcept>(3).

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
