perkamon - en to fr translation catalogue (836 entries)

note: type: TH
en: 2007-07-26
fr: 26 juillet 2007

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: INFINITY, NAN, HUGE_VAL, HUGE_VALF, HUGE_VALL - floating-point constants
fr: INFINITY, NAN, HUGE_VAL, HUGE_VALF, HUGE_VALL - Constantes en virgule flottante

note: type: Plain text
en: B<#define _ISOC99_SOURCE>      /* See feature_test_macros(7) */
fr: B<#define _ISOC99_SOURCE>      /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The macro B<INFINITY> expands to a I<float> constant representing positive infinity.
fr: La macro B<INFINITY> est développée en une constante de type I<float> représentant l'infini positif.

note: type: Plain text
en: The macro B<NAN> expands to a I<float> constant representing a quiet NaN (when supported).  A I<quiet> NaN is a NaN ("not-a-number") that does not raise exceptions when it is used in arithmetic.  The opposite is a I<signaling> NaN.  See IEC 60559:1989.
fr: La macro B<NAN> est développée en une constante de type I<float> représentant un «\ NaN silencieux\ » (si cela est géré). Un «\ NaN silencieux\ » est un «\ NaN\ » (« Not a Number », ce qui veut dire « pas un nombre ») qui ne déclenche pas d'exception quand elle est utilisée en arithmétique. Son opposé est «\ NaN non silencieux\ ». Consultez IEC\ 60559:1989.

note: type: Plain text
en: The macros B<HUGE_VAL>, B<HUGE_VALF>, B<HUGE_VALL> expand to constants of types I<double>, I<float> and I<long double>, respectively, that represent a large positive value, possibly positive infinity.
fr: Les macros B<HUGE_VAL>, B<HUGE_VALF> et B<HUGE_VALL> sont développées respectivement en constante de type I<double>, I<float> et I<long double>, qui représentent une grande valeur positive, et probablement l'infini positif.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: SH
en: AVAILABILITY
fr: DISPONIBILITÉ

note: type: Plain text
en: On a glibc system, the macro B<HUGE_VAL> is always available.  Availability of the B<NAN> macro can be tested using B<#ifdef NAN>, and similarly for B<INFINITY>, B<HUGE_VALF>, B<HUGE_VALL>.  They will be defined by I<E<lt>math.hE<gt>> if B<_ISOC99_SOURCE> or B<_GNU_SOURCE> is defined, or B<__STDC_VERSION__> is defined and has a value not less than 199901L.
fr: Sur un système basé sur la glibc, la macro B<HUGE_VAL> est toujours disponible. La présence de la macro B<NAN> peut être testée avec B<#ifdef NAN> et de façon similaire pour B<INFINITY>, B<HUGE_VALF> et B<HUGE_VALL>. Elles sont définies dans I<E<lt>math.hE<gt>> si B<_ISOC99_SOURCE> ou B<_GNU_SOURCE> est définie ou si B<__STDC_VERSION__> est définie avec une valeur supérieure ou égale à 199901L.

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

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

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: abs, labs, llabs, imaxabs - compute the absolute value of an integer
fr: abs, labs, llabs, imaxabs - Calculer la valeur absolue d'un entier

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<llabs>():
fr: B<llabs>() :

note: type: Plain text
en: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: or I<cc\ -std=c99>
fr: ou I<cc\ -std=c99>

note: type: Plain text
en: The B<abs>()  function computes the absolute value of the integer argument I<j>.  The B<labs>(), B<llabs>()  and B<imaxabs>()  functions compute the absolute value of the argument I<j> of the appropriate integer type for the function.
fr: La fonction B<abs>() calcule la valeur absolue de l'argument entier I<j>. Les fonctions B<labs>(), B<llabs>() et B<imaxabs>() calculent les valeurs absolues de l'argument I<j> selon le type entier approprié de la fonction.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: Returns the absolute value of the integer argument, of the appropriate integer type for the function.
fr: Chaque fonction renvoie la valeur absolue de son argument selon le type d'entier de la fonction.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<abs>(), B<labs>(), B<llabs>(), and B<imaxabs>()  functions are thread-safe.
fr: Les fonctions B<abs>(), B<labs>(), B<llabs>(), et B<imaxabs>() sont sûres dans un contexte multithread.

note: POSIX.1 (1996 edition) requires only the .BR abs () function. type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD, C99.  C89 only includes the B<abs>()  and B<labs>()  functions; the functions B<llabs>()  and B<imaxabs>()  were added in C99.
fr: SVr4, POSIX.1-2001, BSD\ 4.3, C99. C89 n'inclut que les fonctions B<abs>() et B<labs>(). Les fonctions B<llabs>() et B<imaxabs>() ont été ajoutées dans C99.

note: type: Plain text
en: Trying to take the absolute value of the most negative integer is not defined.
fr: La valeur absolue du nombre entier négatif le plus petit est indéfinie.

note: type: Plain text
en: The B<llabs>()  function is included in glibc since version 2.0, but is not in libc5 or libc4.  The B<imaxabs>()  function is included in glibc since version 2.1.1.
fr: La fonction B<llabs>() est incluse dans la glibc depuis la version\ 2.0, mais pas dans la libc5 et la libc4. La fonction B<imaxabs>() est incluse dans la glibc depuis la version\ 2.1.1.

note: type: Plain text
en: For B<llabs>()  to be declared, it may be necessary to define B<_ISOC99_SOURCE> or B<_ISOC9X_SOURCE> (depending on the version of glibc) before including any standard headers.
fr: Pour que B<llabs>() soit déclarée, il peut être nécessaire de définir B<_ISOC99_SOURCE> ou B<_ISOC9X_SOURCE> (suivant la version de la glibc) avant toute inclusion des en-têtes standard.

note: type: Plain text
en: GCC handles B<abs>()  and B<labs>()  as built-in functions.  GCC 3.0 also handles B<llabs>()  and B<imaxabs>()  as built-ins.
fr: GCC traite B<abs>() et B<labs>() comme des fonctions internes. GCC\ 3.0 traite également B<llabs>() et B<imaxabs>() comme des fonctions internes.

note: type: TH
en: 2010-09-20
fr: 20 septembre 2010

note: type: Plain text
en: acos, acosf, acosl - arc cosine function
fr: acos, acosf, acosl - Fonction arc cosinus

note: type: Plain text
en: Link with I<-lm>.
fr: Effectuez l'édition des liens avec l'option I<-lm>.

note: type: Plain text
en: B<acosf>(), B<acosl>():
fr: B<acosf>(), B<acosl>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<acos>()  function calculates the arc cosine of I<x>; that is the value whose cosine is I<x>.
fr: La fonction B<acos>() calcule l'arc cosinus de I<x>, c'est-à-dire la valeur dont le cosinus est I<x>.

note: type: Plain text
en: On success, these functions return the arc cosine of I<x> in radians; the return value is in the range [0,\ pi].
fr: En cas de réussite, ces fonctions renvoient l'arc cosinus de I<x> en radians ; la valeur de retour est dans l'intervalle [0,\ pi].

note: type: Plain text
en: If I<x> is a NaN, a NaN is returned.
fr: Si I<x> est un NaN, la valeur renvoyée est un NaN.

note: type: Plain text
en: If I<x> is +1, +0 is returned.
fr: Si I<x> vaut +1, la valeur renvoyée est +0.

note: type: Plain text
en: If I<x> is positive infinity or negative infinity, a domain error occurs, and a NaN is returned.
fr: Si I<x> est un infini positif ou négatif, une erreur de domaine est produite et un NaN est renvoyé.

note: POSIX.1-2001 documents an optional range error for subnormal x; glibc 2.8 does not do this. type: Plain text
en: If I<x> is outside the range [-1,\ 1], a domain error occurs, and a NaN is returned.
fr: Si I<x> est en dehors de l'intervalle [-1,\ 1], une erreur de domaine est produite et un NaN est renvoyé.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: See B<math_error>(7)  for information on how to determine whether an error has occurred when calling these functions.
fr: Consultez B<math_error>(7) pour savoir comment déterminer qu'une erreur est survenue lors de l'appel de ces fonctions.

note: type: Plain text
en: The following errors can occur:
fr: Les erreurs suivantes peuvent se produire\ :

note: type: TP
en: Domain error: I<x> is outside the range [-1,\ 1]
fr: Erreur de domaine : I<x> est en dehors de l'intervalle [-1,\ 1]

note: type: Plain text
en: I<errno> is set to B<EDOM>.  An invalid floating-point exception (B<FE_INVALID>)  is raised.
fr: I<errno> prend la valeur B<EDOM>. Une exception indiquant une virgule flottante incorrecte (B<FE_INVALID>) est levée.

note: type: Plain text
en: C99, POSIX.1-2001.  The variant returning I<double> also conforms to SVr4, 4.3BSD, C89.
fr: C99, POSIX.1-2001. La variante renvoyant un I<double> est également conforme à SVr4, BSD 4.3 et C89.

note: type: Plain text
en: acosh, acoshf, acoshl - inverse hyperbolic cosine function
fr: acosh, acoshf, acoshl - Fonction arc cosinus hyperbolique

note: type: Plain text
en: B<acosh>():
fr: B<acosh>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _XOPEN_SOURCE\ &&\ _XOPEN_SOURCE_EXTENDED || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _XOPEN_SOURCE\ &&\ _XOPEN_SOURCE_EXTENDED || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: B<acoshf>(), B<acoshl>():
fr: B<acoshf>(), B<acoshl>() :

note: type: Plain text
en: The B<acosh>()  function calculates the inverse hyperbolic cosine of I<x>; that is the value whose hyperbolic cosine is I<x>.
fr: La fonction B<acosh>() calcule l'arc cosinus hyperbolique de I<x>, c'est-à-dire la valeur dont le cosinus hyperbolique est I<x>.

note: type: Plain text
en: On success, these functions return the inverse hyperbolic cosine of I<x>.
fr: En cas de réussite, ces fonctions renvoient l'arc cosinus hyperbolique de I<x>.

note: type: Plain text
en: If I<x> is positive infinity, positive infinity is returned.
fr: Si I<x> est une valeur infinie positive, une valeur positive infinie est renvoyée.

note: type: Plain text
en: If I<x> is less than 1, a domain error occurs, and the functions return a NaN.
fr: Si I<x> vaut moins que 1, une erreur de domaine est produite et les fonctions renvoient un NaN.

note: type: TP
en: Domain error: I<x> is less than 1
fr: Erreur de domaine : I<x> est inférieur à 1

note: type: Plain text
en: asin, asinf, asinl - arc sine function
fr: asin, asinf, asinl - Fonction arc sinus

note: type: Plain text
en: B<asinf>(), B<asinl>():
fr: B<asinf>(), B<asinl>() :

note: type: Plain text
en: The B<asin>()  function calculates the principal value of the arc sine of I<x>; that is the value whose sine is I<x>.
fr: La fonction B<asin>() calcule la mesure principale de l'arc sinus de I<x>, c'est-à-dire la valeur dont le sinus est I<x>.

note: type: Plain text
en: On success, these functions return the principal value of the arc sine of I<x> in radians; the return value is in the range [-pi/2,\ pi/2].
fr: En cas de réussite, ces fonctions renvoient la mesure principale de l'arc sinus de I<x> en radians ; la valeur de retour est dans l'intervalle [-pi/2,\ pi/2].

note: type: Plain text
en: If I<x> is +0 (-0), +0 (-0) is returned.
fr: Si I<x> vaut +0 (resp. -0), +0 (resp. -0) est renvoyé.

note: type: TH
en: 2013-10-14
fr: 14 octobre 2013

note: type: Plain text
en: asinh, asinhf, asinhl - inverse hyperbolic sine function
fr: asinh, asinhf, asinhl - Fonction arc sinus hyperbolique

note: type: Plain text
en: B<asinh>():
fr: B<asinh>() :

note: type: Plain text
en: B<asinhf>(), B<asinhl>():
fr: B<asinhf>(), B<asinhl>() :

note: type: Plain text
en: The B<asinh>()  function calculates the inverse hyperbolic sine of I<x>; that is the value whose hyperbolic sine is I<x>.
fr: La fonction B<asinh>() calcule l'arc sinus hyperbolique de I<x>, c'est-à-dire la valeur dont le sinus hyperbolique est I<x>.

note: type: Plain text
en: On success, these functions return the inverse hyperbolic sine of I<x>.
fr: En cas de réussite, ces fonctions renvoient l'arc sinus hyperbolique de I<x>.

note: type: Plain text
en: If I<x> is positive infinity (negative infinity), positive infinity (negative infinity) is returned.
fr: Si I<x> est une valeur infinie positive (resp. négative), une valeur infinie positive est renvoyée (resp. négative).

note: type: Plain text
en: No errors occur.
fr: Aucune erreur ne se produit.

note: type: Plain text
en: The B<asinh>(), B<asinhf>(), and B<asinhl>()  functions are thread-safe.
fr: Les fonctions B<asinh>(), B<asinhf>(), et B<asinhl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2013-10-07
fr: 7 octobre 2013

note: type: Plain text
en: atan, atanf, atanl - arc tangent function
fr: atan, atanf, atanl - Fonction arc tangente

note: type: Plain text
en: B<atanf>(), B<atanl>():
fr: B<atanf>(), B<atanl>() :

note: type: Plain text
en: The B<atan>()  function calculates the principal value of the arc tangent of I<x>; that is the value whose tangent is I<x>.
fr: La fonction B<atan>() calcule la mesure principale de l'arc tangente de I<x>, c'est-à-dire la valeur dont la tangente est I<x>.

note: type: Plain text
en: On success, these functions return the principal value of the arc tangent of I<x> in radians; the return value is in the range [-pi/2,\ pi/2].
fr: En cas de réussite, ces fonctions renvoient la mesure principale de l'arc tangente de I<x> en radians ; la valeur de retour se trouve dans l'intervalle [-pi/2,\ pi/2].

note: POSIX.1-2001 documents an optional range error for subnormal x; glibc 2.8 does not do this. type: Plain text
en: If I<x> is positive infinity (negative infinity), +pi/2 (-pi/2) is returned.
fr: Si I<x> est une valeur infinie positive (resp. négative), +pi/2 (resp. -pi/2) est renvoyé.

note: type: Plain text
en: The B<atan>(), B<atanf>(), and B<atanl>()  functions are thread-safe.
fr: Les fonctions B<atan>(), B<atanf>() et B<atanl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: atan2, atan2f, atan2l - arc tangent function of two variables
fr: atan2, atan2f, atan2l - Fonction arc tangente de deux variables

note: type: Plain text
en: B<atan2f>(), B<atan2l>():
fr: B<atan2f>(), B<atan2l>() :

note: type: Plain text
en: The B<atan2>()  function calculates the principal value of the arc tangent of I<y/x>, using the signs of the two arguments to determine the quadrant of the result.
fr: La fonction B<atan2>() calcule la mesure principale de l'arc tangente de I<y/x>, en tenant compte des signes des deux variables pour déterminer le quadrant du résultat.

note: type: Plain text
en: On success, these functions return the principal value of the arc tangent of I<y/x> in radians; the return value is in the range [-pi,\ pi].
fr: En cas de réussite, ces fonctions renvoient la mesure principale de l'arc tangente de I<y/x> en radians\ ; la valeur de retour est comprise dans l'intervalle [-pi,\ pi].

note: type: Plain text
en: If I<y> is +0 (-0) and I<x> is less than 0, +pi (-pi) is returned.
fr: Si I<y> vaut +0 (resp. -0) et I<x> est négatif, +pi est renvoyé (resp. -pi).

note: type: Plain text
en: If I<y> is +0 (-0) and I<x> is greater than 0, +0 (-0) is returned.
fr: Si I<y> vaut +0 (resp. -0) et I<x> est positif, +0 (resp. -0) est renvoyé.

note: type: Plain text
en: If I<y> is less than 0 and I<x> is +0 or -0, -pi/2 is returned.
fr: Si I<y> est négatif et I<x> vaut +0 ou -0, -pi/2 est renvoyé.

note: type: Plain text
en: If I<y> is greater than 0 and I<x> is +0 or -0, pi/2 is returned.
fr: Si I<y> est positif et I<x> vaut +0 ou -0, pi/2 est renvoyé.

note: POSIX.1 says: If .I x is 0, a pole error shall not occur. type: Plain text
en: If either I<x> or I<y> is NaN, a NaN is returned.
fr: Si I<x> ou I<y> est un NaN, un NaN est renvoyé.

note: POSIX.1 says: If the result underflows, a range error may occur and .I y/x should be returned. type: Plain text
en: If I<y> is +0 (-0) and I<x> is -0, +pi (-pi) is returned.
fr: Si I<y> vaut +0 (resp. -0) et I<x> vaut -0, +pi (resp. -pi) est renvoyé.

note: type: Plain text
en: If I<y> is +0 (-0) and I<x> is +0, +0 (-0) is returned.
fr: Si I<y> vaut +0 (resp. -0) et I<x> vaut +0, +0 (resp. -0) est renvoyé.

note: type: Plain text
en: If I<y> is a finite value greater (less) than 0, and I<x> is negative infinity, +pi (-pi) is returned.
fr: Si I<y> est une valeur finie positive (resp. négative) et I<x> est une valeur infinie négative, +pi (resp. -pi) est renvoyé.

note: type: Plain text
en: If I<y> is a finite value greater (less) than 0, and I<x> is positive infinity, +0 (-0) is returned.
fr: Si I<y> est une valeur finie positive (resp. négative) et si I<x> est une valeur infinie positive, +0 (resp. -0) est renvoyé.

note: type: Plain text
en: If I<y> is positive infinity (negative infinity), and I<x> is finite, pi/2 (-pi/2) is returned.
fr: Si I<y> est une valeur infinie positive (resp. négative) et si I<x> est une valeur finie, pi/2 (resp. -pi/2) est renvoyé.

note: type: Plain text
en: If I<y> is positive infinity (negative infinity) and I<x> is negative infinity, +3*pi/4 (-3*pi/4) is returned.
fr: Si I<y> est une valeur infinie positive (resp. négative) et si I<x> est une valeur infinie négative, +3*pi/4 (resp. -3*pi/4) est renvoyé.

note: POSIX.1 says: If both arguments are 0, a domain error shall not occur. type: Plain text
en: If I<y> is positive infinity (negative infinity) and I<x> is positive infinity, +pi/4 (-pi/4) is returned.
fr: Si I<y> est une valeur infinie positive (resp. négative) et si I<x> est une valeur infinie positive, +pi/4 (resp. -pi/4) est renvoyé.

note: type: TH
en: 2010-09-11
fr: 11 septembre 2010

note: type: Plain text
en: atanh, atanhf, atanhl - inverse hyperbolic tangent function
fr: atanh, atanhf, atanhl - Fonction arc tangente hyperbolique

note: type: Plain text
en: B<atanh>():
fr: B<atanh>() :

note: type: Plain text
en: B<atanhf>(), B<atanhl>():
fr: B<atanhf>(), B<atanhl>() :

note: type: Plain text
en: The B<atanh>()  function calculates the inverse hyperbolic tangent of I<x>; that is the value whose hyperbolic tangent is I<x>.
fr: La fonction B<atanh>() calcule l'arc tangente hyperbolique de I<x> ; c'est-à-dire la valeur dont la tangente hyperbolique vaut I<x>.

note: type: Plain text
en: On success, these functions return the inverse hyperbolic tangent of I<x>.
fr: En cas de réussite, ces fonctions renvoient l'arc tangente hyperbolique de I<x>.

note: type: Plain text
en: If I<x> is +1 or -1, a pole error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the mathematically correct sign.
fr: Si I<x> vaut +1 ou -1, une erreur de pôle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, respectivement avec le signe mathématique correct.

note: POSIX.1-2001 documents an optional range error for subnormal x; glibc 2.8 does not do this. type: Plain text
en: If the absolute value of I<x> is greater than 1, a domain error occurs, and a NaN is returned.
fr: Si la valeur absolue de I<x> est supérieure à 1, une erreur de domaine est produite et un NaN est renvoyé.

note: type: TP
en: Domain error: I<x> less than -1 or greater than +1
fr: Erreur de domaine : I<x> est inférieur à -1 ou supérieur à +1

note: type: TP
en: Pole error: I<x> is +1 or -1
fr: Erreur de pôle : I<x> vaut +1 ou -1

note: type: Plain text
en: I<errno> is set to B<ERANGE> (but see BUGS).  A divide-by-zero floating-point exception (B<FE_DIVBYZERO>)  is raised.
fr: I<errno> est configuré à la valeur B<ERANGE> (mais consultez la section des BOGUES). Une exception de virgule flottante division par zéro (B<FE_DIVBYZERO>) est déclenchée.

note: type: SH
en: BUGS
fr: BOGUES

note: Bug: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6759 This can be seen in sysdeps/ieee754/k_standard.c type: Plain text
en: In glibc 2.9 and earlier, when a pole error occurs, I<errno> as set to B<EDOM> instead of the POSIX-mandated B<ERANGE>.  Since version 2.10, glibc does the right thing.
fr: Dans la glibc 2.9 et plus anciennes, lorsqu'une erreur de pôle se produit, I<errno> est définie à B<EDOM> au lieu de B<ERANGE> comme défini dans POSIX. Depuis la version 2.10, la glibc suit POSIX.

note: type: TH
en: 2013-09-18
fr: 18 septembre 2013

note: type: Plain text
en: cbrt, cbrtf, cbrtl - cube root function
fr: cbrt, cbrtf, cbrtl - Fonction racine cubique

note: type: Plain text
en: B<cbrt>():
fr: B<cbrt>() :

note: type: Plain text
en: B<cbrtf>(), B<cbrtl>():
fr: B<cbrtf>(), B<cbrtl>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOUCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOUCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<cbrt>()  function returns the (real) cube root of I<x>.  This function cannot fail; every representable real value has a representable real cube root.
fr: La fonction B<cbrt>() renvoie la racine cubique (réelle) de I<x>. La fonction ne peut pas échouer\ ; toute valeur réelle possède une racine cubique calculable.

note: type: Plain text
en: These functions return the cube root of I<x>.
fr: Ces fonctions renvoient la racine cubique de I<x>.

note: type: Plain text
en: If I<x> is +0, -0, positive infinity, negative infinity, or NaN, I<x> is returned.
fr: Si I<x> vaut +0, -0, une valeur infinie positive ou négative, ou NaN, alors I<x> est renvoyé.

note: type: Plain text
en: The B<cbrt>(), B<cbrtf>(), and B<cbrtl>()  functions are thread-safe.
fr: Les fonctions B<cbrt>(), B<cbrtf>() et B<cbrtl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: ceil, ceilf, ceill - ceiling function: smallest integral value not less than argument
fr: ceil, ceilf, ceil - Plus petit entier supérieur ou égal à x

note: type: Plain text
en: B<ceilf>(), B<ceill>():
fr: B<ceilf>(), B<ceill>() :

note: type: Plain text
en: These functions return the smallest integral value that is not less than I<x>.
fr: Ces fonctions renvoient le plus petit nombre entier n'étant pas strictement inférieur à I<x>.

note: type: Plain text
en: For example, I<ceil(0.5)> is 1.0, and I<ceil(-0.5)> is 0.0.
fr: Par exemple, I<ceil(0,5)> vaut 1,0 et I<ceil(-0,5)> vaut 0,0.

note: type: Plain text
en: These functions return the ceiling of I<x>.
fr: Ces fonctions renvoient la partie entière de I<x> par excès.

note: type: Plain text
en: If I<x> is integral, +0, -0, NaN, or infinite, I<x> itself is returned.
fr: Si I<x> est un nombre entier, +0, -0, NaN ou une valeur infinie, la valeur I<x> elle-même est renvoyée.

note: type: Plain text
en: No errors occur.  POSIX.1-2001 documents a range error for overflows, but see NOTES.
fr: Aucune erreur ne se produit. POSIX.1-2001 documente une série d'erreurs pour les dépassements, mais consultez la section NOTES.

note: type: Plain text
en: The B<ceil>(), B<ceilf>(), and B<ceill>()  functions are thread-safe.
fr: Les fonctions B<ceil>(), B<ceilf>() et B<ceill>() sont sûres dans un contexte multithread.

note: type: Plain text
en: SUSv2 and POSIX.1-2001 contain text about overflow (which might set I<errno> to B<ERANGE>, or raise an B<FE_OVERFLOW> exception).  In practice, the result cannot overflow on any current machine, so this error-handling stuff is just nonsense.  (More precisely, overflow can happen only when the maximum value of the exponent is smaller than the number of mantissa bits.  For the IEEE-754 standard 32-bit and 64-bit floating-point numbers the maximum value of the exponent is 128 (respectively, 1024), and the number of mantissa bits is 24 (respectively, 53).)
fr: Les spécifications SUSv2 et POSIX.1-2001 contiennent un passage sur les dépassements (qui peuvent remplir I<errno> avec B<ERANGE> ou déclencher une exception B<FE_OVERFLOW>). En pratique, aucun dépassement ne peut se produire sur les machines actuelles, ce qui rend inutile cette gestion d'erreur. Plus précisément, le dépassement ne peut se produire que si la valeur maximale de l'exposant est plus petite que le nombre de bits de la mantisse. Pour les nombres en virgule flottante 32\ bits et 64\ bits obéissant à la norme IEEE-754, la valeur maximale de l'exposant est 128 (resp. 1024) et le nombre de bits de la mantisse est 24 (resp. 53).

note: type: Plain text
en: The integral value returned by these functions may be too large to store in an integer type (I<int>, I<long>, etc.).  To avoid an overflow, which will produce undefined results, an application should perform a range check on the returned value before assigning it to an integer type.
fr: La partie entière renvoyée par ces fonctions peut être trop grande pour être stockée dans un type entier (I<int>, I<long>, etc.). Pour éviter les dépassements, qui produiront des résultats indéfinis, une application devrait vérifier la validité de la valeur renvoyée avec l'intervalle accepté avant de l'affecter à un type entier.

note: type: Plain text
en: copysign, copysignf, copysignl - copy sign of a number
fr: copysign - Copier le signe d'un nombre

note: type: Plain text
en: B<copysign>(), B<copysignf>(), B<copysignl>():
fr: B<copysign>(), B<copysignf>(), B<copysignl>() :

note: type: Plain text
en: _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<copysign>(), B<copysignf>(), and B<copysignl>()  functions return a value whose absolute value matches that of I<x>, but whose sign bit matches that of I<y>.
fr: Les fonction B<copysign>(), B<copysignf>() et B<copysignl>() renvoient un nombre dont la valeur absolue est celle de I<x>, mais dont le signe est celui de I<y>.

note: type: Plain text
en: For example, I<copysign(42.0,\ -1.0)> and I<copysign(-42.0, -1.0)> both return -42.0.
fr: Par exemple, I<copysign(42.0,\ -1.0)> et I<copysign(-42.0, -1.0)> renvoient toutes les deux -42.0.

note: type: Plain text
en: On success, these functions return a value whose magnitude is taken from I<x> and whose sign is taken from I<y>.
fr: En cas de succès, ces functions renvoient la valeur absolue de I<x>, et le signe de I<y>.

note: type: Plain text
en: If I<x> is a NaN, a NaN with the sign bit of I<y> is returned.
fr: Si I<x> est NaN («\ Not a Number\ »), la fonction renvoie NaN avec le signe de I<y>.

note: type: Plain text
en: The B<copysign>(), B<copysignf>(), and B<copysignl>()  functions are thread-safe.
fr: Les fonctions B<copysign>(), B<copysignf>() et B<copysignl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: C99, POSIX.1-2001.  This function is defined in IEC 559 (and the appendix with recommended functions in IEEE 754/IEEE 854).
fr: C99, POSIX.1-2001. Cette fonction est définie dans IEC 559 (et l'annexe avec les fonctions recommandées de IEEE 754/IEEE 854).

note: type: Plain text
en: On architectures where the floating-point formats are not IEEE 754 compliant, these functions may treat a negative zero as positive.
fr: Sur des architectures où le format des nombres flottants n'est pas conforme à IEEE\ 754, ces fonctions peuvent traiter un zéro négatif comme positif.

note: type: Plain text
en: cos, cosf, cosl - cosine function
fr: cos, cosf, cosl - Fonction cosinus

note: type: Plain text
en: B<cosf>(), B<cosl>():
fr: B<cosf>(), B<cosl>() :

note: type: Plain text
en: The B<cos>()  function returns the cosine of I<x>, where I<x> is given in radians.
fr: La fonction B<cos>() renvoie le cosinus de I<x>, celui-ci étant donné en radians.

note: type: Plain text
en: On success, these functions return the cosine of I<x>.
fr: En cas de réussite, ces fonctions renvoient le cosinus de I<x>.

note: type: TP
en: Domain error: I<x> is an infinity
fr: Erreur de domaine : I<x> est une valeur infinie

note: type: Plain text
en: I<errno> is set to B<EDOM> (but see BUGS).  An invalid floating-point exception (B<FE_INVALID>)  is raised.
fr: I<errno> prend la valeur B<EDOM> (mais consultez la section des BOGUES). Une exception indiquant une virgule flottante incorrecte (B<FE_INVALID>) est levée.

note: type: Plain text
en: The B<cos>(), B<cosf>(), and B<cosl>()  functions are thread-safe.
fr: Les fonctions B<cos>(), B<cosf>() et B<cosl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: C99, POSIX.1-2001.  The variant returning I<double> also conforms to SVr4, 4.3BSD.
fr: C99, POSIX.1-2001. La variante renvoyant un I<double> est également conforme à SVr4 et BSD 4.3.

note: http://sourceware.org/bugzilla/show_bug.cgi?id=6782 type: Plain text
en: Before version 2.10, the glibc implementation did not set I<errno> to B<EDOM> when a domain error occurred.
fr: Avant la version 2.10, l'implémentation de la glibc ne positionnait pas I<errno> à B<EDOM> quand une erreur de domaine se produisait.

note: type: Plain text
en: cosh, coshf, coshl - hyperbolic cosine function
fr: cosh, coshf, coshl - Fonction cosinus hyperbolique

note: type: Plain text
en: B<coshf>(), B<coshl>():
fr: B<coshf>(), B<coshl>() :

note: type: Plain text
en: The B<cosh>()  function returns the hyperbolic cosine of I<x>, which is defined mathematically as:
fr: La fonction B<cosh>() renvoie le cosinus hyperbolique de I<x>, qui est défini mathématiquement de la manière suivante :

note: type: Plain text
en: On success, these functions return the hyperbolic cosine of I<x>.
fr: En cas de réussite, ces fonctions renvoient le cosinus hyperbolique de I<x>.

note: type: Plain text
en: If I<x> is +0 or -0, 1 is returned.
fr: Si I<x> vaut +0 ou -0, la valeur renvoyée est 1.

note: type: Plain text
en: If I<x> is positive infinity or negative infinity, positive infinity is returned.
fr: Si I<x> est une valeur infinie positive ou négative, une valeur infinie positive est renvoyée.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return +B<HUGE_VAL>, +B<HUGE_VALF>, or +B<HUGE_VALL>, respectively.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient +B<HUGE_VAL>, +B<HUGE_VALF> ou +B<HUGE_VALL>, respectivement.

note: type: TP
en: Range error: result overflow
fr: Erreur d'intervalle : dépassement pour le résultat

note: type: Plain text
en: I<errno> is set to B<ERANGE>.  An overflow floating-point exception (B<FE_OVERFLOW>)  is raised.
fr: I<errno> est configurée à B<ERANGE>. Une exception de dépassement en virgule flottante (B<FE_OVERFLOW>) est levée.

note: type: Plain text
en: In glibc version 2.3.4 and earlier, an overflow floating-point (B<FE_OVERFLOW>)  exception is not raised when an overflow occurs.
fr: Dans la glibc version 2.3.4 et les précédentes, une exception de dépassement en virgule flottante (B<FE_OVERFLOW>) n'est pas levée quand un dépassement se produit.

note: type: TH
en: 2013-07-05
fr: 5 juillet 2013

note: type: Plain text
en: div, ldiv, lldiv, imaxdiv - compute quotient and remainder of an integer division
fr: div, ldiv, lldiv, imaxdiv - Calculer le quotient et le reste d'une division entière

note: type: Plain text
en: B<div_t div(int >I<numerator>B<, int >I<denominator>B<);>
fr: B<div_t div(int >I<numérateur>B<, int >I<dénominateur>B<);>

note: type: Plain text
en: B<ldiv_t ldiv(long >I<numerator>B<, long >I<denominator>B<);>
fr: B<ldiv_t ldiv(long >I<numérateur>B<, long >I<dénominateur>B<);>

note: type: Plain text
en: B<lldiv_t lldiv(long long >I<numerator>B<, long long >I<denominator>B<);>
fr: B<lldiv_t lldiv(long long >I<numérateur>B<, long long >I<dénominateur>B<);>

note: type: Plain text
en: B<imaxdiv_t imaxdiv(intmax_t >I<numerator>B<, intmax_t >I<denominator>B<);>
fr: B<imaxdiv_t imaxdiv(intmax_t >I<numérateur>B<, intmax_t >I<dénominateur>B<);>

note: type: Plain text
en: B<lldiv>():
fr: B<lldiv>() :

note: type: Plain text
en: The B<div>()  function computes the value I<numerator>/I<denominator> and returns the quotient and remainder in a structure named I<div_t> that contains two integer members (in unspecified order) named I<quot> and I<rem>.  The quotient is rounded toward zero.  The result satisfies I<quot>*I<denominator>+I<rem> = I<numerator>.
fr: La fonction B<div>() calcule le rapport I<numérateur>/I<dénominateur> et renvoie le quotient et le reste dans une structure de type I<div_t> qui comporte deux membres de type entier (dans un ordre non spécifié) nommés I<quot> (le quotient) et I<rem> (le reste, qui se dit I<remainder> en anglais). Le quotient est arrondi vers zéro. Le résultat satisfait la relation I<quot>*I<dénominateur>+I<rem> = I<numérateur>.

note: type: Plain text
en: The B<ldiv>(), B<lldiv>(), and B<imaxdiv>()  functions do the same, dividing numbers of the indicated type and returning the result in a structure of the indicated name, in all cases with fields I<quot> and I<rem> of the same type as the function arguments.
fr: Les fonctions B<ldiv>(), B<lldiv>() et B<imaxdiv>() font la même chose, diviser des nombres de type indiqué et renvoyer le résultat dans une structure de nom indiqué, avec, dans tous les cas, des champs I<quot> et I<rem> de même type que les paramètres de la fonction.

note: type: Plain text
en: The I<div_t> (etc.) structure.
fr: La structure I<div_t> (etc.).

note: type: Plain text
en: The B<div>(), B<ldiv>(), B<lldiv>(), and B<imaxdiv>()  functions are thread-safe.
fr: Les fonctions B<div>(), B<ldiv>(), B<lldiv>() et B<imaxdiv>() sont sûres dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, C89. C99.  The functions B<lldiv>()  and B<imaxdiv>()  were added in C99.
fr: SVr4, BSD\ 4.3, C89, C99. Les fonctions B<lldiv>() et B<imaxdiv>() ont été ajoutées à la norme C99.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: After
fr: Après

note: type: Plain text
en: the values I<q.quot> and I<q.rem> are -1 and -2, respectively.
fr: les valeurs I<q.quot> et I<q.rem> valent respectivement -1 et -2.

note: type: TH
en: 2013-10-29
fr: 29 octobre 2013

note: type: Plain text
en: erf, erff, erfl, - error function
fr: erf, erff, erfl, - Fonctions d'erreur

note: type: Plain text
en: B<erf>():
fr: B<erf>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: B<erff>(), B<erfl>():
fr: B<erff>(), B<erfl>() :

note: type: Plain text
en: The B<erf>()  function returns the error function of I<x>, defined as
fr: La fonction B<erf>() renvoie la fonction d'erreur de I<x>, définie comme

note: type: TP
en:     erf(x) = 2/sqrt(pi)* integral from 0 to x of exp(-t*t) dt
fr:     erf(x) = 2/sqrt(pi)* intégrale de 0 à x de exp(-t*t) dt

note: type: Plain text
en: On success, these functions return the error function of I<x>, a value in the range [-1,\ 1].
fr: En cas de succès, ces fonctions renvoient la fonction d'erreur de I<x>, une valeur dans l'intervalle [-1,\ 1].

note: POSIX.1-2001 documents an optional range error (underflow) for subnormal x; glibc 2.8 does not do this. type: Plain text
en: If I<x> is positive infinity (negative infinity), +1 (-1) is returned.
fr: Si I<x> est une valeur infinie positive (resp. négative), +1 (resp. -1) est renvoyé.

note: type: Plain text
en: If I<x> is subnormal, a range error occurs, and the return value is 2*x/sqrt(pi).
fr: Si I<x> est dénormalisé, une erreur d'intervalle est déclenchée et la valeur de retour est 2*x/sqrt(pi).

note: type: TP
en: Range error: result underflow (I<x> is subnormal)
fr: Erreur d'intervalle\ : résultat en soupassement (I<x> est dénormalisé).

note: e.g., tgamma(-172.5) on glibc 2.8/x86-32 .I errno is set to .BR ERANGE . type: Plain text
en: An underflow floating-point exception (B<FE_UNDERFLOW>)  is raised.
fr: Une exception en virgule flottante de soupassement (B<FE_UNDERFLOW>) est levée.

note: FIXME . Is it intentional that these functions do not set errno? sin() and cos() also don't set errno; bugs have been raised for those functions. type: Plain text
en: These functions do not set I<errno>.
fr: Ces fonctions ne positionnent pas I<errno>.

note: type: Plain text
en: The B<erf>(), B<erff>(), and B<erfl>()  functions are thread-safe.
fr: Les fonctions B<erf>(), B<erff>() et B<erfl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: erfc, erfcf, erfcl - complementary error function
fr: erfc, erfcf, erfcl - Fonctions d'erreur complémentaires

note: type: Plain text
en: B<erfc>():
fr: B<erfc>() :

note: type: Plain text
en: B<erfcf>(), B<erfcl>():
fr: B<erfcf>(), B<erfcl>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600|| _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600|| _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<erfc>()  function returns the complementary error function of I<x>, that is, 1.0 - erf(x).
fr: La fonction B<erfc>() renvoie la fonction d'erreur complémentaire de I<x>, qui vaut 1,0 - erf(x).

note: type: Plain text
en: On success, these functions return the complementary error function of I<x>, a value in the range [0,2].
fr: En cas de réussite, ces fonctions renvoient la fonction d'erreur complémentaire de I<x>, une valeur comprise dans l'intervalle [0,2].

note: type: Plain text
en: If I<x> is positive infinity, +0 is returned.
fr: Si I<x> est une valeur infinie, la valeur renvoyée est +0.

note: type: Plain text
en: If I<x> is negative infinity, +2 is returned.
fr: Si I<x> est une valeur infinie négative, la valeur renvoyée est +2.

note: type: Plain text
en: If the function result underflows and produces an unrepresentable value, the return value is 0.0.
fr: En cas de soupassement (« underflow ») du résultat de la fonction qui produit une valeur non représentable, la valeur de retour est 0,0.

note: e.g., erfc(27) on x86-32 type: Plain text
en: If the function result underflows but produces a representable (i.e., subnormal) value, that value is returned, and a range error occurs.
fr: Si le résultat de la fonction est en soupassement mais produit une valeur représentable (par exemple, dénormalisée), cette valeur est renvoyée et une erreur d'intervalle est déclenchée.

note: type: TP
en: Range error: result underflow (result is subnormal)
fr: Erreur d'intervalle\ : résultat en soupassement (le résultat est dénormalisé).

note: type: Plain text
en: The B<erfc>(), B<erfcf>(), and B<erfcl>()  functions are thread-safe.
fr: Les fonctions B<erfc>(), B<erfcf>() et B<erfcl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The B<erfc>(), B<erfcf>(), and B<erfcl>()  functions are provided to avoid the loss accuracy that would occur for the calculation 1-erf(x) for large values of I<x> (for which the value of erf(x) approaches 1).
fr: Les fonctions B<erfc>(), B<erfcf>() et B<erfcl>() sont fournies pour éviter la perte de précision qui se produirait avec le calcul de 1-erf(x) pour des valeurs de I<x> élevées (pour lesquelles la valeur de erf(x) est proche de 1).

note: type: Plain text
en: exp, expf, expl - base-e exponential function
fr: exp, expf, expl - Fonction exponentielle de base e

note: type: Plain text
en: B<expf>(), B<expl>():
fr: B<expf>(), B<expl>() :

note: type: Plain text
en: The B<exp>()  function returns the value of e (the base of natural logarithms) raised to the power of I<x>.
fr: La fonction B<exp>() renvoie la valeur e (la base des logarithmes naturels), élevée à la puissance I<x>.

note: type: Plain text
en: On success, these functions return the exponential value of I<x>.
fr: En cas de réussite, ces fonctions renvoient la valeur de l'exponentielle de I<x>

note: type: Plain text
en: If I<x> is negative infinity, +0 is returned.
fr: Si I<x> est une valeur infinie négative, +0 est renvoyé.

note: type: Plain text
en: If the result underflows, a range error occurs, and zero is returned.
fr: En cas de soupassement (« underflow ») du résultat, une erreur d'intervalle se produit et zéro est renvoyé.

note: type: TP
en: Range error, overflow
fr: Erreur d'intervalle, dépassement

note: type: TP
en: Range error, underflow
fr: Erreur d'intervalle, soupassement (« underflow »)

note: type: Plain text
en: I<errno> is set to B<ERANGE>.  An underflow floating-point exception (B<FE_UNDERFLOW>)  is raised.
fr: I<errno> prend la valeur B<ERANGE>. Une exception en virgule flottante de soupassement (B<FE_UNDERFLOW>) est levée.

note: type: TH
en: 2008-08-11
fr: 11 août 2008

note: type: Plain text
en: exp10, exp10f, exp10l - base-10 exponential function
fr: exp10, exp10f, exp10l - Fonction exponentielle en base 10

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The B<exp10>()  function returns the value of 10 raised to the power of I<x>.
fr: La fonction B<exp10>() renvoie 10 élevé à la puissance I<x>.

note: type: Plain text
en: On success, these functions return the base-10 exponential value of I<x>.
fr: En cas de réussite, ces fonctions renvoient la valeur de l'exponentielle en base 10 de I<x>.

note: type: Plain text
en: For various special cases, including the handling of infinity and NaN, as well as overflows and underflows, see B<exp>(3).
fr: Pour certains cas particuliers, dont la gestion des infinis et du NaN ou des dépassements et soupassements (« underflow »), consultez B<exp>(3).

note: type: Plain text
en: For a discussion of the errors that can occur for these functions, see B<exp>(3).
fr: Pour une discussion sur les erreurs qui peuvent se produire avec ces fonctions, consultez B<exp>(3).

note: type: Plain text
en: These functions first appeared in glibc in version 2.1.
fr: Ces fonctions ont été introduites dans la glibc dans sa version 2.1.

note: type: Plain text
en: These functions are GNU extensions.
fr: Ces fonctions sont des extensions GNU.

note: type: Plain text
en: exp2, exp2f, exp2l - base-2 exponential function
fr: exp2, exp2f, exp2l - Fonction exponentielle en base 2

note: type: Plain text
en: B<exp2>(), B<exp2f>(), B<exp2l>():
fr: B<exp2>(), B<exp2f>(), B<exp2l>() :

note: type: Plain text
en: The B<exp2>()  function returns the value of 2 raised to the power of I<x>.
fr: La fonction B<exp2>() renvoie 2 élevé à la puissance I<x>.

note: type: Plain text
en: On success, these functions return the base-2 exponential value of I<x>.
fr: En cas de réussite, ces fonctions renvoient la valeur de l'exponentielle en base 2 de I<x>.

note: type: Plain text
en: expm1, expm1f, expm1l - exponential minus 1
fr: expm1, expm1f, expm1l - Exponentielle moins 1

note: type: Plain text
en: B<expm1>():
fr: B<expm1>() :

note: type: Plain text
en: B<expm1f>(), B<expm1l>():
fr: B<expm1f>(), B<expm1l>() :

note: type: Plain text
en: I<expm1(x)> returns a value equivalent to
fr: I<expm1(x)> renvoie une valeur équivalente à :

note: type: Plain text
en: It is computed in a way that is accurate even if the value of I<x> is near zero\(ema case where I<exp(x) - 1> would be inaccurate due to subtraction of two numbers that are nearly equal.
fr: Elle est calculée de telle manière que la précision est conservée même lorsque I<x> est proche de zéro, alors que I<exp(x) - 1> serait imprécise car les deux nombres sont trop proches.

note: type: Plain text
en: On success, these functions return I<exp(x)\ -\ 1>.
fr: En cas de réussite, ces fonctions renvoient I<exp(x)\ -\ 1>.

note: type: Plain text
en: If I<x> is negative infinity, -1 is returned.
fr: Si I<x> est une valeur infinie négative, -1 est renvoyé.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement.

note: POSIX.1 specifies an optional range error (underflow) if x is subnormal.  Glibc does not implement this. type: Plain text
en: I<errno> is set to B<ERANGE> (but see BUGS).  An overflow floating-point exception (B<FE_OVERFLOW>)  is raised.
fr: I<errno> est définie à B<ERANGE> (mais consultez la section des BOGUES). Une exception de dépassement en virgule flottante (B<FE_OVERFLOW>) est levée.

note: type: Plain text
en: The B<expm1>(), B<expm1f>(), and B<expm1l>()  functions are thread-safe.
fr: Les fonctions B<expm1>(), B<expm1f>() et B<expm1l>() sont sûres dans un contexte multithread.

note: FIXME . Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6778 type: Plain text
en: For some large negative I<x> values (where the function result approaches -1), B<expm1>()  raises a bogus underflow floating-point exception.
fr: Pour certaines grandes valeurs négatives de I<x> (pour lesquelles le résultat de la fonction s'approche de -1), B<expm1>() lève à tort une exception de virgule flottante de soupassement (« underflow »).

note: FIXME . Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6814 e.g., expm1(1e5) through expm1(1.00199970127e5), but not expm1(1.00199970128e5) and beyond. type: Plain text
en: For some large positive I<x> values, B<expm1>()  raises a bogus invalid floating-point exception in addition to the expected overflow exception, and returns a NaN instead of positive infinity.
fr: Pour certaines grandes valeurs positives de I<x>, B<expm1>() lève à tort une exception de virgule flottante incorrecte en plus de l'exception de dépassement et renvoie un NaN au lieu d'une valeur infinie positive.

note: It looks like the fix was in 2.11, or possibly 2.12. I have no test system for 2.11, but 2.12 passes. From the source (sysdeps/i386/fpu/s_expm1.S) it looks like the changes were in 2.11. http://sources.redhat.com/bugzilla/show_bug.cgi?id=6788 type: Plain text
en: Before version 2.11, the glibc implementation did not set I<errno> to B<ERANGE> when a range error occurred.
fr: Avant la version 2.11, l'implémentation de la glibc ne définissait pas I<errno> à B<ERANGE> lorsqu'une erreur d'intervalle se produisait.

note: type: TH
en: 2013-07-10
fr: 10 juillet 2013

note: type: Plain text
en: fabs, fabsf, fabsl - absolute value of floating-point number
fr: fabs, fabsf, fabsl - Valeur absolue d'un nombre en virgule flottante

note: type: Plain text
en: B<fabsf>(), B<fabsl>():
fr: B<fabsf>(), B<fabsl>() :

note: type: Plain text
en: These functions return the absolute value of the floating-point number I<x>.
fr: Ces fonctions renvoient la valeur absolue du nombre I<x> en virgule flottante.

note: type: Plain text
en: These functions return the absolute value of I<x>.
fr: Ces fonctions renvoient la valeur absolue du nombre I<x>.

note: type: Plain text
en: If I<x> is -0, +0 is returned.
fr: Si I<x> vaut -0, la valeur renvoyée est +0.

note: type: Plain text
en: If I<x> is negative infinity or positive infinity, positive infinity is returned.
fr: Si I<x> est une valeur infinie positive ou négative, une valeur infinie positive est renvoyée.

note: type: Plain text
en: The B<fabs>(), B<fabsf>(), and B<fabsl>()  functions are thread-safe.
fr: Les fonctions B<fabs>(), B<fabsf>(), et B<fabsl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2013-07-15
fr: 15 juillet 2013

note: type: Plain text
en: fdim, fdimf, fdiml - positive difference
fr: fdim, fdimf, fdiml - Différence positive

note: type: Plain text
en: B<fdimf>(), B<fdiml>():
fr: B<fdimf>(), B<fdiml>() :

note: type: Plain text
en: These functions return the positive difference, max(I<x>-I<y>,0), between their arguments.
fr: Ces fonctions renvoient la différence positive, max(I<x>-I<y>,0), entre leurs deux paramètres.

note: type: Plain text
en: On success, these functions return the positive difference.
fr: En cas de réussite, ces fonctions renvoient la différence positive.

note: type: Plain text
en: If I<x> or I<y> is a NaN, a NaN is returned.
fr: Si I<x> ou I<y> est un NaN, un NaN est renvoyé.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, respectivement.

note: Unable to test this case, since the best approximation of pi/2 in double precision only yields a tan() value of 1.633e16. .I errno is set to .BR ERANGE . type: Plain text
en: An overflow floating-point exception (B<FE_OVERFLOW>)  is raised.
fr: Une exception en virgule flottante de dépassement (B<FE_OVERFLOW>) est levée.

note: type: Plain text
en: The B<fdim>(), B<fdimf>(), and B<fdiml>()  functions are thread-safe.
fr: Les fonctions B<fdim>(), B<fdimf>() et B<fdiml>() sont sûres dans un contexte multithread.

note: type: TH
en: 2014-04-01
fr: 1er avril 2014

note: type: Plain text
en: feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag, fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv, feupdateenv, feenableexcept, fedisableexcept, fegetexcept - floating-point rounding and exception handling
fr: feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag, fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv, feupdateenv, feenableexcept, fedisableexcept, fegetexcept - Gestion des exceptions et des arrondis des nombres flottants

note: type: Plain text
en: These eleven functions were defined in C99, and describe the handling of floating-point rounding and exceptions (overflow, zero-divide, etc.).
fr: Ces onze fonctions ont été définies dans la norme C99, et décrivent la gestion des arrondis des nombres flottants et des exceptions (dépassement, division par zéro, etc.) sur les nombres flottants.

note: type: Plain text
en: The I<divide-by-zero> exception occurs when an operation on finite numbers produces infinity as exact answer.
fr: L'exception I<divide-by-zero> (division par zéro) se produit quand une opération sur des nombres finis donne un résultat infini.

note: type: Plain text
en: The I<overflow> exception occurs when a result has to be represented as a floating-point number, but has (much) larger absolute value than the largest (finite) floating-point number that is representable.
fr: L'exception I<overflow> (dépassement) se produit quand un résultat doit être représenté par un nombre flottant, mais que sa valeur absolue est trop grande pour être représentée par un nombre flottant.

note: type: Plain text
en: The I<underflow> exception occurs when a result has to be represented as a floating-point number, but has smaller absolute value than the smallest positive normalized floating-point number (and would lose much accuracy when represented as a denormalized number).
fr: L'exception I<underflow> (soupassement) se produit quand un résultat doit être représenté par un nombre flottant, mais que sa valeur absolue est trop petite pour être représentée en nombre flottant.

note: type: Plain text
en: The I<inexact> exception occurs when the rounded result of an operation is not equal to the infinite precision result.  It may occur whenever I<overflow> or I<underflow> occurs.
fr: L'exception I<inexact> se produit quand le résultat arrondi d'une opération n'est pas égal au résultat en précision infinie. Elle peut se déclencher quand les exceptions I<overflow> ou I<underflow> se produisent.

note: type: Plain text
en: The I<invalid> exception occurs when there is no well-defined result for an operation, as for 0/0 or infinity - infinity or sqrt(-1).
fr: L'exception I<invalid> se produit quand il n'y a pas de résultat bien défini pour une opération, comme «\ 0/0\ » ou «\ infini-infini\ » ou «\ sqrt(-1)\ ».

note: type: SS
en: Exception handling
fr: Gestion des exceptions

note: type: Plain text
en: Exceptions are represented in two ways: as a single bit (exception present/absent), and these bits correspond in some implementation-defined way with bit positions in an integer, and also as an opaque structure that may contain more information about the exception (perhaps the code address where it occurred).
fr: Les exceptions sont représentées de deux manières\ : en tant qu'un unique bit (exception présente ou absente), et ces bits correspondent, de manière dépendant de l'implémentation, avec une position au sein d'un entier, et aussi en tant que structure opaque pouvant contenir plus d'informations concernant l'exception (éventuellement l'adresse du code déclenchant l'erreur).

note: type: Plain text
en: Each of the macros B<FE_DIVBYZERO>, B<FE_INEXACT>, B<FE_INVALID>, B<FE_OVERFLOW>, B<FE_UNDERFLOW> is defined when the implementation supports handling of the corresponding exception, and if so then defines the corresponding bit(s), so that one can call exception handling functions, for example, using the integer argument B<FE_OVERFLOW>|B<FE_UNDERFLOW>.  Other exceptions may be supported.  The macro B<FE_ALL_EXCEPT> is the bitwise OR of all bits corresponding to supported exceptions.
fr: Chacune des macros B<FE_DIVBYZERO>, B<FE_INEXACT>, B<FE_INVALID>, B<FE_OVERFLOW>, B<FE_UNDERFLOW> est définie lorsque l'implémentation gère l'exception correspondante. Les bits sont alors définis, ainsi on peut appeler, par exemple, les fonctions de gestion des exceptions avec un argument entier B<FE_OVERFLOW>|B<FE_UNDERFLOW>. D'autres exceptions peuvent être supportées. La macro B<FE_ALL_EXCEPT> est un masque au format OU binaire correspondant à toutes les exceptions supportées.

note: type: Plain text
en: The B<feclearexcept>()  function clears the supported exceptions represented by the bits in its argument.
fr: La fonction B<feclearexcept>() efface les exceptions supportées représentées par les bits de son argument.

note: type: Plain text
en: The B<fegetexceptflag>()  function stores a representation of the state of the exception flags represented by the argument I<excepts> in the opaque object I<*flagp>.
fr: La fonction B<fegetexceptflag>() stocke une représentation de l'état des exceptions contenues dans son argument I<excepts> dans l'objet opaque I<*flagp>.

note: type: Plain text
en: The B<feraiseexcept>()  function raises the supported exceptions represented by the bits in I<excepts>.
fr: La fonction B<feraiseexcept>() déclenche les exceptions supportées, représentées par les bits de son argument I<excepts>.

note: type: Plain text
en: The B<fesetexceptflag>()  function sets the complete status for the exceptions represented by I<excepts> to the value I<*flagp>.  This value must have been obtained by an earlier call of B<fegetexceptflag>()  with a last argument that contained all bits in I<excepts>.
fr: La fonction B<fesetexceptflag>() définit l'état des exceptions représentées par l'argument I<excepts> à la valeur I<*flagp>. Cette valeur doit être le résultat d'un appel préalable à B<fegetexceptflag>() avec un dernier argument contenant tous les bits dans I<excepts>.

note: type: Plain text
en: The B<fetestexcept>()  function returns a word in which the bits are set that were set in the argument I<excepts> and for which the corresponding exception is currently set.
fr: La fonction B<fetestexcept>() renvoie un mot dont les bits définis sont également les bits définis dans l'argument I<excepts> et pour lesquels l'exception correspondante est définie.

note: type: SS
en: Rounding mode
fr: Mode d'arrondis

note: type: Plain text
en: The rounding mode determines how the result of floating-point operations is treated when the result cannot be exactly represented in the significand.  Various rounding modes may be provided: round to nearest (the default), round up (toward positive infinity), round down (toward negative infinity), and round toward zero.
fr: Le mode d'arrondi détermine comment le résultat des opérations en virgule flottante doit être traité quand le résultat ne peut pas être représenté exactement dans la mantisse. Plusieurs modes d'arrondis peuvent être fournis\ : arrondi au plus proche (le mode par défaut), arrondi vers le haut (vers l'infini positif), arrondi vers le bas (vers l'infini négatif) et l'arrondi vers zéro.

note: type: Plain text
en: Each of the macros B<FE_TONEAREST>, B<FE_UPWARD>, B<FE_DOWNWARD>, and B<FE_TOWARDZERO> is defined when the implementation supports getting and setting the corresponding rounding direction.
fr: Chacune des macros B<FE_TONEAREST>, B<FE_UPWARD>, B<FE_DOWNWARD> et B<FE_TOWARDZERO> est définie lorsque l'implémentation gère la définition et la lecture de la direction d'arrondi correspondante.

note: type: Plain text
en: The B<fegetround>()  function returns the macro corresponding to the current rounding mode.
fr: La fonction B<fegetround>() renvoie la macro correspondant au mode d'arrondi en cours.

note: type: Plain text
en: The B<fesetround>()  function sets the rounding mode as specified by its argument and returns zero when it was successful.
fr: La fonction B<fesetround>() définit le mode d'arrondi tel qu'il est spécifié par son argument et renvoie zéro en cas de succès.

note: type: Plain text
en: C99 and POSIX.1-2008 specify an identifier, B<FLT_ROUNDS>, defined in I<E<lt>float.hE<gt>>, which indicates the implementation-defined rounding behavior for floating-point addition.  This identifier has one of the following values:
fr: C99 et POSIX.1-2008 spécifient un identifiant, B<FLT_ROUNDS>, défini dans I<E<lt>float.hE<gt>>, qui indique le mode d'arrondi de l'implémentation pour les additions en virgule flottante. Cet identifiant peut prendre une des valeurs suivantes :

note: type: Plain text
en: The rounding mode is not determinable.
fr: Le mode d'arrondi est indéterminé.

note: type: Plain text
en: Rounding is toward 0.
fr: L'arrondi se fait vers 0.

note: type: Plain text
en: Rounding is toward nearest number.
fr: L'arrondi se fait vers le nombre le plus proche.

note: type: Plain text
en: Rounding is toward positive infinity.
fr: L'arrondi se fait vers l'infini positif.

note: type: Plain text
en: Rounding is toward negative infinity.
fr: L'arrondi se fait vers l'infini négatif.

note: type: Plain text
en: Other values represent machine-dependent, nonstandard rounding modes.
fr: Les autres valeurs sont dépendantes des machines, et ne sont pas des modes d'arrondi standard.

note: type: Plain text
en: The value of B<FLT_ROUNDS> should reflect the current rounding mode as set by B<fesetround>()  (but see BUGS).
fr: La valeur de B<FLT_ROUNDS> devrait refléter le mode d'arrondi en cours tel qu'il est configuré par B<fesetround>() (mais consultez la section des BOGUES).

note: type: SS
en: Floating-point environment
fr: Environnement de virgule flottante

note: type: Plain text
en: The entire floating-point environment, including control modes and status flags, can be handled as one opaque object, of type I<fenv_t>.  The default environment is denoted by B<FE_DFL_ENV> (of type I<const fenv_t\ *>).  This is the environment setup at program start and it is defined by ISO C to have round to nearest, all exceptions cleared and a nonstop (continue on exceptions) mode.
fr: L'environnement de virgule flottante, y compris les modes de contrôle et les drapeaux d'état, peuvent être manipulés sous forme d'un objet opaque de type I<fenv_t>. L'environnement par défaut est représenté par B<FE_DFL_ENV> (de type I<const fenv_t\ *>). Il s'agit de la configuration de l'environnement au démarrage d'un programme, et elle est définie par ISO C comme ayant un arrondi au plus proche, toutes les exceptions effacées et un mode sans arrêt (continuer en présence des exceptions).

note: type: Plain text
en: The B<fegetenv>()  function saves the current floating-point environment in the object I<*envp>.
fr: La fonction B<fegetenv>() sauve l'environnement de travail en cours en virgule flottante dans l'objet I<*envp>.

note: type: Plain text
en: The B<feholdexcept>()  function does the same, then clears all exception flags, and sets a nonstop (continue on exceptions) mode, if available.  It returns zero when successful.
fr: La fonction B<feholdexcept>() effectue la même chose, puis efface tous les drapeaux d'exceptions, et bascule si possible sur un mode sans arrêt (continuer en présence des exceptions). Elle renvoie zéro en cas de succès.

note: type: Plain text
en: The B<fesetenv>()  function restores the floating-point environment from the object I<*envp>.  This object must be known to be valid, for example, the result of a call to B<fegetenv>()  or B<feholdexcept>()  or equal to B<FE_DFL_ENV>.  This call does not raise exceptions.
fr: La fonction B<fesetenv>() recharge l'environnement de travail en virgule flottante à partir de l'objet I<*envp>. Cet objet doit être valide, c'est-à-dire être le résultat d'un appel à B<fegetenv>() ou B<feholdexcept>(), ou égal à B<FE_DFL_ENV>. Cet appel ne déclenche pas d'exception.

note: type: Plain text
en: The B<feupdateenv>()  function installs the floating-point environment represented by the object I<*envp>, except that currently raised exceptions are not cleared.  After calling this function, the raised exceptions will be a bitwise OR of those previously set with those in I<*envp>.  As before, the object I<*envp> must be known to be valid.
fr: La fonction B<feupdateenv>() installe l'environnement de virgule flottante représenté par l'objet I<*envp>, sauf que les exceptions déjà déclenchées ne sont pas effacées. Après l'appel de cette fonction, les exceptions déclenchées seront un OU binaire entre l'ensemble précédent, et celui contenu dans I<*envp>. Comme précédemment, l'objet  I<*envp> doit être valide.

note: Earlier seven of these functions were listed as returning void. This was corrected in Corrigendum 1 (ISO/IEC 9899:1999/Cor.1:2001(E)) of the C99 Standard. type: Plain text
en: These functions return zero on success and nonzero if an error occurred.
fr: Ces fonctions renvoient 0 en cas de succès et une valeur non nulle en cas d'erreur.

note: type: Plain text
en: The B<feclearexcept>(), B<fegetexceptflag>(), B<fegetexceptflag>(), B<fesetexceptflag>(), B<fetestexcept>(), B<fegetround>(), B<fesetround>(), B<fegetenv>(), B<feholdexcept>(), B<fesetenv>(), B<feupdateenv>(), B<feenableexcept>(), B<fedisableexcept>(), and B<fegetexcept>()  functions are thread-safe.
fr: Les fonctions B<feclearexcept>(), B<fegetexceptflag>(), B<fegetexceptflag>(), B<fesetexceptflag>(), B<fetestexcept>(), B<fegetround>(), B<fesetround>(), B<fegetenv>(), B<feholdexcept>(), B<fesetenv>(), B<feupdateenv>(), B<feenableexcept>(), B<fedisableexcept>() et B<fegetexcept>() sont sûres dans un contexte multithread.

note: type: SS
en: Glibc notes
fr: Notes sur la glibc

note: type: Plain text
en: If possible, the GNU C Library defines a macro B<FE_NOMASK_ENV> which represents an environment where every exception raised causes a trap to occur.  You can test for this macro using B<#ifdef>.  It is defined only if B<_GNU_SOURCE> is defined.  The C99 standard does not define a way to set individual bits in the floating-point mask, for example, to trap on specific flags.  Since version 2.2, glibc supports the functions B<feenableexcept>()  and B<fedisableexcept>()  to set individual floating-point traps, and B<fegetexcept>()  to query the state.
fr: Si possible, la bibliothèque GNU C définit une macro B<FE_NOMASK_ENV> qui représente un environnement où toutes les exceptions déclenchées entraînent une interception. La présence de cette macro peut être testée en utilisant B<#ifdef>. Elle n'est définie que si B<_GNU_SOURCE> est définie. Le standard C99 ne définit pas de méthode pour positionner les bits individuels dans le masque de virgule flottante, par exemple pour intercepter des drapeaux particuliers. Depuis la version 2.2, la glibc gère B<feenableexcept>() et B<fedisableexcept>() pour définir individuellement des interceptions de virgules flottantes, et B<fegetexcept>() pour demander l'état.

note: type: Plain text
en: The B<feenableexcept>()  and B<fedisableexcept>()  functions enable (disable) traps for each of the exceptions represented by I<excepts> and return the previous set of enabled exceptions when successful, and -1 otherwise.  The B<fegetexcept>()  function returns the set of all currently enabled exceptions.
fr: Les fonctions B<feenableexcept>() et B<fedisableexcept>() activent (désactivent) les interceptions pour chaque exception représentée par I<excepts> et renvoient l'ensemble précédent des exceptions activées lorsqu'elles réussissent, et -1 sinon. La fonction B<fegetexcept>() renvoie l'ensemble des exceptions actuellement activées.

note: Aug 08, glibc 2.8 See http://gcc.gnu.org/ml/gcc/2002-02/msg01535.html type: Plain text
en: C99 specifies that the value of B<FLT_ROUNDS> should reflect changes to the current rounding mode, as set by B<fesetround>().  Currently, this does not occur: B<FLT_ROUNDS> always has the value 1.
fr: C99 spécifie que la valeur de B<FLT_ROUNDS> devrait refléter les changements du mode d'arrondi en cours, tels qu'il est configuré par B<fesetround>(). Actuellement, ce n'est pas le cas : B<FLT_ROUNDS> prend toujours la valeur 1.

note: type: TH
en: 2013-07-22
fr: 22 juillet 2013

note: type: Plain text
en: finite, finitef, finitel, isinf, isinff, isinfl, isnan, isnanf, isnanl - BSD floating-point classification functions
fr: finite, finitef, finitel, isinf, isinff, isinfl, isnan, isnanf, isnanl - Fonctions BSD de classification en virgule flottante

note: type: Plain text
en: B<finite>(), B<finitef>(), B<finitel>():
fr: B<finite>(), B<finitef>(), B<finitel>() :

note: type: Plain text
en: B<isinf>():
fr: B<isinf>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE

note: type: Plain text
en: B<isinff>(), B<isinfl>():
fr: B<isinff>(), B<isinfl>() :

note: type: Plain text
en: B<isnan>():
fr: B<isnan>() :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE || _ISOC99_SOURCE;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE || _ISOC99_SOURCE

note: type: Plain text
en: B<isnanf>(), B<isnanl>():
fr: B<isnanf>(), B<isnanl>() :

note: type: Plain text
en: The B<finite>(), B<finitef>(), and B<finitel>()  functions return a nonzero value if I<x> is neither infinite nor a "not-a-number" (NaN) value, and 0 otherwise.
fr: Les fonctions B<finite>(), B<finitef>() et B<finitel>() renvoient une valeur non nulle si I<x> n'est ni infini, ni une valeur NaN (« Not a Number », ce qui signifie « pas un nombre »), et 0 autrement.

note: type: Plain text
en: The B<isnan>(), B<isnanf>(), and B<isnanl>()  functions return a nonzero value if I<x> is a NaN value, and 0 otherwise.
fr: Les fonctions B<isnan>(), B<isnanf>() et B<isnanl>() renvoient une valeur non nulle si I<x> est un NaN et 0 autrement.

note: type: Plain text
en: The B<isinf>(), B<isinff>(), and B<isinfl>()  functions return 1 if I<x> is positive infinity, -1 if I<x> is negative infinity, and 0 otherwise.
fr: Les fonctions B<isinf>(), B<isinff>() et B<isinfl>() renvoient 1 si I<x> est un valeur infinie positive, -1 si I<x> est une valeur infinie négative, 0 sinon.

note: type: Plain text
en: The B<finite>(), B<finitef>(), B<finitel>(), B<isinf>(), B<isinff>(), B<isinfl>(), B<isnan>(), B<isnanf>(), and B<isnanl>()  functions are thread-safe.
fr: Les fonctions B<finite>(), B<finitef>(), B<finitel>(), B<isinf>(), B<isinff>(), B<isinfl>(), B<isnan>(), B<isnanf>() et B<isnanl>() sont sûres dans un contexte multithread.

note: finite* not on HP-UX; they exist on Tru64. .SH HISTORY The .BR finite () function occurs in 4.3BSD. see IEEE.3 in the 4.3BSD manual type: Plain text
en: Note that these functions are obsolete.  C99 defines macros B<isfinite>(), B<isinf>(), and B<isnan>()  (for all types) replacing them.  Further note that the C99 B<isinf>()  has weaker guarantees on the return value.  See B<fpclassify>(3).
fr: Notez que ces fonctions sont obsolètes, C99 définit les macros B<isfinite>(), B<isinf>() et B<isnan>() (pour tous les types) les remplaçant. Notez de plus que la macro C99 B<isinf>() a moins de garanties sur sa valeur de retour. Consultez B<fpclassify>(3).

note: type: TH
en: 2013-07-23
fr: 23 juillet 2013

note: type: Plain text
en: floor, floorf, floorl - largest integral value not greater than argument
fr: floor, floorf, floorl - Le plus grand entier inférieur ou égal à x

note: type: Plain text
en: B<floorf>(), B<floorl>():
fr: B<floorf>(), B<floorl>() :

note: type: Plain text
en: These functions return the largest integral value that is not greater than I<x>.
fr: Ces fonctions renvoient la plus grande valeur entière qui n'est pas strictement supérieure à I<x>.

note: type: Plain text
en: For example, I<floor(0.5)> is 0.0, and I<floor(-0.5)> is -1.0.
fr: Par exemple, I<floor(0,5)> vaut 0,0 et I<floor(-0,5)> vaut -1,0.

note: type: Plain text
en: These functions return the floor of I<x>.
fr: Ces fonctions renvoient la partie entière de I<x>.

note: type: Plain text
en: If I<x> is integral, +0, -0, NaN, or an infinity, I<x> itself is returned.
fr: Si I<x> est un nombre entier, +0, -0, NaN ou une valeur infinie, la valeur I<x> elle-même est renvoyée.

note: type: Plain text
en: The B<floor>(), B<floorf>(), and B<floorl>()  functions are thread-safe.
fr: Les fonctions B<floor>(), B<floorf>() et B<floorl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2013-09-17
fr: 17 septembre 2013

note: type: Plain text
en: fma, fmaf, fmal - floating-point multiply and add
fr: fma, fmaf, fmal - Multiplication et addition en virgule flottante

note: type: Plain text
en: B<fma>(), B<fmaf>(), B<fmal>():
fr: B<fma>(), B<fmaf>(), B<fmal>() :

note: type: Plain text
en: The B<fma>()  function computes I<x> * I<y> + I<z>.  The result is rounded as one ternary operation according to the current rounding mode (see B<fenv>(3)).
fr: La fonction B<fma>() calcule I<x> * I<y> + I<z>. Le résultat est arrondi à la fin suivant le mode d'arrondi (consultez B<fenv>(3)).

note: type: Plain text
en: These functions return the value of I<x> * I<y> + I<z>, rounded as one ternary operation.
fr: Ces fonctions renvoient la valeur de I<x> * I<y> + I<z>, arrondie comme une seule opération ternaire.

note: type: Plain text
en: If I<x> times I<y> is an exact infinity, and I<z> is an infinity with the opposite sign, a domain error occurs, and a NaN is returned.
fr: Si I<x> fois I<y> est exactement un infini et I<z> est un infini de signe opposé, une erreur de domaine se produit et NaN est renvoyé.

note: POSIX.1-2008 allows some possible differences for the following two domain error cases, but on Linux they are treated the same (AFAICS). Nevertheless, we'll mirror POSIX.1 and describe the two cases separately. POSIX.1 says that a NaN or an implementation-defined value shall be returned for this cas
en: If one of I<x> or I<y> is an infinity, the other is 0, and I<z> is not a NaN, a domain error occurs, and a NaN is returned.
fr: Si I<x> ou I<y> est une valeur infinie et si l'autre vaut 0 et si I<z> n'est pas un NaN, une erreur de domaine est produite et un NaN est renvoyé.

note: POSIX.1 makes the domain error optional for this case. type: Plain text
en: If one of I<x> or I<y> is an infinity, and the other is 0, and I<z> is a NaN, a domain error occurs, and a NaN is returned.
fr: Si I<x> ou I<y> est une valeur infinie et si l'autre vaut 0 et si I<z> est un NaN, une erreur de domaine est produite et un NaN est renvoyé.

note: type: Plain text
en: If I<x> times I<y> is not an infinity times zero (or vice versa), and I<z> is a NaN, a NaN is returned.
fr: Si I<x> fois I<y> n'est pas une valeur infinie fois zéro (ou vice versa) et si I<z> est un NaN, un NaN est renvoyé.

note: type: Plain text
en: If the result overflows, a range error occurs, and an infinity with the correct sign is returned.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et un infini du bon signe est renvoyé.

note: type: Plain text
en: If the result underflows, a range error occurs, and a signed 0 is returned.
fr: En cas de soupassement (« underflow ») du résultat, une erreur d'intervalle se produit et un zéro signé est renvoyé.

note: type: TP
en: Domain error: I<x> * I<y> + I<z>, or I<x> * I<y> is invalid and I<z> is not a NaN
fr: Erreur de domaine : I<x> * I<y> + I<z> ou I<x> * I<y> n'est pas correct et I<z> n'est pas un NaN

note: .I errno is set to .BR EDOM . type: Plain text
en: An invalid floating-point exception (B<FE_INVALID>)  is raised.
fr: Une exception indiquant une virgule flottante incorrecte (B<FE_INVALID>) est levée.

note: type: TP
en: Range error: result underflow
fr: Erreur d'intervalle : soupassement (« underflow ») du résultat

note: type: Plain text
en: The B<fma>(), B<fmaf>(), and B<fmal>()  functions are thread-safe.
fr: Les fonctions B<fma>(), B<fmaf>(), et B<fmal>() sont sûres dans un contexte multithread.

note: type: Plain text
en: fmax, fmaxf, fmaxl - determine maximum of two floating-point numbers
fr: fmax, fmaxf, fmaxl - Trouver le maximum de deux nombres en virgule flottante

note: type: Plain text
en: B<fmax>(), B<fmaxf>(), B<fmaxl>():
fr: B<fmax>(), B<fmaxf>(), B<fmaxl>() :

note: type: Plain text
en: These functions return the larger value of I<x> and I<y>.
fr: Ces fonctions renvoient la valeur maximale entre I<x> et I<y>.

note: type: Plain text
en: These functions return the maximum of I<x> and I<y>.
fr: Ces fonctions renvoient la valeur maximale entre I<x> et I<y>.

note: type: Plain text
en: If one argument is a NaN, the other argument is returned.
fr: Si un des paramètres est un NaN, l'autre paramètre est renvoyé.

note: type: Plain text
en: If both arguments are NaN, a NaN is returned.
fr: Si les deux paramètres sont des NaN (pas un nombre : « Not a Number »), un NaN est renvoyé.

note: type: Plain text
en: The B<fmax>(), B<fmaxf>(), and B<fmaxl>()  functions are thread-safe.
fr: Les fonctions B<fmax>(), B<fmaxf>(), et B<fmaxl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: fmin, fminf, fminl - determine minimum of two floating-point numbers
fr: fmin, fminf, fminl - Trouver le minimum de deux nombres en virgule flottante

note: type: Plain text
en: B<fmin>(), B<fminf>(), B<fminl>():
fr: B<fmin>(), B<fminf>(), B<fminl>() :

note: type: Plain text
en: These functions return the lesser value of I<x> and I<y>.
fr: Ces fonctions renvoient la valeur minimale entre I<x> et I<y>.

note: type: Plain text
en: These functions return the minimum of I<x> and I<y>.
fr: Ces fonctions renvoient le minimum de I<x> et I<y>.

note: type: Plain text
en: The B<fmin>(), B<fminf>(), and B<fminl>()  functions are thread-safe.
fr: Les fonctions B<fmin>(), B<fminf>() et B<fminl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2012-03-15
fr: 15 mars 2012

note: type: Plain text
en: fmod, fmodf, fmodl - floating-point remainder function
fr: fmod, fmodf, fmodl - Fonction modulo réel

note: type: Plain text
en: B<fmodf>(), B<fmodl>():
fr: B<fmodf>(), B<fmodl>() :

note: type: Plain text
en: The B<fmod>()  function computes the floating-point remainder of dividing I<x> by I<y>.  The return value is I<x> - I<n> * I<y>, where I<n> is the quotient of I<x> / I<y>, rounded toward zero to an integer.
fr: La fonction B<fmod>() calcule le reste, en virgule flottante, de la division de I<x> par I<y>. La valeur renvoyée est I<x> - I<n> * I<y>, où I<n> est le quotient I<x> / I<y>, arrondi à l'entier inférieur en valeur absolue.

note: type: Plain text
en: On success, these functions return the value I<x>\ -\ I<n>*I<y>, for some integer I<n>, such that the returned value has the same sign as I<x> and a magnitude less than the magnitude of I<y>.
fr: En cas de réussite, ces fonctions renvoient la valeur I<x>\ -\ I<n>*I<y>, pour un entier I<n> tel que la valeur de retour a le même signe que I<x> et une norme inférieure à la norme de I<y>.

note: type: Plain text
en: If I<x> is an infinity, a domain error occurs, and a NaN is returned.
fr: Si I<x> est une valeur infinie, une erreur de domaine est produite et un NaN est renvoyé.

note: type: Plain text
en: If I<y> is zero, a domain error occurs, and a NaN is returned.
fr: Si I<y> vaut zéro, une erreur de domaine est produite et un NaN est renvoyé.

note: type: Plain text
en: If I<x> is +0 (-0), and I<y> is not zero, +0 (-0) is returned.
fr: Si I<x> vaut +0 (resp. -0), et I<y> n'est pas nul, +0 (resp. -0) est renvoyé.

note: [XXX see bug above] and \fIx\fP is not a NaN type: TP
en: Domain error: I<y> is zero
fr: Erreur de domaine : I<y> est nul.

note: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6784 type: Plain text
en: Before version 2.10, the glibc implementation did not set I<errno> to B<EDOM> when a domain error occurred for an infinite I<x>.
fr: Avant la version 2.10, l'implémentation de la glibc ne définissait pas I<errno> à B<EDOM> lorsqu'une erreur de domaine pour un I<x> infini.

note: type: TH
en: 2013-08-06
fr: 6 août 2013

note: type: Plain text
en: fpclassify, isfinite, isnormal, isnan, isinf - floating-point classification macros
fr: fpclassify, isfinite, isnormal, isnan, isinf - Macros de classification en virgule flottante

note: type: Plain text
en: B<fpclassify>(), B<isfinite>(), B<isnormal>():
fr: B<fpclassify>(), B<isfinite>(), B<isnormal>() :

note: type: Plain text
en: Floating point numbers can have special values, such as infinite or NaN.  With the macro B<fpclassify(>I<x>B<)> you can find out what type I<x> is.  The macro takes any floating-point expression as argument.  The result is one of the following values:
fr: Les nombres en virgule flottante peuvent avoir des valeurs spéciales, telles que infini ou NaN. Avec la macro B<fpclassify(>I<x>B<)>, il est possible de connaître le type de I<x>. La macro prend en paramètre n'importe quelle expression en virgule flottante. Le résultat est l'une des valeurs suivantes\ :

note: type: Plain text
en: I<x> is "Not a Number".
fr: I<x> est non numérique (NaN, pour «\ Not a Number\ »).

note: type: Plain text
en: I<x> is either positive infinity or negative infinity.
fr: I<x> est une valeur infinie positive ou négative.

note: type: Plain text
en: I<x> is zero.
fr: I<x> est nul.

note: type: Plain text
en: I<x> is too small to be represented in normalized format.
fr: I<x> est trop petit pour être représenté au format normalisé.

note: type: Plain text
en: if nothing of the above is correct then it must be a normal floating-point number.
fr: si aucune des valeurs précédentes n'est vraie, alors c'est qu'il doit s'agir d'un nombre à virgule flottante normal.

note: type: Plain text
en: The other macros provide a short answer to some standard questions.
fr: Les autres macros fournissent une réponse courte à des questions standard.

note: type: Plain text
en: returns a nonzero value if
fr: renvoie une valeur non nulle si

note: type: Plain text
en: returns a nonzero value if (fpclassify(x) == FP_NORMAL)
fr: renvoie une valeur non nulle si (fpclassify(x) == FP_NORMAL)

note: type: Plain text
en: returns a nonzero value if (fpclassify(x) == FP_NAN)
fr: renvoie une valeur non nulle si (fpclassify(x) == FP_NAN)

note: type: Plain text
en: returns 1 if I<x> is positive infinity, and -1 if I<x> is negative infinity.
fr: renvoie 1 si I<x> est une valeur infinie positive, et -1 si I<x> est une valeur infinie négative.

note: type: Plain text
en: The B<fpclassify>(), B<isfinite>(), B<isnormal>(), B<isnan>(), and B<isinf>()  macros are thread-safe.
fr: Les macros B<fpclassify>(), B<isfinite>(), B<isnormal>(), B<isnan>() et B<isinf>() sont sûres dans un contexte multithread.

note: type: Plain text
en: For B<isinf>(), the standards merely say that the return value is nonzero if and only if the argument has an infinite value.
fr: Pour B<isinf>(), les normes indiquent simplement que la valeur de retour est non nulle si et seulement si le paramètre a une valeur infinie.

note: type: Plain text
en: In glibc 2.01 and earlier, B<isinf>()  returns a nonzero value (actually: 1) if I<x> is positive infinity or negative infinity.  (This is all that C99 requires.)
fr: Dans la glibc\ 2.01 et les versions précédentes, B<isinf>() renvoie une valeur non nulle (habituellement, 1) si I<x> est une valeur infinie positive ou négative. C'est tout ce qu'exige C99.

note: type: Plain text
en: frexp, frexpf, frexpl - convert floating-point number to fractional and integral components
fr: frexp, frexpf, frexpl - Conversion de réel en fraction normalisée

note: type: Plain text
en: B<frexpf>(), B<frexpl>():
fr: B<frexpf>(), B<frexpl>() :

note: type: Plain text
en: The B<frexp>()  function is used to split the number I<x> into a normalized fraction and an exponent which is stored in I<exp>.
fr: La fonction B<frexp>() est utilisée pour convertir le nombre I<x> en une fraction normalisée et un exposant qui est stocké dans I<exp>.

note: type: Plain text
en: The B<frexp>()  function returns the normalized fraction.  If the argument I<x> is not zero, the normalized fraction is I<x> times a power of two, and its absolute value is always in the range 1/2 (inclusive) to 1 (exclusive), that is, [0.5,1).
fr: La fonction B<frexp>() renvoie la fraction normalisée. Si l'argument I<x> est non nul, la fraction normalisée est I<x> multiplié par 2^I<exp>. La valeur absolue de la fraction normalisée est comprise dans l'intervalle compris entre 1/2 (inclus) et 1 (exclu), c'est-à-dire [1/2,\ 1[.

note: type: Plain text
en: If I<x> is zero, then the normalized fraction is zero and zero is stored in I<exp>.
fr: Si I<x> est nul, la fraction normalisée vaut zéro et I<exp> prend la valeur zéro.

note: type: Plain text
en: If I<x> is a NaN, a NaN is returned, and the value of I<*exp> is unspecified.
fr: Si I<x> est un NaN (pas un nombre : « Not a Number »), un NaN est renvoyé et la valeur de I<*exp> n'est pas spécifiée.

note: type: Plain text
en: If I<x> is positive infinity (negative infinity), positive infinity (negative infinity) is returned, and the value of I<*exp> is unspecified.
fr: Si I<x> est une valeur infinie positive (resp. négative), une valeur infinie positive (resp. négative) est renvoyée et la valeur de I<*exp> n'est pas spécifiée.

note: type: Plain text
en: The B<frexp>(), B<frexpf>(), and B<frexpl>()  functions are thread-safe.
fr: Les fonctions B<frexp>(), B<frexpf>() et B<frexpl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The program below produces results such as the following:
fr: Le programme ci-dessous affiche les résultats suivants\ :

note: type: SS
en: Program source
fr: Source du programme

note: type: TH
en: 2008-08-05
fr: 5 août 2008

note: type: Plain text
en: gamma, gammaf, gammal - (logarithm of the) gamma function
fr: gamma, gammaf, gammal - Logarithme de la fonction Gamma

note: type: Plain text
en: B<gamma>():
fr: B<gamma>() :

note: type: Plain text
en: B<gammaf>(), B<gammal>():
fr: B<gammaf>(), B<gammal>() :

note: type: Plain text
en: These functions are deprecated: instead, use either the B<tgamma>(3)  or the B<lgamma>(3)  functions, as appropriate.
fr: Ces fonctions sont obsolètes : à la place, utilisez B<tgamma>(3) ou B<lgamma>(3), suivant le cas.

note: type: Plain text
en: For the definition of the Gamma function, see B<tgamma>(3).
fr: Pour la définition de la fonction Gamma, consultez B<tgamma>(3).

note: type: SS
en: *BSD version
fr: Versions BSD*

note: type: Plain text
en: The libm in 4.4BSD and some versions of FreeBSD had a B<gamma>()  function that computes the Gamma function, as one would expect.
fr: La libm de BSD\ 4.4 et de certaines versions de FreeBSD avait une fonction B<gamma>() qui calculait la fonction Gamma, comme on s'y attend.

note: type: SS
en: glibc version
fr: Version glibc

note: type: Plain text
en: Glibc has a B<gamma>()  function that is equivalent to B<lgamma>(3)  and computes the natural logarithm of the Gamma function.
fr: La glibc a une fonction B<gamma>() qui est équivalente à B<lgamma>(3) et qui calcule le logarithme népérien (ou naturel) de la fonction Gamma.

note: type: Plain text
en: See B<lgamma>(3).
fr: Consultez B<lgamma>(3).

note: type: Plain text
en: Because of historical variations in behavior across systems, this function is not specified in any standard.
fr: Du fait de variations dans le comportement de cette fonction sur les différents systèmes, cette fonction n'est spécifiée dans aucune norme.

note: type: SS
en: History
fr: Historique

note: type: Plain text
en: 4.2BSD had a B<gamma>()  that computed ln(|Gamma(|I<x>|)|), leaving the sign of Gamma(|I<x>|)  in the external integer I<signgam>.  In 4.3BSD the name was changed to B<lgamma>(3), and the man page promises
fr: BSD\ 4.2 avait une fonction B<gamma>() qui calculait ln(|Gamma(|I<x>|)|), laissant le signe de Gamma(|I<x>|)  dans l'entier externe I<signgam>. Dans BSD\ 4.3, le nom a été modifié en B<lgamma>(3), et la page de manuel promettait\ :

note: type: Plain text
en: At some time in the future the name gamma will be rehabilitated and used for the Gamma function
fr: Un jour où l'autre, le nom gamma sera réhabilité et utilisé pour la fonction Gamma.

note: The FreeBSD man page says about gamma() that it is like lgamma() except that is does not set signgam. Also, that 4.4BSD has a gamma() that computes the true gamma function. type: Plain text
en: This did indeed happen in 4.4BSD, where B<gamma>()  computes the Gamma function (with no effect on I<signgam>).  However, this came too late, and we now have B<tgamma>(3), the "true gamma" function.
fr: Cela est vraiment arrivé dans BSD 4.4 où B<gamma>() calcule la fonction Gamma (sans effet sur I<signgam>). Toutefois, cela est venu trop tard, et maintenant nous avons B<tgamma>(3), la vraie fonction gamma (Ndt\ : «\ true gamma\ »).

note: type: Plain text
en: hypot, hypotf, hypotl - Euclidean distance function
fr: hypot, hypotf, hypotl - Distance euclidienne

note: type: Plain text
en: B<hypot>():
fr: B<hypot>() :

note: type: Plain text
en: B<hypotf>(), B<hypotl>():
fr: B<hypotf>(), B<hypotl>()\ :

note: type: Plain text
en: The B<hypot>()  function returns sqrt(I<x>*I<x>+I<y>*I<y>).  This is the length of the hypotenuse of a right-angled triangle with sides of length I<x> and I<y>, or the distance of the point (I<x>,I<y>)  from the origin.
fr: La fonction B<hypot>() renvoie la valeur sqrt(I<x>*I<x>+I<y>*I<y>). C'est la longueur de l'hypoténuse d'un triangle rectangle de côtés I<x> et I<y>. C'est également la distance entre un point de coordonnées (I<x>,I<y>)  et l'origine.

note: e.g., hypot(DBL_MIN, DBL_MIN) does the right thing, as does, say hypot(DBL_MAX/2.0, DBL_MAX/2.0). type: Plain text
en: The calculation is performed without undue overflow or underflow during the intermediate steps of the calculation.
fr: Le calcul est effectué sans dépassement (« overflow ») ni soupassement (« underflow ») dans les étapes intermédiaires du calcul.

note: type: Plain text
en: On success, these functions return the length of a right-angled triangle with sides of length I<x> and I<y>.
fr: En cas de réussite, ces fonction renvoient la longueur de l'hypoténuse d'un triangle rectangle de côtés de longueurs I<x> et I<y>.

note: type: Plain text
en: If I<x> or I<y> is an infinity, positive infinity is returned.
fr: Si I<x> ou I<y> est une valeur infinie, une valeur infinie positive est renvoyée.

note: type: Plain text
en: If I<x> or I<y> is a NaN, and the other argument is not an infinity, a NaN is returned.
fr: Si I<x> ou I<y> est un NaN (pas un nombre : « Not a Number »), et l'autre paramètre n'est pas infini, un NaN est renvoyé.

note: Actually, could the result not be subnormal if both arguments are subnormal?  I think not -- mtk, Jul 2008 type: Plain text
en: If both arguments are subnormal, and the result is subnormal, a range error occurs, and the correct result is returned.
fr: Si les deux paramètres sont dénormalisés et le résultat est dénormalisé, une erreur d'intervalle est déclenchée, et le résultat correct est renvoyé.

note: FIXME . Is it intentional that these functions do not set errno? They do set errno for the y == 0 case, below. Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6783 type: Plain text
en: These functions do not set I<errno> for this case.
fr: Ces fonctions ne positionnent pas I<errno> dans ce cas.

note: type: Plain text
en: ilogb, ilogbf, ilogbl - get integer exponent of a floating-point value
fr: ilogb, ilogbf, ilogbl - Obtenir l'exposant entier d'un nombre en virgule flottante

note: type: Plain text
en: B<ilogb>():
fr: B<ilogb>() :

note: type: Plain text
en: B<ilogbf>(), B<ilogbl>():
fr: B<ilogbf>(), B<ilogbl>()\ :

note: type: Plain text
en: These functions return the exponent part of their argument as a signed integer.  When no error occurs, these functions are equivalent to the corresponding B<logb>(3)  functions, cast to I<int>.
fr: Ces fonctions renvoient l'exposant de leur argument sous forme d'entier signé. Si aucune erreur ne se produit, ces fonctions sont équivalentes aux fonctions B<logb>(3) avec un transtypage vers le type I<int>.

note: type: Plain text
en: On success, these functions return the exponent of I<x>, as a signed integer.
fr: En cas de succès, ces fonctions renvoient l'exposant de I<x> sous forme d'entier signé.

note: the POSIX.1 spec for logb() says logb() gives pole error for this case, but for ilogb() it says domain error. glibc: The numeric value is either `INT_MIN' or `-INT_MAX'. type: Plain text
en: If I<x> is zero, then a domain error occurs, and the functions return B<FP_ILOGB0>.
fr: Si I<x> est nul, cela cause une erreur d'intervalle et les fonctions renvoient B<FP_ILOGB0>.

note: glibc: The numeric value is either `INT_MIN' or `INT_MAX'. On i386, FP_ILOGB0 and FP_ILOGBNAN have the same value. type: Plain text
en: If I<x> is a NaN, then a domain error occurs, and the functions return B<FP_ILOGBNAN>.
fr: Si I<x> n'est pas un nombre (NaN), cela cause une erreur d'intervalle et les fonctions renvoient B<FP_ILOGBNAN>.

note: POSIX.1-2001 also says: If the correct value is greater than {INT_MAX}, {INT_MAX} shall be returned and a domain error shall occur. If the correct value is less than {INT_MIN}, {INT_MIN} type: Plain text
en: If I<x> is negative infinity or positive infinity, then a domain error occurs, and the functions return B<INT_MAX>.
fr: Si I<x> est l'infini négatif ou positif, cela cause une erreur d'intervalle et les fonctions renvoient B<INT_MAX>.

note: type: TP
en: Domain error: I<x> is 0 or a NaN
fr: Erreur d'intervalle : I<x> est nul ou n'est pas un nombre (NaN)

note: FIXME . Is it intentional that these functions do not set errno, or raise an exception? log(), log2(), log10() do set errno Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6794 type: Plain text
en: These functions do not set I<errno> or raise an exception for this case.
fr: Ces fonctions ne positionnent pas I<errno> et ne lèvent pas d'exception dans ce cas.

note: type: Plain text
en: The B<ilogb>(), B<ilogbf>(), and B<ilogbl>()  functions are thread-safe.
fr: Les fonctions B<ilogb>(), B<ilogbf>() et B<ilogbl>() sont sûres dans un contexte multithread.

note: type: TH
en: 1993-06-02
fr: 2 juin 1993

note: type: Plain text
en: infnan - deal with infinite or not-a-number (NaN) result
fr: infnan - Traiter un résultat infini ou non numérique (NaN)

note: type: Plain text
en: The B<infnan>()  function returns a suitable value for infinity and "not-a-number" (NaN) results.  The value of I<error> can be B<ERANGE> to represent infinity or anything else to represent NaN.  I<errno> is also set.
fr: La fonction B<infnan>()  renvoie une valeur acceptable pour un résultat infini ou non numérique (NaN, « Not a Number »). La valeur I<error> peut être B<ERANGE> pour indiquer l'infini, ou n'importe quoi d'autre pour représenter NaN. I<errno> est également renseignée.

note: type: Plain text
en: If I<error> is B<ERANGE> (Infinity), B<HUGE_VAL> is returned.
fr: Si I<error> vaut B<ERANGE> (infini), B<HUGE_VAL> est renvoyé.

note: type: Plain text
en: If I<error> is -B<ERANGE> (-Infinity), -B<HUGE_VAL> is returned.
fr: Si I<error> vaut B<-ERANGE> (-infini), -B<HUGE_VAL> est renvoyé.

note: type: Plain text
en: If I<error> is anything else, NAN is returned.
fr: Si I<error> vaut autre chose, NAN est renvoyé.

note: type: Plain text
en: The value of I<error> is "not-a-number" (NaN).
fr: La valeur de I<error> est non numérique (NaN).

note: type: Plain text
en: The value of I<error> is positive infinity or negative infinity.
fr: La valeur de I<error> est infinie (positive ou négative).

note: type: Plain text
en: 4.3BSD.
fr: BSD\ 4.3.

note: type: Plain text
en: This obsolete function was provided in libc4 and libc5, but is not available in glibc2.
fr: Cette fonction, obsolète, était fournie dans la libc4 et la libc5, mais n'est plus disponible dans la glibc\ 2.

note: type: TH
en: 2014-01-27
fr: 27 janvier 2014

note: type: Plain text
en: isgreater, isgreaterequal, isless, islessequal, islessgreater, isunordered - floating-point relational tests without exception for NaN
fr: isgreater, isgreaterequal, isless, islessequal, islessgreater, isunordered - Relations d'ordre pour nombre à virgule flottante, sans exception pour NaN

note: type: Plain text
en: All functions described here:
fr: Toutes les fonctions définies ici :

note: type: Plain text
en: The normal relation operations (like B<E<lt>>, "less than")  will fail if one of the operands is NaN.  This will cause an exception.  To avoid this, C99 defines the macros listed below.
fr: Les opérations de relation usuelles (comme B<E<lt>>, « inférieur à ») échouent si l'un des paramètres vaut NaN (I<Not a Number>, ce qui signifie « pas un nombre »), et déclenchent une exception. Pour l'éviter, C99 définit les macros listées ci-dessous.

note: type: Plain text
en: These macros are guaranteed to evaluate their arguments only once.  The arguments must be of real floating-point type (note: do not pass integer values as arguments to these macros, since the arguments will I<not> be promoted to real-floating types).
fr: Ces macros garantissent de n'évaluer leurs paramètres qu'une seule fois. Les paramètres peuvent être de n'importe quel type flottant réel (attention, il ne faut pas passer des valeurs entières en paramètre de ces macros, ces paramètres I<ne seront pas> convertis en type flottant réel).

note: type: Plain text
en: determines I<(x)\ E<gt>\ (y)> without an exception if I<x> or I<y> is NaN.
fr: détermine si I<(x)\ E<gt>\ (y)> sans lever d'exception si I<x> ou I<y> vaut NaN.

note: type: Plain text
en: determines I<(x)\ E<gt>=\ (y)> without an exception if I<x> or I<y> is NaN.
fr: détermine si I<(x)\ E<gt>=\ (y)> sans lever d'exception si I<x> ou I<y> vaut NaN.

note: type: Plain text
en: determines I<(x)\ E<lt>\ (y)> without an exception if I<x> or I<y> is NaN.
fr: détermine si I<(x)\ E<lt>\ (y)> sans lever d'exception si I<x> ou I<y> vaut NaN.

note: type: Plain text
en: determines I<(x)\ E<lt>=\ (y)> without an exception if I<x> or I<y> is NaN.
fr: détermine si I<(x)\ E<lt>=\ (y)> sans lever d'exception si I<x> ou I<y> vaut NaN.

note: type: Plain text
en: determines I<(x)\ E<lt> (y) || (x) E<gt>\ (y)> without an exception if I<x> or I<y> is NaN.  This macro is not equivalent to I<x\ !=\ y> because that expression is true if I<x> or I<y> is NaN.
fr: détermine si I<(x)\ E<lt> (y) || (x) E<gt>\ (y)> sans lever d'exception si I<x> ou I<y> vaut NaN. Cette macro n'est pas équivalente à I<x\ !=\ y> car cette expression est vraie si I<x> ou I<y> vaut NaN.

note: type: Plain text
en: determines whether its arguments are unordered, that is, whether at least one of the arguments is a NaN.
fr: détermine si ses paramètres n'ont pas d'ordre, c'est-à-dire si au moins un de ses paramètres est un NaN.

note: type: Plain text
en: The macros other than B<isunordered>()  return the result of the relational comparison; these macros return 0 if either argument is a NaN.
fr: Les macros autres que B<isunordered>() renvoient le résultat de la relation d'ordre ; ces macros renvoient 0 si l'un des paramètres est un NaN.

note: type: Plain text
en: B<isunordered>()  returns 1 if I<x> or I<y> is NaN and 0 otherwise.
fr: B<isunordered>() renvoie 1 si I<x> ou I<y> vaut NaN et 0 sinon.

note: type: Plain text
en: The B<isgreater>(), B<isgreaterequal>(), B<isless>(), B<islessequal>(), B<islessgreater>(), and B<isunordered>()  macros are thread-safe.
fr: Les macros B<isgreater>(), B<isgreaterequal>(), B<isless>(), B<islessequal>(), B<islessgreater>() et B<isunordered>() sont sûres dans un contexte multithread.

note: type: Plain text
en: Not all hardware supports these functions, and where hardware support isn't provided, they will be emulated by macros.  This will result in a performance penalty.  Don't use these functions if NaN is of no concern for you.
fr: Tous les matériels ne supportent pas ces fonctions, et quand une gestion matérielle n'est pas fournie, elles sont émulées par des macros. Cela diminue les performances. Ne les utilisez pas si NaN ne vous concerne pas.

note: type: TH
en: 2014-01-18
fr: 18 janvier 2014

note: type: Plain text
en: j0, j0f, j0l, j1, j1f, j1l, jn, jnf, jnl - Bessel functions of the first kind
fr: j0, j0f, j0l, j1, j1f, j1l, jn, jnf, jnl - Fonctions de Bessel de la première espèce

note: type: Plain text
en: B<j0>(), B<j1>(), B<jn>():
fr: B<j0>(), B<j1>(), B<jn>()\ :

note: type: Plain text
en: B<j0f>(), B<j0l>(), B<j1f>(), B<j1l>(), B<jnf>(), B<jnl>():
fr: B<j0f>(), B<j0l>(), B<j1f>(), B<j1l>(), B<jnf>(), B<jnl>()\ :

note: type: Plain text
en: The B<j0>()  and B<j1>()  functions return Bessel functions of I<x> of the first kind of orders 0 and 1, respectively.  The B<jn>()  function returns the Bessel function of I<x> of the first kind of order I<n>.
fr: Les fonctions B<j0>() et B<j1>() renvoient les valeurs des fonctions de Bessel de la première espèce, respectivement d'ordre 0 et 1, pour la variable réelle I<x>. La fonction B<jn>() renvoie la valeur de la fonction de Bessel de la première espèce d'ordre I<n>, pour la variable réelle I<x>.

note: type: Plain text
en: The B<j0f>(), B<j1f>(), and B<jnf>(), functions are versions that take and return I<float> values.  The B<j0l>(), B<j1l>(), and B<jnl>()  functions are versions that take and return I<long double> values.
fr: Les fonctions B<j0f>(), B<j1f>() et B<jnf>() sont des versions qui prennent en argument et renvoient des valeurs de type I<float>. Les fonctions B<j0l>(), B<j1l>() et B<jnl>() sont des versions qui prennent en argument et renvoient des valeurs de type I<long double>.

note: type: Plain text
en: On success, these functions return the appropriate Bessel value of the first kind for I<x>.
fr: En cas de réussite, ces fonctions renvoient la valeur de Bessel de la première espèce appropriée pour I<x>.

note: type: Plain text
en: If I<x> is too large in magnitude, or the result underflows, a range error occurs, and the return value is 0.
fr: Si I<x> a un module trop important, ou si un dépassement se produit pour le résultat, une erreur d'intervalle est produite et la valeur de retour est 0.

note: type: TP
en: Range error: result underflow, or I<x> is too large in magnitude
fr: Erreur d'intervalle : dépassement pour le résultat ou I<x> a un module trop important

note: An underflow floating-point exception .RB ( FE_UNDERFLOW ) is raised. type: Plain text
en: I<errno> is set to B<ERANGE>.
fr: I<errno> prend la valeur B<ERANGE>.

note: FIXME . Is it intentional that these functions do not raise exceptions? e.g., j0(1.5e16) Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6805 type: Plain text
en: These functions do not raise exceptions for B<fetestexcept>(3).
fr: Ces fonctions ne lèvent pas d'exception pour B<fetestexcept>(3).

note: type: Plain text
en: The functions returning I<double> conform to SVr4, 4.3BSD, POSIX.1-2001.  The others are nonstandard functions that also exist on the BSDs.
fr: Les fonctions renvoyant des valeurs de type I<double> se conforment à SVr4, BSD\ 4.3 et POSIX.1-2001. Les autres sont des fonctions non standard qui existent également sur les BSD.

note: type: Plain text
en: There are errors of up to 2e-16 in the values returned by B<j0>(), B<j1>()  and B<jn>()  for values of I<x> between -8 and 8.
fr: Il peut y avoir une erreur allant jusqu'à 2e-16 dans les valeurs renvoyées par B<j0>(), B<j1>() et B<jn>() pour I<x> compris entre -8 et 8.

note: type: TH
en: 2013-08-19
fr: 19 août 2013

note: type: Plain text
en: ldexp, ldexpf, ldexpl - multiply floating-point number by integral power of 2
fr: ldexp, ldexpf, ldexpl - Multiplier un nombre réel par une puissance de 2

note: type: Plain text
en: B<ldexpf>(), B<ldexpl>():
fr: B<ldexpf>(), B<ldexpl>()\ :

note: type: Plain text
en: The B<ldexp>()  function returns the result of multiplying the floating-point number I<x> by 2 raised to the power I<exp>.
fr: La fonction B<ldexp>() renvoie le résultat de la multiplication du nombre réel I<x> par 2 élevé à la puissance I<exp>.

note: type: Plain text
en: On success, these functions return I<x * (2^exp)>.
fr: En cas de réussite, ces fonctions renvoient I<x * (2^exp)>.

note: type: Plain text
en: If I<exp> is zero, then I<x> is returned.
fr: Si I<exp> est nul, alors I<x> est renvoyé.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with a sign the same as I<x>.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le même signe que I<x>.

note: type: Plain text
en: The B<ldexp>(), B<ldexpf>(), and B<ldexpl>()  functions are thread-safe.
fr: Les fonctions B<ldexp>(), B<ldexpf>() et B<ldexpl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: lgamma, lgammaf, lgammal, lgamma_r, lgammaf_r, lgammal_r, signgam - log gamma function
fr: lgamma, lgammaf, lgammal, lgamma_r, lgammaf_r, lgammal_r, signgam - Logarithme de la fonction Gamma

note: type: Plain text
en: B<lgamma>():
fr: B<lgamma>() :

note: type: Plain text
en: B<lgammaf>(), B<lgammal>():
fr: B<lgammaf>(), B<lgammal>() :

note: type: Plain text
en: B<lgamma_r>(), B<lgammaf_r>(), B<lgammal_r>():
fr: B<lgamma_r>(), B<lgammaf_r>(), B<lgammal_r>()\ :

note: type: Plain text
en: I<signgam>:
fr: I<signgam> :

note: type: Plain text
en: The B<lgamma>()  function returns the natural logarithm of the absolute value of the Gamma function.  The sign of the Gamma function is returned in the external integer I<signgam> declared in I<E<lt>math.hE<gt>>.  It is 1 when the Gamma function is positive or zero, -1 when it is negative.
fr: La fonction B<lgamma>() renvoie le logarithme népérien (ou naturel) de la valeur absolue de la fonction Gamma. Le signe de la fonction Gamma est stocké dans la variable entière externe I<signgam> déclaré dans I<E<lt>math.hE<gt>>. Il vaut 1 si la fonction Gamma est positive ou nulle, -1 si elle est négative.

note: type: Plain text
en: Since using a constant location I<signgam> is not thread-safe, the functions B<lgamma_r>(), B<lgammaf_r>(), and B<lgammal_r>()  have been introduced; they return the sign via the argument I<signp>.
fr: Comme l'utilisation de la variable statique I<signgam> n'est pas sûre en multithread, les fonctions B<lgamma_r>(), B<lgammaf_r>() et B<lgammal_r>() ont été introduites, elles renvoient le signe dans le paramètre I<signp>.

note: type: Plain text
en: On success, these functions return the natural logarithm of Gamma(x).
fr: En cas de réussite, ces fonctions renvoient le logarithme népérien (ou logarithme naturel) de Gamma(x).

note: type: Plain text
en: If I<x> is 1 or 2, +0 is returned.
fr: Si I<x> vaut 1 ou 2, +0 est renvoyé.

note: type: Plain text
en: If I<x> is a nonpositive integer, a pole error occurs, and the functions return +B<HUGE_VAL>, +B<HUGE_VALF>, or +B<HUGE_VALL>, respectively.
fr: Si I<x> est un nombre entier non-positif, une erreur de pôle se produit et les fonctions renvoient +B<HUGE_VAL>, +B<HUGE_VALF> ou +B<HUGE_VALL>, respectivement.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the correct mathematical sign.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le bon signe mathématique.

note: type: TP
en: Pole error: I<x> is a nonpositive integer
fr: Erreur de pôle : I<x> est un nombre entier non-positif

note: type: Plain text
en: The B<lgamma>()  functions are specified in C99 and POSIX.1-2001.  I<signgam> is specified in POSIX.1-2001, but not in C99.  The B<lgamma_r>()  functions are nonstandard, but present on several other systems.
fr: Les fonctions B<lgamma>() sont spécifiées dans C99 et POSIX.1-2001. I<signgam> est spécifiée dans POSIX.1-2001, mais pas dans C99. Les fonctions B<lgamma_r>() ne sont pas standardisées mais elles sont présentes sur de nombreux systèmes.

note: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6777 type: Plain text
en: In glibc 2.9 and earlier, when a pole error occurs, I<errno> is set to B<EDOM>; instead of the POSIX-mandated B<ERANGE>.  Since version 2.10, glibc does the right thing.
fr: Dans la glibc 2.9 et précédentes, lorsqu'une erreur de pôle se produit, I<errno> est définie à B<EDOM> au lieu de B<ERANGE> comme défini dans POSIX. C'est corrigé depuis la glibc 2.10.

note: type: Plain text
en: log, logf, logl - natural logarithmic function
fr: log, logf, logl - Fonction logarithme népérien

note: type: Plain text
en: B<logf>(), B<logl>():
fr: B<logf>(), B<logl>() :

note: type: Plain text
en: The B<log>()  function returns the natural logarithm of I<x>.
fr: La fonction B<log>() renvoie le logarithme népérien (ou logarithme naturel) de I<x>, noté traditionnellement B<ln> en français.

note: type: Plain text
en: On success, these functions return the natural logarithm of I<x>.
fr: En cas de réussite, ces fonctions renvoient le logarithme népérien de I<x>.

note: type: Plain text
en: If I<x> is 1, the result is +0.
fr: Si I<x> vaut 1, le résultat est +0.

note: type: Plain text
en: If I<x> is zero, then a pole error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.
fr: Si I<x> est nul, une erreur de pôle se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement.

note: type: Plain text
en: If I<x> is negative (including negative infinity), then a domain error occurs, and a NaN (not a number) is returned.
fr: Si I<x> est négatif (l'infini négatif compris), alors une erreur de domaine se produit et un NaN (« Not a Number » : pas un nombre) est renvoyé.

note: type: TP
en: Domain error: I<x> is negative
fr: Erreur de domaine : I<x> est négatif

note: type: TP
en: Pole error: I<x> is zero
fr: Erreur de pôle : I<x> est nul

note: type: Plain text
en: I<errno> is set to B<ERANGE>.  A divide-by-zero floating-point exception (B<FE_DIVBYZERO>)  is raised.
fr: I<errno> prend la valeur B<ERANGE>. Une exception de virgule flottante de division par zéro (B<FE_DIVBYZERO>) est levée.

note: type: Plain text
en: In glibc 2.5 and earlier, taking the B<log>()  of a NaN produces a bogus invalid floating-point (B<FE_INVALID>)  exception.
fr: Dans la glibc 2.5 et les versions antérieures, B<log>() produisait à tort pour un NaN une exception de virgule flottante incorrecte (B<FE_INVALID>).

note: type: Plain text
en: log10, log10f, log10l - base-10 logarithmic function
fr: log10, log10f, log10l - Fonction logarithme en base 10

note: type: Plain text
en: B<log10f>(), B<log10l>():
fr: B<log10f>(), B<log10l>()\ :

note: type: Plain text
en: The B<log10>()  function returns the base 10 logarithm of I<x>.
fr: La fonction B<log10>() renvoie le logarithme décimal de I<x>.

note: type: Plain text
en: On success, these functions return the base 10 logarithm of I<x>.
fr: En cas de réussite, ces fonctions renvoient le logarithme décimal de I<x>.

note: type: Plain text
en: For special cases, including where I<x> is 0, 1, negative, infinity, or NaN, see B<log>(3).
fr: Pour les cas particuliers, entre autres quand I<x> vaut 0, 1, une valeur négative, une valeur infinie, un NaN, consultez B<log>(3).

note: type: Plain text
en: For a discussion of the errors that can occur for these functions, see B<log>(3).
fr: Pour une discussion sur les erreurs qui peuvent se produire pour ces fonctions, consultez B<log>(3).

note: type: TH
en: 2014-02-28
fr: 28 février 2014

note: type: Plain text
en: log1p, log1pf, log1pl - logarithm of 1 plus argument
fr: log1p, log1pf, log1pl - Logarithme de 1 plus x

note: type: Plain text
en: B<log1p>():
fr: B<log1p>() :

note: type: Plain text
en: B<log1pf>(), B<log1pl>():
fr: B<log1pf>(), B<log1pl>()\ :

note: type: Plain text
en: I<log1p(x)> returns a value equivalent to
fr: I<log1p(x)> renvoie la valeur équivalente à

note: type: Plain text
en: It is computed in a way that is accurate even if the value of I<x> is near zero.
fr: Elle est calculée de telle manière que la précision est conservée même lorsque I<x> est proche de zéro.

note: type: Plain text
en: On success, these functions return the natural logarithm of I<(1\ +\ x)>.
fr: En cas de réussite, ces fonctions renvoient le logarithme népérien (ou logarithme naturel) de I<(1\ +\ x)>.

note: type: Plain text
en: If I<x> is -1, a pole error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.
fr: Si I<x> vaut -1, une erreur de pôle se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement.

note: POSIX.1 specifies a possible range error if x is subnormal glibc 2.8 doesn't do this type: Plain text
en: If I<x> is less than -1 (including negative infinity), a domain error occurs, and a NaN (not a number) is returned.
fr: Si I<x> est inférieur à -1 (l'infini négatif compris), une erreur de domaine se produit et un NaN (« Not a Number » : pas un nombre) est renvoyé.

note: type: TP
en: Domain error: I<x> is less than -1
fr: Erreur de domaine : I<x> est inférieur à -1

note: type: TP
en: Pole error: I<x> is -1
fr: Erreur de pôle : I<x> vaut -1

note: .I errno is set to .BR ERANGE . type: Plain text
en: A divide-by-zero floating-point exception (B<FE_DIVBYZERO>)  is raised.
fr: Une exception de virgule flottante de division par zéro (B<FE_DIVBYZERO>) est levée.

note: type: Plain text
en: The B<log1p>(), B<log1pf>(), and B<log1pl>()  functions are thread-safe.
fr: Les fonctions B<log1p>(), B<log1pf>() et B<log1pl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2010-09-12
fr: 12 septembre 2010

note: type: Plain text
en: log2, log2f, log2l - base-2 logarithmic function
fr: log2, log2f, log2l - Fonction logarithme en base 2

note: type: Plain text
en: B<log2>(), B<log2f>(), B<log2l>():
fr: B<log2>(), B<log2f>(), B<log2l>()\ :

note: type: Plain text
en: The B<log2>()  function returns the base 2 logarithm of I<x>.
fr: La fonction B<log2>() renvoie le logarithme en base 2 de I<x>.

note: type: Plain text
en: On success, these functions return the base 2 logarithm of I<x>.
fr: En cas de réussite, ces fonctions renvoient le logarithme en base 2 de I<x>.

note: type: Plain text
en: logb, logbf, logbl - get exponent of a floating-point value
fr: logb, logbf, logbl - Obtenir l'exposant d'un nombre à virgule flottante

note: type: Plain text
en: B<logb>():
fr: B<logb>()\ :

note: type: Plain text
en: B<logbf>(), B<logbl>():
fr: B<logbf>(), B<logbl>() :

note: type: Plain text
en: These functions extract the exponent from the internal floating-point representation of I<x> and return it as a floating-point value.  The integer constant B<FLT_RADIX>, defined in I<E<lt>float.hE<gt>>, indicates the radix used for the system's floating-point representation.  If B<FLT_RADIX> is 2, B<logb(>I<x>B<)> is equal to B<floor(log2(>I<x>B<))>, except that it is probably faster.
fr: Ces fonctions extraient l'exposant de la représentation interne en virgule flottante de I<x> et le renvoie sous forme de nombre en virgule flottante. La constante entière B<FLT_RADIX>, définie dans I<E<lt>float.hE<gt>>, indique la base utilisée pour la représentation des nombres en virgule flottante du système. Si B<FLT_RADIX> vaut 2, alors B<logb(>I<x>B<)> est équivalent à B<floor(log2(>I<x>B<))> et elle est probablement plus rapide.

note: type: Plain text
en: If I<x> is subnormal, B<logb>()  returns the exponent I<x> would have if it were normalized.
fr: Si I<x> est dénormalisé, B<logb>() renvoie l'exposant I<x> comme s'il était normalisé.

note: type: Plain text
en: On success, these functions return the exponent of I<x>.
fr: En cas de réussite, ces fonctions renvoient l'exposant de I<x>.

note: type: Plain text
en: If I<x> is negative infinity or positive infinity, then positive infinity is returned.
fr: Si I<x> est une valeur infinie positive ou négative, l'infini positif est renvoyé.

note: type: TP
en: Pole error: I<x> is 0
fr: Erreur de pôle : I<x> est nul

note: type: Plain text
en: The B<logb>(), B<logbf>(), and B<logbl>()  functions are thread-safe.
fr: Les fonctions B<logb>(), B<logbf>() et B<logbl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: lrint, lrintf, lrintl, llrint, llrintf, llrintl - round to nearest integer
fr: lrint, lrintf, lrintl, llrint, llrintf, llrintl - Arrondir à l'entier le plus proche

note: type: Plain text
en: All functions shown above:
fr: Pour toutes les fonctions ci-dessus :

note: type: Plain text
en: These functions round their argument to the nearest integer value, using the current rounding direction (see B<fesetround>(3)).
fr: Ces fonctions arrondissent leurs paramètres à la valeur entière la plus proche, en utilisant la direction actuelle d'approximation (voir B<fesetround>(3)).

note: type: Plain text
en: Note that unlike the B<rint>(3)  family of functions, the return type of these functions differs from that of their arguments.
fr: Notez que contrairement à la famille de fonctions B<rint>(3), le type de la valeur renvoyée est différent du type de leur paramètre.

note: type: Plain text
en: These functions return the rounded integer value.
fr: Ces fonctions renvoient la valeur entière arrondie.

note: The return value is -(LONG_MAX - 1) or -(LLONG_MAX -1) type: Plain text
en: If I<x> is a NaN or an infinity, or the rounded value is too large to be stored in a I<long> (I<long long> in the case of the B<ll*> functions), then a domain error occurs, and the return value is unspecified.
fr: Si I<x> est un Nan ou un infini ou si la valeur arrondie est trop importante pour être stockée dans un I<long> (ou un I<long long> dans le cas des fonction B<ll*>), une erreur de domaine se produit et la valeur de retour n'est pas spécifiée.

note: type: TP
en: Domain error: I<x> is a NaN or infinite, or the rounded value is too large
fr: Erreur de domaine : I<x> est un NaN ou un infini ou la valeur arrondie est trop importante

note: type: Plain text
en: The B<lrint>(), B<lrintf>(), B<lrintl>(), B<llrint>(), B<llrintf>(), and B<llrintl>()  functions are thread-safe.
fr: Les fonctions B<lrint>(), B<lrintf>(), B<lrintl>(), B<llrint>(), B<llrintf>() et B<llrintl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2013-08-26
fr: 26 août 2013

note: type: Plain text
en: lround, lroundf, lroundl, llround, llroundf, llroundl - round to nearest integer, away from zero
fr: lround, lroundf, lroundl, llround, llroundf, llroundl - Arrondir à l'entier le plus proche

note: type: Plain text
en: These functions round their argument to the nearest integer value, rounding away from zero, regardless of the current rounding direction (see B<fenv>(3)).
fr: Ces fonctions arrondissent leur paramètre à l'entier le plus proche, en s'éloignant de zéro, quelle que soit la direction actuelle d'approximation (consultez B<fenv>(3)).

note: type: Plain text
en: Note that unlike the B<round>(3)  and B<ceil>(3), functions, the return type of these functions differs from that of their arguments.
fr: Notez que contrairement aux fonctions B<round>(3) et B<ceil>(3), le type de la valeur renvoyée est différent du type de leur paramètre.

note: type: Plain text
en: The B<lround>(), B<lroundf>(), B<lroundl>(), B<llround>(), B<llroundf>(), and B<llroundl>()  functions are thread-safe.
fr: Les fonctions B<lround>(), B<lroundf>(), B<lroundl>(), B<llround>(), B<llroundf>() et B<llroundl>() sont sûres dans un contexte multithread.

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: See CONFORMANCE in the glibc 2.8 (and earlier) source. type: Plain text
en: The I<math_errhandling> identifier specified by C99 and POSIX.1-2001 is not supported by glibc.  This identifier is supposed to indicate which of the two error-notification mechanisms (I<errno>, exceptions retrievable via B<fettestexcept>(3))  is in use.  The standards require that at least one be in use, but permit both to be available.  The current (version 2.8) situation under glibc is messy.  Most (but not all) functions raise exceptions on errors.  Some also set I<errno>.  A few functions set I<errno>, but don't raise an exception.  A very few functions do neither.  See the individual manual pages for details.
fr: L'identifiant I<math_errhandling> spécifié par C99 et POSIX.1-2001 n'est pas pris en charge par la glibc. Cet identifiant est supposé indiquer lequel des deux mécanismes d'indication d'erreur est utilisé (I<errno> ou des exceptions récupérables avec B<fettestexcept>(3)). Les normes imposent qu'au moins l'un d'entre eux soit utilisé, mais autorisent à ce que les deux soient disponibles. La situation actuelle de la glibc (version 2.8) n'est pas très propre. La plupart des fonctions (mais pas toutes) lèvent des exceptions en cas d'erreur. Certaines positionnent également I<errno>. Quelques fonctions positionnent I<errno>, mais ne lèvent pas d'exception. Très peu ne font ni l'un ni l'autre. Consultez les différentes pages de manuel pour avoir les détails.

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 discussion on this page does not apply to the complex mathematical functions (i.e., those declared by I<E<lt>complex.hE<gt>>), which in general are not required to return errors by C99 and POSIX.1-2001.
fr: La discussion sur cette page ne s'applique pas aux fonctions mathématiques à variables complexes (c'est-à-dire celles déclarées par I<E<lt>complex.hE<gt>>), pour lesquelles C99 et POSIX.1-2001 n'exigent pas en général de renvoyer d'erreurs.

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: TH
en: 2010-09-10
fr: 10 septembre 2010

note: type: Plain text
en: matherr - SVID math library exception handling
fr: matherr - Gestionnaire d'exception SVID de la bibliothèque mathématique

note: type: Plain text
en: B<#define _SVID_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>math.hE<gt>>
fr: B<#define _SVID_SOURCE>       /* Consultez feature_test_macros(7) */
    B<#include E<lt>math.hE<gt>>

note: type: Plain text
en: The System V Interface Definition (SVID) specifies that various math functions should invoke a function called B<matherr>()  if a math exception is detected.  This function is called before the math function returns; after B<matherr>()  returns, the system then returns to the math function, which in turn returns to the caller.
fr: La spécification « System V Interface Definition » (SVID) spécifie que différentes fonctions devraient appeler une fonction B<matherr>() en cas d'exception mathématique. Cette fonction est appelée avant que la fonction mathématique ne rende la main ; après le retour de B<matherr>(), le système retourne dans la fonction mathématique qui renvoie le résultat à l'appelant.

note: type: Plain text
en: The B<matherr>()  mechanism is supported by glibc, but is now obsolete: new applications should use the techniques described in B<math_error>(7)  and B<fenv>(3).  This page documents the glibc B<matherr>()  mechanism as an aid for maintaining and porting older applications.
fr: Le mécanisme B<matherr>() est pris en charge par la glibc, mais il est désormais obsolète : les nouvelles applications devraient utiliser les techniques décrites dans B<math_error>(7) et B<fenv>(3). Cette page documente le mécanisme B<matherr>() de la glibc comme aide pour maintenir et porter d'anciennes applications.

note: type: Plain text
en: To employ B<matherr>(), the programmer must define the B<_SVID_SOURCE> feature test macro (before including I<any> header files), and assign the value B<_SVID_> to the external variable B<_LIB_VERSION>.
fr: Pour utiliser B<matherr>(), le programmeur doit définir la macro de test de fonctionnalité B<_SVID_SOURCE> (avant d'inclure I<tout> en-tête) et définir la variable externe B<_LIB_VERSION> à la valeur B<_SVID_>.

note: type: Plain text
en: The system provides a default version of B<matherr>().  This version does nothing, and returns zero (see below for the significance of this).  The default B<matherr>()  can be overridden by a programmer-defined version, which will be invoked when an exception occurs.  The function is invoked with one argument, a pointer to an I<exception> structure, defined as follows:
fr: Le système fourni une version par défaut de B<matherr>(). Cette version ne fait rien et renvoie zéro (voir ci-dessous pour la signification). La fonction B<matherr>() par défaut peut être remplacée par une version spécifique au programme, qui sera appelée quand une exception se produit. La fonction est appelée avec un paramètre, un pointeur vers une structure I<exception>, définie comme ceci :

note: type: Plain text
en: struct exception {
        int    type;      /* Exception type */
        char  *name;      /* Name of function causing exception */
        double arg1;      /* 1st argument to function */
        double arg2;      /* 2nd argument to function */
        double retval;    /* Function return value */
    }
fr: struct exception {
        int    type;      /* Type d'exception */
        char  *name;      /* Nom de la fonction ayant
                             produit l'exception */
        double arg1;      /* 1er paramètre de la fonction */
        double arg2;      /* 2e paramètre de la fonction */
        double retval;    /* Valeur de retour de la fonction */
    }

note: type: Plain text
en: The I<type> field has one of the following values:
fr: Le champ I<type> peut prendre une des valeurs suivantes\ :

note: type: Plain text
en: A domain error occurred (the function argument was outside the range for which the function is defined).  The return value depends on the function; I<errno> is set to B<EDOM>.
fr: Une erreur de domaine s'est produite (un paramètre de la fonction était en dehors du domaine de définition de la fonction). La valeur de retour dépend de la fonction ; I<errno> prend la valeur B<EDOM>.

note: type: Plain text
en: A pole error occurred (the function result is an infinity).  The return value in most cases is B<HUGE> (the largest single precision floating-point number), appropriately signed.  In most cases, I<errno> is set to B<EDOM>.
fr: Une erreur de pôle s'est produite (la fonction résulte en un infini). La valeur de retour dans la plupart des cas est B<HUGE> (le plus grand nombre en virgule flottante), avec le bon signe. Dans la plupart des cas, I<errno> prend la valeur B<EDOM>.

note: type: Plain text
en: An overflow occurred.  In most cases, the value B<HUGE> is returned, and I<errno> is set to B<ERANGE>.
fr: Un dépassement s'est produit. Dans la plupart des cas, la valeur B<HUGE> est renvoyée et I<errno> prend la valeur B<ERANGE>.

note: type: Plain text
en: An underflow occurred.  0.0 is returned, and I<errno> is set to B<ERANGE>.
fr: Un soupassement (« underflow ») s'est produit. 0,0 est renvoyé et I<errno> prend la valeur B<ERANGE>.

note: type: Plain text
en: Total loss of significance.  0.0 is returned, and I<errno> is set to B<ERANGE>.
fr: Perte complète de chiffres significatifs. 0,0 est renvoyé et I<errno> prend la valeur B<ERANGE>.

note: type: Plain text
en: Partial loss of significance.  This value is unused on glibc (and many other systems).
fr: Perte partielle de chiffres significatifs. La valeur n'est pas utilisée par la glibc (et beaucoup d'autres systèmes).

note: type: Plain text
en: The I<arg1> and I<arg2> fields are the arguments supplied to the function (I<arg2> is undefined for functions that take only one argument).
fr: Les champs I<arg1> et I<arg2> sont les paramètres fournis à la fonction (I<arg2> n'est pas défini pour les fonctions qui ne prennent qu'un seul paramètre).

note: type: Plain text
en: The I<retval> field specifies the return value that the math function will return to its caller.  The programmer-defined B<matherr>()  can modify this field to change the return value of the math function.
fr: Le champ I<retval> spécifie la valeur de retour que la fonction mathématique va renvoyer à l'appelant. La fonction B<matherr>() spécifique au programme peut modifier ce champ pour changer la valeur de retour de la fonction mathématique.

note: type: Plain text
en: If the B<matherr>()  function returns zero, then the system sets I<errno> as described above, and may print an error message on standard error (see below).
fr: Si la fonction B<matherr>() renvoie zéro, alors le système positionne I<errno> comme décrit ci-dessus et peut afficher un message d'erreur sur la sortie d'erreur (voir ci-dessous).

note: type: Plain text
en: If the B<matherr>()  function returns a nonzero value, then the system does not set I<errno>, and doesn't print an error message.
fr: Si la fonction B<matherr>() renvoie une valeur non nulle, alors le système ne positionne pas I<errno> et n'affiche pas de message d'erreur.

note: type: SS
en: Math functions that employ matherr()
fr: Fonctions mathématiques qui utilisent matherr()

note: type: Plain text
en: The table below lists the functions and circumstances in which B<matherr>()  is called.  The "Type" column indicates the value assigned to I<exc-E<gt>type> when calling B<matherr>().  The "Result" column is the default return value assigned to I<exc-E<gt>retval>.
fr: La table ci-dessous liste les fonctions et les circonstances pour lesquelles B<matherr>() est appelée. La colonne « Type » indique la valeur donnée à I<exc-E<gt>type> lors de l'appel à B<matherr>(). La colonne « Résultat » est la valeur du résultat par défaut donnée à I<exc-E<gt>retval>.

note: type: Plain text
en: The "Msg?" and "errno" columns describe the default behavior if B<matherr>()  returns zero.  If the "Msg?" columns contains "y", then the system prints an error message on standard error.
fr: Les colonnes « Msg? » et « errno » décrivent le comportement par défaut si B<matherr>() renvoie zéro. Si la colonne « Msg? » contient « o », alors le système affiche un message d'erreur sur la sortie d'erreur.

note: type: Plain text
en: The table uses the following notations and abbreviations:
fr: La table utilise les notations et abréviations suivantes :

note: type: Plain text
en: x        first argument to function
    y        second argument to function
    fin      finite value for argument
    neg      negative value for argument
    int      integral value for argument
    o/f      result overflowed
    u/f      result underflowed
    |x|      absolute value of x
    X_TLOSS  is a constant defined in I<E<lt>math.hE<gt>>
fr: x        premier paramètre de la fonction
    y        deuxième paramètre de la fonction
    fin      valeur finie du paramètre
    nég      valeur négative du paramètre
    ent      valeur entière du paramètre
    o/f      dépassement (« overflow ») pour le résultat
    u/f      soupassement (« underflow ») pour le résultat
    |x|      valeur absolue de x
    X_TLOSS  constante définie dans I<E<lt>math.hE<gt>>

note: type: tbl table
en: Function	Type	Result	Msg?	errno
fr: Fonction	Type	Résultat	Msg?	errno

note: type: tbl table
en: acos(|x|E<gt>1)	DOMAIN	HUGE	y	EDOM
fr: acos(|x|E<gt>1)	DOMAIN	HUGE	o	EDOM

note: type: tbl table
en: asin(|x|E<gt>1)	DOMAIN	HUGE	y	EDOM
fr: asin(|x|E<gt>1)	DOMAIN	HUGE	o	EDOM

note: type: tbl table
en: atan2(0,0)	DOMAIN	HUGE	y	EDOM
fr: atan2(0,0)	DOMAIN	HUGE	o	EDOM

note: retval is 0.0/0.0 type: tbl table
en: acosh(xE<lt>1)	DOMAIN	NAN	y	EDOM
fr: acosh(xE<lt>1)	DOMAIN	NAN	o	EDOM

note: retval is 0.0/0.0 type: tbl table
en: atanh(|x|E<gt>1)	DOMAIN	NAN	y	EDOM
fr: atanh(|x|E<gt>1)	DOMAIN	NAN	o	EDOM

note: retval is x/0.0 type: tbl table
en: atanh(|x|==1)	SING	(xE<gt>0.0)?	y	EDOM
fr: atanh(|x|==1)	SING	(xE<gt>0.0)?	o	EDOM

note: type: tbl table
en: sqrt(xE<lt>0)	DOMAIN	0.0	y	EDOM
fr: sqrt(xE<lt>0)	DOMAIN	0.0	o	EDOM

note: type: tbl table
en: j0(|x|E<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: j0(|x|E<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: j1(|x|E<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: j1(|x|E<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: jn(|x|E<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: jn(|x|E<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: y0(xE<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: y0(xE<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: y1(xE<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: y1(xE<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: yn(xE<gt>X_TLOSS)	TLOSS	0.0	y	ERANGE
fr: yn(xE<gt>X_TLOSS)	TLOSS	0.0	o	ERANGE

note: type: tbl table
en: y0(0)	DOMAIN	-HUGE	y	EDOM
fr: y0(0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: y0(xE<lt>0)	DOMAIN	-HUGE	y	EDOM
fr: y0(xE<lt>0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: y1(0)	DOMAIN	-HUGE	y	EDOM
fr: y1(0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: y1(xE<lt>0)	DOMAIN	-HUGE	y	EDOM
fr: y1(xE<lt>0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: yn(n,0)	DOMAIN	-HUGE	y	EDOM
fr: yn(n,0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: yn(xE<lt>0)	DOMAIN	-HUGE	y	EDOM
fr: yn(xE<lt>0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: lgamma(-int) or	SING	HUGE	y	EDOM
fr: lgamma(-ent) or	SING	HUGE	o	EDOM

note: type: tbl table
en: tgamma(-int)	SING	NAN	y	EDOM
fr: tgamma(-ent)	SING	NAN	o	EDOM

note: type: tbl table
en: tgamma(0)	SING	copysign(	y	ERANGE
fr: tgamma(0)	SING	copysign(	o	ERANGE

note: type: tbl table
en: log(0)	SING	-HUGE	y	EDOM
fr: log(0)	SING	-HUGE	o	EDOM

note: type: tbl table
en: log(xE<lt>0)	DOMAIN	-HUGE	y	EDOM
fr: log(xE<lt>0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: log10(0)	SING	-HUGE	y	EDOM
fr: log10(0)	SING	-HUGE	o	EDOM

note: type: tbl table
en: log10(xE<lt>0)	DOMAIN	-HUGE	y	EDOM
fr: log10(xE<lt>0)	DOMAIN	-HUGE	o	EDOM

note: type: tbl table
en: pow(0.0,0.0)	DOMAIN	0.0	y	EDOM
fr: pow(0.0,0.0)	DOMAIN	0.0	o	EDOM

note: +0 and -0 type: tbl table
en: 0**neg	DOMAIN	0.0	y	EDOM
fr: 0**nég	DOMAIN	0.0	o	EDOM

note: type: tbl table
en: neg**non-int	DOMAIN	0.0	y	EDOM
fr: nég**non-ent	DOMAIN	0.0	o	EDOM

note: type: tbl table
en: fmod(x,0)	DOMAIN	x	y	EDOM
fr: fmod(x,0)	DOMAIN	x	o	EDOM

note: retval is 0.0/0.0 type: tbl table
en: remainder(x,0)	DOMAIN	NAN	y	EDOM
fr: remainder(x,0)	DOMAIN	NAN	o	EDOM

note: type: Plain text
en: The example program demonstrates the use of B<matherr>()  when calling B<log>(3).  The program takes up to three command-line arguments.  The first argument is the floating-point number to be given to B<log>(3).  If the optional second argument is provided, then B<_LIB_VERSION> is set to B<_SVID_> so that B<matherr>()  is called, and the integer supplied in the command-line argument is used as the return value from B<matherr>().  If the optional third command-line argument is supplied, then it specifies an alternative return value that B<matherr>()  should assign as the return value of the math function.
fr: Le programme d'exemple montre l'utilisation de B<matherr>() lors de l'appel à B<log>(3). Le programme prend jusqu'à 3 paramètres en ligne de commande. Le premier paramètre est le nombre en virgule flottante à fournir à B<log>(3). Si le deuxième paramètre, optionnel, est fourni, B<_LIB_VERSION> est configuré à la valeur B<_SVID_> de telle sorte que B<matherr>() soit appelée et l'entier fourni sur la ligne de commande est utilisé comme valeur de retour de B<matherr>(). Si le troisième paramètre, optionnel, est fourni, il spécifie une autre valeur de retour que B<matherr>() doit positionner comme valeur de retour de la fonction mathématique.

note: type: Plain text
en: The following example run, where B<log>(3)  is given an argument of 0.0, does not use B<matherr>():
fr: L'exécution suivante de l'exemple (dans laquelle B<log>(3) reçoit la valeur 0,0) n'utilise pas B<matherr>() :

note: type: Plain text
en: In the following run, B<matherr>()  is called, and returns 0:
fr: Dans l'exécution suivante, B<matherr>() est appelée et renvoie 0 :

note: type: Plain text
en: The message "log: SING error" was printed by the C library.
fr: Le message « log: SING error » a été affiché par la bibliothèque C.

note: type: Plain text
en: In the following run, B<matherr>()  is called, and returns a nonzero value:
fr: Dans l'exécution suivante, B<matherr>() est appelée et renvoie une valeur non nulle :

note: type: Plain text
en: In this case, the C library did not print a message, and I<errno> was not set.
fr: Dans ce cas, la bibliothèque C n'a pas affiché de message et I<errno> n'a pas été positionnée.

note: type: Plain text
en: In the following run, B<matherr>()  is called, changes the return value of the math function, and returns a nonzero value:
fr: Dans l'exécution suivante, B<matherr>() est appelée, modifie la valeur de retour de la fonction mathématique et renvoie une valeur non nulle :

note: type: Plain text
en: modf, modff, modfl - extract signed integral and fractional values from floating-point number
fr: modf, modff, modfl - Séparer la partie entière et décimale d'un nombre réel

note: type: Plain text
en: B<modf>(), B<modfl>():
fr: B<modf>(), B<modfl>() :

note: type: Plain text
en: The B<modf>()  function breaks the argument I<x> into an integral part and a fractional part, each of which has the same sign as I<x>.  The integral part is stored in the location pointed to by I<iptr>.
fr: La fonction B<modf>() scinde son argument I<x> en une partie entière et une partie décimale, chacune d'elles ayant le signe de I<x>. La partie entière est stockée à l'emplacement pointé par I<iptr>.

note: type: Plain text
en: The B<modf>()  function returns the fractional part of I<x>.
fr: La fonction B<modf>() renvoie la partie décimale de I<x>.

note: type: Plain text
en: If I<x> is a NaN, a NaN is returned, and I<*iptr> is set to a NaN.
fr: Si I<x> n'est pas un nombre (NaN, pour « Not a Number »), un NaN est renvoyé, et I<*iptr> est rempli avec un NaN.

note: type: Plain text
en: If I<x> is positive infinity (negative infinity), +0 (-0) is returned, and I<*iptr> is set to positive infinity (negative infinity).
fr: Si I<x> est l'infini positif (resp. l'infini négatif), +0 (resp. -0) est renvoyé et I<*iptr> est positionné à l'infini positif (resp. l'infini négatif).

note: type: Plain text
en: The B<modf>(), B<modff>(), and B<modfl>()  functions are thread-safe.
fr: Les fonctions B<modf>(), B<modff>() et B<modfl>() sont sûre dans un contexte multithread.

note: type: Plain text
en: nan, nanf, nanl - return 'Not a Number'
fr: nan, nanf, nanl - Fonctions renvoyant «\ Not a Number\ »

note: type: Plain text
en: B<nan>(), B<nanf>(), B<nanl>():
fr: B<nan>(), B<nanf>(), B<nanl>() :

note: type: Plain text
en: These functions return a representation (determined by I<tagp>)  of a quiet NaN.  If the implementation does not support quiet NaNs, these functions return zero.
fr: Ces fonctions renvoient une représentation (déterminée par I<tagp>) d'un NaN (« Not A Number », élément non numérique indiquant un cas d'erreur dans les routines mathématiques) silencieux. Si cette implémentation ne supporte pas les NaN, ces fonctions renvoient zéro.

note: type: Plain text
en: The call I<nan("char-sequence")> is equivalent to:
fr: L'appel I<nan("char-sequence")> est équivalent à :

note: type: Plain text
en: Similarly, calls to B<nanf>()  and B<nanl>()  are equivalent to analogous calls to B<strtof>(3)  and B<strtold>(3).
fr: Et de même, les appels à B<nanf>() et B<nanl>() sont équivalents aux appels analogues à B<strtof>(3) et B<strtold>(3).

note: type: Plain text
en: The argument I<tagp> is used in an unspecified manner.  On IEEE 754 systems, there are many representations of NaN, and I<tagp> selects one.  On other systems it may do nothing.
fr: L'argument I<tagp> est utilisé de manière non spécifiée. Sur les systèmes IEEE 754, il existe de nombreuses représentations de NaN, et I<tagp> en sélectionne une. Sur les autres systèmes, il peut n'avoir aucun effet.

note: type: Plain text
en: C99, POSIX.1-2001.  See also IEC 559 and the appendix with recommended functions in IEEE 754/IEEE 854.
fr: C99, POSIX.1-2001. Consultez aussi IEC 559 et l'annexe sur les fonctions recommandées dans IEEE 754/IEEE 854.

note: type: TH
en: 2013-09-02
fr: 2 septembre 2013

note: type: Plain text
en: nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - floating-point number manipulation
fr: nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - Manipulation de nombres en virgule flottante

note: type: Plain text
en: B<nextafter>():
fr: B<nextafter>() :

note: type: Plain text
en: B<nextafterf>(), B<nextafterl>():
fr: B<nextafterf>(), B<nextafterl>() :

note: type: Plain text
en: B<nexttoward>(), B<nexttowardf>(), B<nexttowardl>():
fr: B<nexttoward>(), B<nexttowardf>(), B<nexttowardl>() :

note: type: Plain text
en: The B<nextafter>(), B<nextafterf>(), and B<nextafterl>()  functions return the next representable floating-point value following I<x> in the direction of I<y>.  If I<y> is less than I<x>, these functions will return the largest representable number less than I<x>.
fr: Les fonctions B<nextafter>(), B<nextafterf>() et B<nextafterl>() renvoient la valeur en virgule flottante pouvant être représentée suivant I<x> dans la direction de I<y>. Si I<y> est inférieur à I<x>, ces fonctions renverront la valeur la plus élevée pouvant être représentée inférieure à I<x>.

note: type: Plain text
en: If I<x> equals I<y>, the functions return I<y>.
fr: Si I<x> est égal à I<y>, la fonction renvoie I<y>.

note: type: Plain text
en: The B<nexttoward>(), B<nexttowardf>(), and B<nexttowardl>()  functions do the same as the corresponding B<nextafter>()  functions, except that they have a I<long double> second argument.
fr: Les fonctions B<nexttoward>(), B<nexttowardf>() et B<nexttowardl>() réalisent le même travail que les fonctions B<nextafter>() correspondantes sauf qu'elles ont un second argument de type I<long double>.

note: type: Plain text
en: On success, these functions return the next representable floating-point value after I<x> in the direction of I<y>.
fr: En cas de réussite, ces fonctions renvoient la valeur en virgule flottante suivante pouvant être représentée après I<x> dans la direction de I<y>.

note: type: Plain text
en: If I<x> equals I<y>, then I<y> (cast to the same type as I<x>)  is returned.
fr: Si I<x> est égal à I<y>, alors I<y> (converti dans le même type que I<x>) est renvoyé.

note: e.g., DBL_MAX type: Plain text
en: If I<x> is finite, and the result would overflow, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the correct mathematical sign.
fr: Si I<x> est une valeur finie et que le résultat produit un dépassement, une erreur d'intervalle est produite et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le bon signe mathématique.

note: type: Plain text
en: If I<x> is not equal to I<y>, and the correct function result would be subnormal, zero, or underflow, a range error occurs, and either the correct value (if it can be represented), or 0.0, is returned.
fr: Si I<x> n'est pas égal à I<y> et que le résultat correct de la fonction aurait dû être dénormalisé (« subnormal »), zéro, ou en cas de soupassement (« underflow »), alors une erreur d'intervalle est produite et la valeur renvoyée est soit la valeur correcte (si elle peut être représentée), soit 0.

note: type: TP
en: Range error: result is subnormal or underflows
fr: Erreur d'intervalle : le résultat est dénormalisé ou un soupassement se produit.

note: type: Plain text
en: The B<nextafter>(), B<nextafterf>(), B<nextafterl>(), B<nexttoward>(), B<nexttowardf>(), and B<nexttowardl>()  functions are thread-safe.
fr: Les fonctions B<nextafter>(), B<nextafterf>(), B<nextafterl>(), B<nexttoward>(), B<nexttowardf>() et B<nexttowardl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: In glibc version 2.5 and earlier, these functions do not raise an underflow floating-point (B<FE_UNDERFLOW>)  exception when an underflow occurs.
fr: Dans la glibc version 2.5 et antérieures, ces fonction ne lèvent pas d'exception de virgule flottante de soupassement (B<FE_UNDERFLOW>) quand un soupassement se produit.

note: type: Plain text
en: pow, powf, powl - power functions
fr: pow, powf, powl - Fonction puissance

note: type: Plain text
en: B<powf>(), B<powl>():
fr: B<powf>(), B<powl>() :

note: type: Plain text
en: The B<pow>()  function returns the value of I<x> raised to the power of I<y>.
fr: La fonction B<pow>() renvoie la valeur de I<x> élevé à la puissance I<y>.

note: type: Plain text
en: On success, these functions return the value of I<x> to the power of I<y>.
fr: En cas de réussite, ces fonctions renvoient la valeur de I<x> élevée à la puissance I<y>.

note: The domain error is generated at least as far back as glibc 2.4 type: Plain text
en: If I<x> is a finite value less than 0, and I<y> is a finite noninteger, a domain error occurs, and a NaN is returned.
fr: Si I<x> est une valeur finie négative et I<y> une nombre fini non-entier, une erreur de domaine se produit et un NaN est renvoyé.

note: The range error is generated at least as far back as glibc 2.4 type: Plain text
en: If the result overflows, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the mathematically correct sign.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le bon signe mathématique.

note: POSIX.1 does not specify the sign of the zero, but http://sources.redhat.com/bugzilla/show_bug.cgi?id=2678 points out that the zero has the wrong sign in some cases. type: Plain text
en: If result underflows, and is not representable, a range error occurs, and 0.0 is returned.
fr: En cas de soupassement (« underflow ») pour le résultat, et qu'il ne peut pas être représenté, une erreur d'intervalle se produit et 0 est renvoyé.

note: type: Plain text
en: Except as specified below, if I<x> or I<y> is a NaN, the result is a NaN.
fr: Sauf dans les cas spécifiés ci-dessous, si I<x> ou I<y> est un NaN, le résultat est un NaN.

note: type: Plain text
en: If I<x> is +1, the result is 1.0 (even if I<y> is a NaN).
fr: Si I<x> vaut +1, le résultat est 1,0 (même si I<y> est un NaN).

note: type: Plain text
en: If I<y> is 0, the result is 1.0 (even if I<x> is a NaN).
fr: Si I<y> est nul, le résultat est 1,0 (même si I<x> est un NaN).

note: type: Plain text
en: If I<x> is +0 (-0), and I<y> is an odd integer greater than 0, the result is +0 (-0).
fr: Si I<x> vaut +0 (resp. -0) et I<y> est un nombre entier impair positif, le résultat est +0 (resp. -0).

note: type: Plain text
en: If I<x> is 0, and I<y> greater than 0 and not an odd integer, the result is +0.
fr: Si I<x> est nul et I<y> positif et n'est pas un nombre entier impair, le résultat est +0.

note: type: Plain text
en: If I<x> is -1, and I<y> is positive infinity or negative infinity, the result is 1.0.
fr: Si I<x> vaut -1 et I<y> est une valeur infinie positive ou négative, le résultat est 1,0.

note: type: Plain text
en: If the absolute value of I<x> is less than 1, and I<y> is negative infinity, the result is positive infinity.
fr: Si la valeur absolue de I<x> est inférieure à 1 et I<y> est une valeur infinie négative, le résultat est l'infini positif.

note: type: Plain text
en: If the absolute value of I<x> is greater than 1, and I<y> is negative infinity, the result is +0.
fr: Si la valeur absolue de I<x> est supérieure à 1 et I<y> est une valeur infinie négative, le résultat est +0.

note: type: Plain text
en: If the absolute value of I<x> is less than 1, and I<y> is positive infinity, the result is +0.
fr: Si la valeur absolue de I<x> est inférieure à 1 et I<y> est une valeur infinie positive, le résultat est +0.

note: type: Plain text
en: If the absolute value of I<x> is greater than 1, and I<y> is positive infinity, the result is positive infinity.
fr: Si la valeur absolue de I<x> est supérieure à 1 et I<y> est une valeur infinie positive, le résultat est l'infini positif.

note: type: Plain text
en: If I<x> is negative infinity, and I<y> is an odd integer less than 0, the result is -0.
fr: Si I<x> est une valeur infinie négative et I<y> est un nombre entier impair négatif, le résultat est -0.

note: type: Plain text
en: If I<x> is negative infinity, and I<y> less than 0 and not an odd integer, the result is +0.
fr: Si I<x> est une valeur infinie négative et I<y> est négatif et n'est pas un nombre entier impair, le résultat est +0.

note: type: Plain text
en: If I<x> is negative infinity, and I<y> is an odd integer greater than 0, the result is negative infinity.
fr: Si I<x> est une valeur infinie négative et I<y> est un nombre entier impair positif, le résultat est l'infini négatif.

note: type: Plain text
en: If I<x> is negative infinity, and I<y> greater than 0 and not an odd integer, the result is positive infinity.
fr: Si I<x> est une valeur infinie négative et I<y> est positif et n'est pas un nombre entier impair, le résultat est l'infini positif.

note: type: Plain text
en: If I<x> is positive infinity, and I<y> less than 0, the result is +0.
fr: Si I<x> est une valeur infinie positive et I<y> est négatif, le résultat est +0.

note: type: Plain text
en: If I<x> is positive infinity, and I<y> greater than 0, the result is positive infinity.
fr: Si I<x> est une valeur infinie positive et I<y> est positif, le résultat est l'infini positif.

note: type: Plain text
en: If I<x> is +0 or -0, and I<y> is an odd integer less than 0, a pole error occurs and B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, is returned, with the same sign as I<x>.
fr: Si I<x> vaut +0 ou -0 et I<y> est une nombre entier impair négatif, une erreur de pôle se produit et B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL> est renvoyé avec le même signe que I<x>.

note: The pole error is generated at least as far back as glibc 2.4 type: Plain text
en: If I<x> is +0 or -0, and I<y> is less than 0 and not an odd integer, a pole error occurs and +B<HUGE_VAL>, +B<HUGE_VALF>, or +B<HUGE_VALL>, is returned.
fr: Si I<x> vaut +0 ou -0 et I<y> est négatif et pas un nombre impair, une erreur de pôle se produit et +B<HUGE_VAL>, +B<HUGE_VALF> ou +B<HUGE_VALL> est renvoyé.

note: type: TP
en: Domain error: I<x> is negative, and I<y> is a finite noninteger
fr: Erreur de domaine : I<x> est négatif et I<y> est un nombre fini non entier

note: type: TP
en: Pole error: I<x> is zero, and I<y> is negative
fr: Erreur de pôle : I<x> est nul et I<y> est négatif

note: type: TP
en: Range error: the result overflows
fr: Erreur d'intervalle : dépassement pour le résultat

note: type: TP
en: Range error: the result underflows
fr: Erreur d'intervalle : soupassement (« underflow ») du résultat

note: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6776 or possibly 2.9, I haven't found the source code change and I don't have a 2.9 system to test type: Plain text
en: In glibc 2.9 and earlier, when a pole error occurs, I<errno> is set to B<EDOM> instead of the POSIX-mandated B<ERANGE>.  Since version 2.10, glibc does the right thing.
fr: Dans la glibc 2.9 et les versions antérieures, si une erreur de pôle survient, I<errno> est positionné à B<EDOM> à la place de la valeur B<ERANGE> spécifiée par POSIX. Depuis la version 2.10, le comportement de la glibc est corrigé.

note: see bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=3866 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=369 type: Plain text
en: If I<x> is negative, then large negative or positive I<y> values yield a NaN as the function result, with I<errno> set to B<EDOM>, and an invalid (B<FE_INVALID>)  floating-point exception.  For example, with B<pow>(), one sees this behavior when the absolute value of I<y> is greater than about 9.223373e18.
fr: Si I<x> est négatif, alors des valeurs négatives ou positives importantes de I<y> provoquent un NaN comme résultat de la fonction, avec I<errno> prenant la valeur B<EDOM> et une exception de virgule flottante incorrecte (B<FE_INVALID>). Par exemple, avec B<pow>(), on peut rencontrer ce comportement quand la valeur absolue de I<y> est supérieure à environ 9,223373e18.

note: FIXME . Actually, 2.3.2 is the earliest test result I have; so yet to confirm if this error occurs only in 2.3.2. type: Plain text
en: In version 2.3.2 and earlier, when an overflow or underflow error occurs, glibc's B<pow>()  generates a bogus invalid floating-point exception (B<FE_INVALID>)  in addition to the overflow or underflow exception.
fr: Dans la version 2.3.2 et les suivantes de la glibc, quand un dépassement ou un soupassement (« underflow ») se produit, B<pow>() génère à tort une exception de virgule flottante incorrecte (B<FE_INVALID>) en plus de l'exception de dépassement ou de soupassement.

note: type: Plain text
en: pow10, pow10f, pow10l - base-10 power functions
fr: pow10, pow10f, pow10l - Fonction 10 puissance

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>math.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>math.hE<gt>>

note: type: Plain text
en: The B<pow10>()  function returns the value of 10 raised to the power I<x>.
fr: La fonction B<pow10>() renvoie la valeur de 10 élevé à la puissance I<x>.

note: type: Plain text
en: This is a GNU extension.
fr: Il s'agit d'une extension GNU.

note: type: Plain text
en: These functions are identical to the functions listed under B<exp10>(3).
fr: Ces fonctions sont identiques à celles listées dans B<exp10>(3).

note: type: Plain text
en: drem, dremf, dreml, remainder, remainderf, remainderl - floating-point remainder function
fr: drem, dremf, dreml, remainder, remainderf, remainderl - Fonction reste en virgule flottante

note: type: Plain text
en: /* The C99 versions */
    B<double remainder(double >I<x>B<, double >I<y>B<);>
    B<float remainderf(float >I<x>B<, float >I<y>B<);>
    B<long double remainderl(long double >I<x>B<, long double >I<y>B<);>
fr: /* Les versions C99 */
    B<double remainder(double >I<x>B<, double >I<y>B<);>
    B<float remainderf(float >I<x>B<, float >I<y>B<);>
    B<long double remainderl(long double >I<x>B<, long double >I<y>B<);>

note: type: Plain text
en: /* Obsolete synonyms */
    B<double drem(double >I<x>B<, double >I<y>B<);>
    B<float dremf(float >I<x>B<, float >I<y>B<);>
    B<long double dreml(long double >I<x>B<, long double >I<y>B<);>
fr: /* Synonymes obsolètes */
    B<double drem(double >I<x>B<, double >I<y>B<);>
    B<float dremf(float >I<x>B<, float >I<y>B<);>
    B<long double dreml(long double >I<x>B<, long double >I<y>B<);>

note: type: Plain text
en: B<remainder>():
fr: B<remainder>() :

note: type: Plain text
en: _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _XOPEN_SOURCE\ &&\ _XOPEN_SOURCE_EXTENDED || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 500 || _XOPEN_SOURCE\ &&\ _XOPEN_SOURCE_EXTENDED || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: B<remainderf>(), B<remainderl>():
fr: B<remainderf>(), B<remainderl>() :

note: type: Plain text
en: B<drem>(), B<dremf>(), B<dreml>():
fr: B<drem>(), B<dremf>(), B<dreml>() :

note: type: Plain text
en: The B<remainder>()  function computes the remainder of dividing I<x> by I<y>.  The return value is I<x>-I<n>*I<y>, where I<n> is the value I<x\ /\ y>, rounded to the nearest integer.  If the absolute value of I<x>-I<n>*I<y> is 0.5, I<n> is chosen to be even.
fr: La fonction B<remainder>() calcule le reste de la division de I<x> par I<y>. La valeur renvoyée est I<x>-I<n>*I<y>, où I<n> est la valeur I<x\ /\ y>, arrondie à l'entier le plus proche. Si la valeur absolue de I<x>-I<n>*I<y> vaut 0,5, un I<n> pair est choisi.

note: type: Plain text
en: These functions are unaffected by the current rounding mode (see B<fenv>(3)).
fr: Ces fonctions ne sont pas affectées par le mode d'arrondi en cours (voir B<fenv>(3)).

note: type: Plain text
en: The B<drem>()  function does precisely the same thing.
fr: La fonction B<drem>() fait précisément la même chose.

note: type: Plain text
en: On success, these functions return the floating-point remainder, I<x>-I<n>*I<y>.  If the return value is 0, it has the sign of I<x>.
fr: En cas de réussite, ces fonctions renvoient le reste en virgule flottante, I<x>-I<n>*I<y>. Si la valeur de retour est nulle, elle a le signe de I<x>.

note: type: Plain text
en: If I<x> is an infinity, and I<y> is not a NaN, a domain error occurs, and a NaN is returned.
fr: Si I<x> est infini et I<y> n'est pas un NaN, une erreur de domaine se produit et un NaN est renvoyé.

note: type: Plain text
en: If I<y> is zero, and I<x> is not a NaN, a domain error occurs, and a NaN is returned.
fr: Si I<y> est nul et I<x> n'est pas un NaN, une erreur de domaine se produit et un NaN est renvoyé.

note: type: TP
en: Domain error: I<x> is an infinity and I<y> is not a NaN
fr: Erreur de domaine : I<x> est infini et I<y> n'est pas un NaN

note: IEC 60559. type: Plain text
en: The functions B<remainder>(), B<remainderf>(), and B<remainderl>()  are specified in C99 and POSIX.1-2001.
fr: Les fonctions B<remainder>(), B<remainderf>() et B<remainderl>() sont spécifiées dans C99 et POSIX.1-2001.

note: type: Plain text
en: The function B<drem>()  is from 4.3BSD.  The I<float> and I<long double> variants B<dremf>()  and B<dreml>()  exist on some systems, such as Tru64 and glibc2.  Avoid the use of these functions in favor of B<remainder>()  etc.
fr: La fonction B<drem>() vient de BSD\ 4.3. Les variantes I<float> et I<long double> B<dremf>() et B<dreml>() existent sur certains systèmes, comme Tru64 et glibc2. Évitez d'utiliser ces fonctions pour leur préférer B<remainder>() etc.

note: type: Plain text
en: The call
fr: L'appel

note: FIXME . this bug occurs as at glibc 2.8. Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6779 type: Plain text
en: returns a NaN, as expected, but wrongly causes a domain error; it should yield a silent NaN.
fr: renvoie un NaN, comme attendu, mais cause à tort une erreur de domaine ; il devrait juste renvoyer un NaN.

note: type: Plain text
en: The call "remainder(29.0, 3.0)" returns -1.
fr: L'appel «\ remainder(29.0, 3.0)\ » renvoie -1.

note: type: Plain text
en: remquo, remquof, remquol - remainder and part of quotient
fr: remquo, remquof, remquol - Reste et partie d'un quotient

note: type: Plain text
en: B<remquo>(), B<remquof>(), B<remquol>():
fr: B<remquo>(), B<remquof>(), B<remquol>() :

note: type: Plain text
en: These functions compute the remainder and part of the quotient upon division of I<x> by I<y>.  A few bits of the quotient are stored via the I<quo> pointer.  The remainder is returned as the function result.
fr: Ces fonctions calculent le reste et la partie du quotient de la division de I<x> par I<y>. Quelques bits du quotient sont stockés via le pointeur I<quo>. Le reste est renvoyé comme la valeur de retour de la fonction.

note: type: Plain text
en: The value of the remainder is the same as that computed by the B<remainder>(3)  function.
fr: La valeur du reste est la même que si elle avait été calculée par la fonction B<remainder>(3).

note: type: Plain text
en: The value stored via the I<quo> pointer has the sign of I<x\ /\ y> and agrees with the quotient in at least the low order 3 bits.
fr: La valeur stockée via le pointeur I<quo> a le signe de I<x\ /\ y> et est d'accord avec le quotient sur au moins les 3 bits de poids faible.

note: A possible application of this function might be the computation of sin(x). Compute remquo(x, pi/2, &quo) or so. glibc, UnixWare: return 3 bits MacOS 10: return 7 bits type: Plain text
en: For example, I<remquo(29.0,\ 3.0)> returns -1.0 and might store 2.  Note that the actual quotient might not fit in an integer.
fr: Par exemple, I<remquo(29.0,\ 3.0)> renvoie -1.0 et devrait stocker 2. Veuillez noter que le quotient actuel peut ne pas tenir sur un entier.

note: type: Plain text
en: On success, these functions return the same value as the analogous functions described in B<remainder>(3).
fr: En cas de réussite, ces fonctions renvoient la même valeur que les fonctions analogues décrites dans B<remainder>(3).

note: type: TP
en: Domain error: I<x> is an infinity or I<y> is 0, and the other argument is not a NaN
fr: Erreur de domaine : I<x> est un infini ou I<y> est nul et l'autre paramètre n'est pas un NaN

note: type: Plain text
en: nearbyint, nearbyintf, nearbyintl, rint, rintf, rintl - round to nearest integer
fr: nearbyint, nearbyintf, nearbyintl, rint, rintf, rintl - Arrondir à l'entier le plus proche

note: type: Plain text
en: B<nearbyint>(), B<nearbyintf>(), B<nearbyintl>():
fr: B<nearbyint>(), B<nearbyintf>(), B<nearbyintl>() :

note: type: Plain text
en: _XOPEN_SOURCE\ E<gt>=\ 600 || _POSIX_C_SOURCE\ E<gt>=\ 200112L || _ISOC99_SOURCE;
fr: _XOPEN_SOURCE\ E<gt>=\ 600 || _POSIX_C_SOURCE\ E<gt>=\ 200112L || _ISOC99_SOURCE

note: type: Plain text
en: B<rint>():
fr: B<rint>() :

note: type: Plain text
en: B<rintf>(), B<rintl>():
fr: B<rintf>(), B<rintl>()\ :

note: type: Plain text
en: The B<nearbyint>(), B<nearbyintf>(), and B<nearbyintl>()  functions round their argument to an integer value in floating-point format, using the current rounding direction (see B<fesetround>(3))  and without raising the I<inexact> exception.
fr: Les fonctions B<nearbyint>(), B<nearbyintf>() et B<nearbyintl>() arrondissent leur paramètre à l'entier le plus proche, dans un format en virgule flottante, en utilisant la direction d'approximation actuelle (consultez B<fesetround>(3)), et sans déclencher l'exception I<inexact>.

note: type: Plain text
en: The B<rint>(), B<rintf>(), and B<rintl>()  functions do the same, but will raise the I<inexact> exception (B<FE_INEXACT>, checkable via B<fetestexcept>(3))  when the result differs in value from the argument.
fr: Les fonctions B<rint>(), B<rintf>() et B<rintl>() font la même chose, mais peuvent déclencher l'exception I<inexact> (B<FE_INEXACT>, vérifiable par B<fetestexcept>(3)) lorsque le résultat diffère du paramètre.

note: type: Plain text
en: The B<nearbyint>(), B<nearbyintf>(), B<nearbyintl>(), B<rint>(), B<rintf>(), and B<rintl>()  functions are thread-safe.
fr: Les fonctions B<nearbyint>(), B<nearbyintf>(), B<nearbyintl>(), B<rint>(), B<rintf>() et B<rintl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: If you want to store the rounded value in an integer type, you probably want to use one of the functions described in B<lrint>(3)  instead.
fr: Si vous voulez stocker la valeur arrondie dans un type entier, vous devriez probablement utiliser une des fonctions décrites dans B<lrint>(3) à la place.

note: type: Plain text
en: round, roundf, roundl - round to nearest integer, away from zero
fr: round, roundf, roundl - Arrondir à l'entier le plus proche en s'éloignant de zéro

note: type: Plain text
en: B<round>(), B<roundf>(), B<roundl>():
fr: B<round>(), B<roundf>(), B<roundl>() :

note: type: Plain text
en: These functions round I<x> to the nearest integer, but round halfway cases away from zero (regardless of the current rounding direction, see B<fenv>(3)), instead of to the nearest even integer like B<rint>(3).
fr: Ces fonctions arrondissent leur I<x> à l'entier le plus proche, en s'éloignant de zéro (sans tenir compte de la direction d'approximation en cours, consultez B<fenv>(3)), à la différence de l'arrondi vers l'entier pair le plus proche comme B<rint>(3).

note: type: Plain text
en: For example, I<round(0.5)> is 1.0, and I<round(-0.5)> is -1.0.
fr: Par exemple, I<round(0,5)> vaut 1,0 et I<round(-0,5)> vaut -1,0.

note: type: Plain text
en: The B<round>(), B<roundf>(), and B<roundl>()  functions are thread-safe.
fr: Les fonctions B<round>(), B<roundf>() et B<roundl>() sont sûres dans un contexte multithread.

note: The POSIX.1-2001 APPLICATION USAGE SECTION discusses this point. type: Plain text
en: POSIX.1-2001 contains text about overflow (which might set I<errno> to B<ERANGE>, or raise an B<FE_OVERFLOW> exception).  In practice, the result cannot overflow on any current machine, so this error-handling stuff is just nonsense.  (More precisely, overflow can happen only when the maximum value of the exponent is smaller than the number of mantissa bits.  For the IEEE-754 standard 32-bit and 64-bit floating-point numbers the maximum value of the exponent is 128 (respectively, 1024), and the number of mantissa bits is 24 (respectively, 53).)
fr: POSIX.1-2001 contient un passage sur les dépassements (qui peuvent remplir I<errno> avec B<ERANGE> ou déclencher une exception B<FE_OVERFLOW>). En pratique, aucun dépassement ne peut se produire sur les machines actuelles, ce qui rend inutile cette gestion d'erreur. Plus précisément, le dépassement ne peut se produire que si la valeur maximale de l'exposant est plus petite que le nombre de bits de la mantisse. Pour les nombres en virgule flottante 32\ bits et 64\ bits obéissant à la norme IEEE-754, la valeur maximale de l'exposant est 128 (resp. 1024) et le nombre de bits de la mantisse est 24 (resp. 53).

note: type: Plain text
en: If you want to store the rounded value in an integer type, you probably want to use one of the functions described in B<lround>(3)  instead.
fr: Si vous voulez stocker la valeur arrondie dans un type entier, vous devriez probablement utiliser une des fonctions décrites dans B<lround>(3) à la place.

note: type: TH
en: 2013-03-23
fr: 23 mars 2013

note: type: Plain text
en: scalb, scalbf, scalbl - multiply floating-point number by integral power of radix (OBSOLETE)
fr: scalb, scalbf, scalbl - Multiplier un nombre en virgule flottante par un entier puissance d'une base (OBSOLÈTE)

note: type: Plain text
en: B<scalb>():
fr: B<scalb>()\ :

note: type: Plain text
en: B<scalbf>(), B<scalbl>():
fr: B<scalbf>(), B<scalbl>() :

note: type: Plain text
en: These functions multiply their first argument I<x> by B<FLT_RADIX> (probably 2)  to the power of I<exp>, that is:
fr: Ces fonctions multiplient leur premier paramètre I<x> par B<FLT_RADIX> (probablement 2) à la puissance I<exp>, c'est-à-dire :

note: not in /usr/include but in a gcc lib type: Plain text
en: The definition of B<FLT_RADIX> can be obtained by including I<E<lt>float.hE<gt>>.
fr: La définition de B<FLT_RADIX> peut être obtenue en incluant I<E<lt>float.hE<gt>>.

note: type: Plain text
en: On success, these functions return I<x> * B<FLT_RADIX> ** I<exp>.
fr: En cas de réussite, ces fonctions renvoient I<x> * B<FLT_RADIX> ** I<exp>.

note: type: Plain text
en: If I<x> or I<exp> is a NaN, a NaN is returned.
fr: Si I<x> ou I<exp> est un NaN, un NaN est renvoyé.

note: type: Plain text
en: If I<x> is positive infinity (negative infinity), and I<exp> is not negative infinity, positive infinity (negative infinity) is returned.
fr: Si I<x> est une valeur infinie positive (resp. négative) et I<exp> n'est pas une valeur infinie négative, l'infini positif (resp. négatif) est renvoyé.

note: type: Plain text
en: If I<x> is +0 (-0), and I<exp> is not positive infinity, +0 (-0) is returned.
fr: Si I<x> vaut +0 (resp. -0) et I<exp> n'est pas l'infini positif, +0 (resp. -0) est renvoyé.

note: type: Plain text
en: If I<x> is zero, and I<exp> is positive infinity, a domain error occurs, and a NaN is returned.
fr: Si I<x> est nul et I<exp> est l'infini positif, une erreur de domaine se produit et un NaN est renvoyé.

note: type: Plain text
en: If I<x> is an infinity, and I<exp> is negative infinity, a domain error occurs, and a NaN is returned.
fr: Si I<x> est infini et I<exp> est l'infini négatif, une erreur de domaine se produit et un NaN est renvoyé.

note: type: Plain text
en: If the result underflows, a range error occurs, and the functions return zero, with a sign the same as I<x>.
fr: En cas de soupassement (« underflow »), une erreur d'intervalle se produit et les fonctions renvoient zéro avec le même signe que I<x>.

note: type: TP
en: Domain error: I<x> is 0, and I<exp> is positive infinity, or I<x> is positive infinity and I<exp> is negative infinity and the other argument is not a NaN
fr: Erreur de domaine : I<x> est nul et I<exp> est l'infini positif, ou I<x> est l'infini positif et I<exp> est l'infini négatif et l'autre paramètre n'est pas un NaN.

note: type: Plain text
en: B<scalb>()  is specified in POSIX.1-2001, but marked obsolescent.  POSIX.1-2008 removes the specification of B<scalb>(), recommending the use of B<scalbln>(3), B<scalblnf>(3), or B<scalblnl>(3)  instead.  The B<scalb>()  function is from 4.3BSD.
fr: B<scalb>() est spécifiée dans POSIX.1-2001, mais marquée comme étant obsolète. POSIX.1-2008 supprime la spécification de B<scalb>(), en recommandant d'utiliser B<scalbln>(3), B<scalblnf>(3) ou B<scalblnl>(3) à la place. La fonction B<scalb>() provient de BSD 4.3.

note: Looking at header files: scalbf() is present on the BSDs, Tru64, HP-UX 11, Irix 6.5; scalbl() is on HP-UX 11 and Tru64. type: Plain text
en: B<scalbf>()  and B<scalbl>()  are unstandardized; B<scalbf>()  is nevertheless present on several other systems
fr: B<scalbf>() et B<scalbl>() ne sont pas standard ; B<scalbf>() est cependant présent dans certains autres système.

note: type: Plain text
en: scalbn, scalbnf, scalbnl, scalbln, scalblnf, scalblnl - multiply floating-point number by integral power of radix
fr: scalbn, scalbnf, scalbnl, scalbln, scalblnf, scalblnl - Multiplier un nombre en virgule flottante par un entier puissance d'une base

note: type: Plain text
en: B<scalbln>(), B<scalblnf>(), B<scalblnl>():
fr: B<scalbln>(), B<scalblnf>(), B<scalblnl>() :

note: type: Plain text
en: B<scalbn>(), B<scalbnf>(), B<scalbnl>():
fr: B<scalbn>(), B<scalbnf>(), B<scalbnl>() :

note: type: Plain text
en: The B<scalbn>(), B<scalbnf>(), B<scalbnl>(), B<scalbln>(), B<scalblnf>(), and B<scalblnl>()  functions are thread-safe.
fr: Les fonctions B<scalbn>(), B<scalbnf>(), B<scalbnl>(), B<scalbln>(), B<scalblnf>() et B<scalblnl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: These functions differ from the obsolete functions described in B<scalb>(3)  in the type of their second argument.  The functions described on this page have a second argument of an integral type, while those in B<scalb>(3)  have a second argument of type I<double>.
fr: Ces fonctions diffèrent des fonctions obsolètes décrites dans B<scalb>(3) par le type de leur deuxième paramètre. Les fonctions décrites sur cette page ont un deuxième paramètre de type entier, tandis que celle de B<scalb>(3) ont un deuxième paramètre de type I<double>.

note: type: Plain text
en: If B<FLT_RADIX> equals 2 (which is usual), then B<scalbn>()  is equivalent to B<ldexp>(3).
fr: Si B<FLT_RADIX> vaut 2 (ce qui est le cas en général), alors B<scalbn>() est équivalent à B<ldexp>(3).

note: type: TH
en: 2013-07-04
fr: 4 juillet 2013

note: type: Plain text
en: signbit - test sign of a real floating-point number
fr: signbit - Tester le signe d'un nombre réel à virgule flottante

note: type: Plain text
en: B<signbit>():
fr: B<signbit>() :

note: type: Plain text
en: B<signbit>()  is a generic macro which can work on all real floating-point types.  It returns a nonzero value if the value of I<x> has its sign bit set.
fr: B<signbit>() est une macro générique qui peut travailler sur tous les types de réel à virgule flottante. Elle renvoie une valeur non nulle si la valeur de I<x> a son bit de signe positionné.

note: type: Plain text
en: This is not the same as I<x E<lt> 0.0>, because IEEE 754 floating point allows zero to be signed.  The comparison I<-0.0 E<lt> 0.0> is false, but I<signbit(-0.0)> will return a nonzero value.
fr: Ceci n'est pas identique à I<x E<lt> 0.0>, car la représentation des nombres en virgule flottante IEEE\ 754 permet à zéro d'être signé (-0 ou +0). La comparaison I<-0.0 E<lt> 0.0> est fausse, mais I<signbit (-0.0)> renvoie une valeur non nulle.

note: type: Plain text
en: NaNs and infinities have a sign bit.
fr: Les NaN et les infinis ont un bit de signe.

note: type: Plain text
en: The B<signbit>()  macro returns nonzero if the sign of I<x> is negative; otherwise it returns zero.
fr: La macro B<signbit>() renvoie une valeur non nulle si le signe de I<x> est négatif ; sinon elle renvoie zéro.

note: type: Plain text
en: The B<signbit>()  macro is thread-safe.
fr: La macro B<signbit>() est sûre dans un contexte multithread.

note: type: TH
en: 2009-02-04
fr: 4 février 2009

note: type: Plain text
en: significand, significandf, significandl - get mantissa of floating-point number
fr: significand, significandf, significandl - Obtenir la mantisse d'un nombre réel en virgule flottante

note: type: Plain text
en: B<significand>(), B<significandf>(), B<significandl>():
fr: B<significand>(), B<significandf>(), B<significandl>() :

note: type: Plain text
en: The B<significand>()  function returns the mantissa of I<x> scaled to the range [1,2).  It is equivalent to
fr: La fonction B<significand>() renvoie la mantisse de I<x> mise à l'échelle dans l'intervalle [1,2). Cette fonction est équivalente à\ :

note: type: Plain text
en: This function exists mainly for use in certain standardized tests for IEEE 754 conformance.
fr: Cette fonction existe principalement afin de tester la conformité aux tests de standardisation de l'IEEE 754.

note: .SH HISTORY This function came from BSD. type: Plain text
en: These functions are nonstandard; the I<double> version is available on a number of other systems.
fr: Ces fonction ne sont pas standard ; la version pour les I<double> est disponible sur un certain nombre d'autres systèmes.

note: type: TH
en: 2013-12-16
fr: 16 décembre 2013

note: type: Plain text
en: sin, sinf, sinl - sine function
fr: sin, sinf, sinl - Fonction sinus

note: type: Plain text
en: B<sinf>(), B<sinl>():
fr: B<sinf>(), B<sinl>() :

note: type: Plain text
en: The B<sin>()  function returns the sine of I<x>, where I<x> is given in radians.
fr: La fonction B<sin>() renvoie le sinus du réel I<x>, ce dernier étant fourni en radians.

note: type: Plain text
en: On success, these functions return the sine of I<x>.
fr: En cas de réussite, ces fonction renvoient le sinus de I<x>.

note: type: Plain text
en: The B<sin>(), B<sinf>(), and B<sinl>()  functions are thread-safe.
fr: Les fonctions B<sin>(), B<ainf>(), et B<sinl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2013-12-23
fr: 23 décembre 2013

note: type: Plain text
en: sincos, sincosf, sincosl - calculate sin and cos simultaneously
fr: sincos, sincosf, sincosl - Calculer simultanément des sinus et cosinus

note: type: Plain text
en: Several applications need sine and cosine of the same angle I<x>.  This function computes both at the same time, and stores the results in I<*sin> and I<*cos>.
fr: De nombreuses applications ont besoin de calculer le sinus et le cosinus du même angle I<x>. Cette fonction calcule les deux en même temps, et stocke les résultats I<*sin> et I<*cos>.

note: type: Plain text
en: If I<x> is a NaN, a NaN is returned in I<*sin> and I<*cos>.
fr: Si I<x> n'est pas un NaN, un NaN est renvoyé dans I<*sin> et I<*cos>.

note: type: Plain text
en: If I<x> is positive infinity or negative infinity, a domain error occurs, and a NaN is returned in I<*sin> and I<*cos>.
fr: Si I<x> est une valeur infinie positive ou négative, une erreur de domaine se produit et un NaN est renvoyé dans I<*sin> et I<*cos>.

note: type: Plain text
en: These functions return I<void>.
fr: Ces fonctions ne renvoient pas de valeur (I<void>).

note: type: Plain text
en: The B<sincos>(), B<sincosf>(), and B<sincosl>()  functions are thread-safe.
fr: Les fonctions B<sincos>(), B<sincosf>() et B<sincosl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: Plain text
en: sinh, sinhf, sinhl - hyperbolic sine function
fr: sinh, sinhf, sinhl - Fonction sinus hyperbolique

note: type: Plain text
en: B<sinhf>(), B<sinhl>():
fr: B<sinhf>(), B<sinhl>() :

note: type: Plain text
en: The B<sinh>()  function returns the hyperbolic sine of I<x>, which is defined mathematically as:
fr: La fonction B<sinh>() renvoie le sinus hyperbolique de I<x>, défini mathématiquement comme :

note: type: Plain text
en: On success, these functions return the hyperbolic sine of I<x>.
fr: En cas de réussite, ces fonctions renvoient le sinus hyperbolique de I<x>.

note: POSIX.1-2001 documents an optional range error (underflow) for subnormal x; glibc 2.8 does not do this. type: Plain text
en: If the result overflows, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the same sign as I<x>.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le même signe que I<x>.

note: type: Plain text
en: sqrt, sqrtf, sqrtl - square root function
fr: sqrt, sqrtf, sqrtl - Fonction racine carrée

note: type: Plain text
en: B<sqrtf>(), B<sqrtl>():
fr: B<sqrtf>(), B<sqrtl>() :

note: type: Plain text
en: The B<sqrt>()  function returns the nonnegative square root of I<x>.
fr: La fonction B<sqrt>() renvoie la racine carrée (I<square root>) non négative de I<x>.

note: type: Plain text
en: On success, these functions return the square root of I<x>.
fr: En cas de réussite, ces fonctions renvoient la racine carrée de I<x>.

note: type: Plain text
en: If I<x> is less than -0, a domain error occurs, and a NaN is returned.
fr: Si I<x> vaut moins que -0, une erreur de domaine se produit et un NaN est renvoyé.

note: type: TP
en: Domain error: I<x> less than -0
fr: Erreur de domaine : I<x> est inférieur à -0

note: type: TH
en: 2014-01-06
fr: 6 janvier 2014

note: type: Plain text
en: tan, tanf, tanl - tangent function
fr: tan, tanf, tanl - Fonction tangente

note: type: Plain text
en: B<tanf>(), B<tanl>():
fr: B<tanf>(), B<tanl>() :

note: type: Plain text
en: The B<tan>()  function returns the tangent of I<x>, where I<x> is given in radians.
fr: La fonction B<tan>() renvoie la tangente de I<x>, dont la valeur est fournie en radians.

note: type: Plain text
en: On success, these functions return the tangent of I<x>.
fr: En cas de réussite, ces fonction renvoient la tangente de I<x>.

note: I think overflow can't occur, because the closest floating-point representation of pi/2 is still not close enough to pi/2 to produce a large enough value to overflow. Testing certainly seems to bear this out.  -- mtk, Jul 08 POSIX.1 allows an optional underflow error; glibc 2.8 doesn't do this POSIX
en: If the correct result would overflow, a range error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the mathematically correct sign.
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le bon signe mathématique.

note: type: Plain text
en: The B<tan>(), B<tanf>(), and B<tanl>()  functions are thread-safe.
fr: Les fonctions B<tan>(), B<tanf>() et B<tanl>() sont sûres dans un contexte multithread.

note: type: TH
en: 2014-01-07
fr: 7 janvier 2014

note: type: Plain text
en: tanh, tanhf, tanhl - hyperbolic tangent function
fr: tanh, tanhf, tanhl - Fonction tangente hyperbolique

note: type: Plain text
en: B<tanhf>(), B<tanhl>():
fr: B<tanhf>(), B<tanhl>() :

note: type: Plain text
en: The B<tanh>()  function returns the hyperbolic tangent of I<x>, which is defined mathematically as:
fr: La fonction B<tanh>() renvoie la tangente hyperbolique de I<x>, définie mathématiquement ainsi\ :

note: type: Plain text
en: On success, these functions return the hyperbolic tangent of I<x>.
fr: En cas de réussite, ces fonctions renvoient la tangente hyperbolique de I<x>.

note: type: Plain text
en: The B<tanh>(), B<tanhf>(), and B<tanhl>()  functions are thread-safe.
fr: Les fonctions B<tanh>(), B<tanhf>() et B<tanhl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: tgamma, tgammaf, tgammal - true gamma function
fr: tgamma, tgammaf, tgammal - Véritables fonctions Gamma

note: type: Plain text
en: B<tgamma>(), B<tgammaf>(), B<tgammal>():
fr: B<tgamma>(), B<tgammaf>(), B<tgammal>()\ :

note: type: Plain text
en: The Gamma function is defined by
fr: La fonction Gamma est définie ainsi\ :

note: type: Plain text
en:     Gamma(x) = integral from 0 to infinity of t^(x-1) e^-t dt
fr:     Gamma(x) = intégrale de 0 à l'infini de t^(x-1) e^-t dt

note: type: Plain text
en: It is defined for every real number except for nonpositive integers.  For nonnegative integral I<m> one has
fr: Elle est définie pour tout réel sauf les entiers négatifs ou nuls. Pour un entier positif I<m>, on a

note: type: Plain text
en: and, more generally, for all I<x>:
fr: et, plus généralement pour tout I<x>\ :

note: type: Plain text
en: Furthermore, the following is valid for all values of I<x> outside the poles:
fr: De plus, la relation ci-dessous est valable pour toute valeur de I<x> en dehors des pôles\ :

note: type: Plain text
en: On success, these functions return Gamma(x).
fr: En cas de réussite, ces fonctions renvoient Gamma(x).

note: type: Plain text
en: If I<x> is a negative integer, or is negative infinity, a domain error occurs, and a NaN is returned.
fr: Si I<x> est un entier négatif ou l'infini négatif, une erreur de domaine est produite et un NaN est renvoyé.

note: type: Plain text
en: If the result underflows, a range error occurs, and the functions return 0, with the correct mathematical sign.
fr: En cas de soupassement (« underflow ») pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient 0, avec le bon signe mathématique.

note: type: Plain text
en: If I<x> is -0 or +0, a pole error occurs, and the functions return B<HUGE_VAL>, B<HUGE_VALF>, or B<HUGE_VALL>, respectively, with the same sign as the 0.
fr: Si I<x> vaut -0 ou +0, une erreur de pôle se produit et les fonctions renvoient B<HUGE_VAL>, B<HUGE_VALF> ou B<HUGE_VALL>, resp. avec le même signe que le 0.

note: type: TP
en: Domain error: I<x> is a negative integer, or negative infinity
fr: Erreur de domaine : I<x> est un entier négatif ou l'infini négatif

note: FIXME . errno is not set to EDOM for x == -inf Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6809 type: Plain text
en: I<errno> is set to B<EDOM>.  An invalid floating-point exception (B<FE_INVALID>)  is raised (but see BUGS).
fr: I<errno> prend la valeur B<EDOM>. Une exception de virgule flottante incorrecte (B<FE_INVALID>) est levée (mais consultez la section des BOGUES).

note: type: TP
en: Pole error: I<x> is +0 or -0
fr: Erreur de pôle : I<x> vaut +0 ou -0

note: type: Plain text
en: glibc also gives the following error which is not specified in C99 or POSIX.1-2001.
fr: La glibc donne également l'erreur suivante qui n'est pas spécifiée dans C99 ou POSIX.1-2001.

note: FIXME . Is it intentional that errno is not set: Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6810 glibc (as at 2.8) also supports and an inexact exception for various cases. type: Plain text
en: I<errno> is not set for this case.
fr: I<errno> n'est pas modifiée dans ce cas.

note: type: Plain text
en: This function had to be called "true gamma function" since there is already a function B<gamma>(3)  that returns something else (see B<gamma>(3)  for details).
fr: Cette fonction a été appelée « true gamma function » (« véritable fonction Gamma ») car il existe déjà une fonction B<gamma>(3) qui retourne un autre résultat (consultez B<gamma>(3) pour des détails).

note: Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6809 type: Plain text
en: If I<x> is negative infinity, I<errno> is not set (it should be set to B<EDOM>).
fr: Si I<x> est l'infini négatif, I<errno> n'est pas touchée (elle devrait prendre la valeur B<EDOM>).

note: type: Plain text
en: In glibc versions 2.3.3 and earlier, an argument of +0 or -0 incorrectly produced a domain error (I<errno> set to B<EDOM> and an B<FE_INVALID> exception raised), rather than a pole error.
fr: Dans la glibc version 2.3.3 et antérieures, un paramètre +0 ou -0 produit à tort une erreur de domaine (I<errno> prend la valeur B<EDOM> et une exception B<FE_INVALID> est levée), au lieu d'une erreur de pôle.

note: type: Plain text
en: trunc, truncf, truncl - round to integer, toward zero
fr: trunc, truncf, truncl - Arrondir à l'entier le plus proche vers zéro

note: type: Plain text
en: B<trunc>(), B<truncf>(), B<truncl>():
fr: B<trunc>(), B<truncf>(), B<truncl>() :

note: type: Plain text
en: These functions round I<x> to the nearest integer not larger in absolute value.
fr: Ces fonctions arrondissent leur argument à l'entier le plus proche dont la valeur absolue est inférieure ou égale à la valeur absolue de l'argument.

note: type: Plain text
en: If I<x> is integral, infinite, or NaN, I<x> itself is returned.
fr: Si I<x> est un nombre entier, infini ou NaN, la valeur renvoyée est I<x> lui-même.

note: type: Plain text
en: The B<trunc>(), B<truncf>(), and B<truncl>()  functions are thread-safe.
fr: Les fonctions B<trunc>(), B<truncf>() et B<truncl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: y0, y0f, y0l, y1, y1f, y1l, yn, ynf, ynl - Bessel functions of the second kind
fr: y0, y0f, y0l, y1, y1f, y1l, yn, ynf, ynl - Fonctions de Bessel de seconde espèce

note: type: Plain text
en: B<y0>(), B<y1>(), B<yn>():
fr: B<y0>(), B<y1>(), B<yn>() :

note: type: Plain text
en: B<y0f>(), B<y0l>(), B<y1f>(), B<y1l>(), B<ynf>(), B<ynl>():
fr: B<y0f>(), B<y0l>(), B<y1f>(), B<y1l>(), B<ynf>(), B<ynl>() :

note: type: Plain text
en: The B<y0>()  and B<y1>()  functions return Bessel functions of I<x> of the second kind of orders 0 and 1, respectively.  The B<yn>()  function returns the Bessel function of I<x> of the second kind of order I<n>.
fr: Les fonctions B<y0>() et B<y1>() renvoient les fonctions de Bessel de I<x> de la seconde espèce pour l'ordre 0 et l'ordre 1, respectivement. La fonction B<yn>() renvoie la fonction de Bessel de I<x> de la seconde espèce à l'ordre I<n>.

note: type: Plain text
en: The value of I<x> must be positive.
fr: La valeur I<x> doit être positive.

note: type: Plain text
en: The B<y0f>(), B<y1f>(), and B<ynf>()  functions are versions that take and return I<float> values.  The B<y0l>(), B<y1l>(), and B<ynl>()  functions are versions that take and return I<long double> values.
fr: Les fonctions B<y0f>(), B<y1f>() et B<ynf>() sont des versions qui prennent en argument et renvoient des valeurs de type I<float>. Les fonctions B<y0l>(), B<y1l>() et B<ynl>() sont des versions qui prennent en argument et renvoient des valeurs de type I<long double>.

note: type: Plain text
en: On success, these functions return the appropriate Bessel value of the second kind for I<x>.
fr: En cas de réussite, ces fonctions renvoient la valeur appropriée de Bessel de la seconde espèce pour I<x>.

note: type: Plain text
en: If I<x> is negative, a domain error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.  (POSIX.1-2001 also allows a NaN return for this case.)
fr: Si I<x> est négatif, une erreur de domaine se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement (POSIX.1-2001 permet également de renvoyer un NaN dans ce cas).

note: type: Plain text
en: If I<x> is 0.0, a pole error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.
fr: Si I<x> vaut 0,0, une erreur de pôle se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement.

note: type: Plain text
en: If the result underflows, a range error occurs, and the functions return 0.0
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient 0,0.

note: type: Plain text
en: If the result overflows, a range error occurs, and the functions return -B<HUGE_VAL>, -B<HUGE_VALF>, or -B<HUGE_VALL>, respectively.  (POSIX.1-2001 also allows a 0.0 return for this case.)
fr: En cas de dépassement pour le résultat, une erreur d'intervalle se produit et les fonctions renvoient -B<HUGE_VAL>, -B<HUGE_VALF> ou -B<HUGE_VALL>, respectivement. (POSIX.1-2001 permet également de renvoyer 0,0 dans ce cas.)

note: type: TP
en: Pole error: I<x> is 0.0
fr: Erreur de pôle : I<x> vaut 0,0

note: Before POSIX.1-2001 TC2, this was (inconsistently) specified as a range error. FIXME . y0(0.0) gives EDOM Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6808 type: Plain text
en: I<errno> is set to B<ERANGE> (but see BUGS).  No B<FE_DIVBYZERO> exception is returned by B<fetestexcept>(3)  for this case.
fr: I<errno> prend la valeur B<ERANGE> (mais consultez la section des BOGUES). Aucune exception B<FE_DIVBYZERO> n'est renvoyée par B<fetestexcept>(3) dans ce cas.

note: e.g., y0(1e33) on glibc 2.8/x86-32 An underflow floating-point exception .RB ( FE_UNDERFLOW ) is raised. FIXME . Is it intentional that these functions do not use FE_*? Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6806 type: Plain text
en: I<errno> is set to B<ERANGE>.  No B<FE_UNDERFLOW> exception is returned by B<fetestexcept>(3)  for this case.
fr: I<errno> prend la valeur B<ERANGE>. Aucune exception B<FE_UNDERFLOW> n'est renvoyée par B<fetestexcept>(3) dans ce cas.

note: e.g., yn(10, 1e-40) on glibc 2.8/x86-32 .I errno is set to .BR ERANGE . FIXME . Is it intentional that errno is not set? Bug raised: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6808 type: Plain text
en: I<errno> is not set for this case.  An overflow floating-point exception (B<FE_OVERFLOW>)  is raised.
fr: I<errno> n'est pas modifiée dans ce cas. Une exception de virgule flottante de dépassement (B<FE_OVERFLOW>) est levée.

note: FIXME . Bug raised: http://sourceware.org/bugzilla/show_bug.cgi?id=6807 type: Plain text
en: On a pole error, these functions set I<errno> to B<EDOM>, instead of B<ERANGE> as POSIX.1-2004 requires.
fr: En cas d'erreur de pôle, ces fonctions configurent I<errno> avec B<EDOM>, à la place de B<ERANGE> comme demandé dans POSIX.1-2004.

note: FIXME . Actually, 2.3.2 is the earliest test result I have; so yet to confirm if this error occurs only in 2.3.2. type: Plain text
en: In glibc version 2.3.2 and earlier, these functions do not raise an invalid floating-point exception (B<FE_INVALID>)  when a domain error occurs.
fr: Dans le glibc 2.3.2 et les versions antérieures, ces fonctions ne lèvent pas d'exception de virgule flottante incorrecte (B<FE_INVALID>) quand une erreur de domaine se produit.
