perkamon - en to fr translation catalogue (110 entries)

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

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: cabs, cabsf, cabsl - absolute value of a complex number
fr: cabs, cabsf, cabsl - Module d'un nombre complexe

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: The B<cabs>()  function returns the absolute value of the complex number I<z>.  The result is a real number.
fr: Les fonctions B<cabs>() renvoient le module (la valeur absolue) du nombre complexe I<z>. Le résultat est un nombre réel.

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: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: The function is actually an alias for I<hypot(a,\ b)> (or, equivalently, I<sqrt(a*a\ +\ b*b)>).
fr: Cette fonction est en fait un alias pour I<hypot(a,\ b)> ( ou I<sqrt(a*a\ +\ b*b)>).

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: 2011-09-15
fr: 15 septembre 2011

note: type: Plain text
en: cacos, cacosf, cacosl - complex arc cosine
fr: cacos, cacosf, cacosl - Fonction arc cosinus complexe

note: type: Plain text
en: The B<cacos>()  function calculates the complex arc cosine of I<z>.  If I<y\ =\ cacos(z)>, then I<z\ =\ ccos(y)>.  The real part of I<y> is chosen in the interval [0,pi].
fr: La fonction B<cacos>() calcule la valeur complexe de l'arc cosinus de I<z>. Si I<y\ =\ cacos(z)>, alors I<z\ =\ ccos(y)>. La partie réelle de I<y> est choisie dans l'intervalle [0,\ pi].

note: type: Plain text
en: One has:
fr: On a\ :

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: /* Link with "-lm" */
fr: Effectuez l'édition des liens avec l'option «\ -lm\ ».

note: type: Plain text
en:     if (argc != 3) {
            fprintf(stderr, "Usage: %s E<lt>realE<gt> E<lt>imagE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 3) {
            fprintf(stderr, "Utilisation : %s E<lt>reelE<gt> E<lt>imagE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     printf("formula = %6.3f %6.3f*i\en", creal(f), cimag(f));
fr:     printf("formule = %6.3f %6.3f*i\en", creal(f), cimag(f));

note: type: Plain text
en: cacosh, cacoshf, cacoshl - complex arc hyperbolic cosine
fr: cacosh, cacoshf, cacoshl - Fonction arc cosinus hyperbolique complexe

note: type: Plain text
en: The B<cacosh>()  function calculates the complex arc hyperbolic cosine of I<z>.  If I<y\ =\ cacosh(z)>, then I<z\ =\ ccosh(y)>.  The imaginary part of I<y> is chosen in the interval [-pi,pi].  The real part of I<y> is chosen nonnegative.
fr: La fonction B<cacosh>() calcule la valeur complexe de l'arc cosinus hyperbolique de I<z>. Si I<y\ =\ cacosh(z)>, alors I<z\ =\ ccosh(y)>. La partie imaginaire de I<y> est choisie dans l'intervalle [-pi,\ pi]. La partie réelle de I<y> est positive ou nulle.

note: type: Plain text
en:     f = 2 * clog(csqrt((z + 1)/2) + csqrt((z - 1)/2));
        printf("formula  = %6.3f %6.3f*i\en", creal(f2), cimag(f2));
fr:     f = 2 * clog(csqrt((z + 1)/2) + csqrt((z - 1)/2));
        printf("formule  = %6.3f %6.3f*i\en", creal(f2), cimag(f2));

note: type: Plain text
en: carg, cargf, cargl - calculate the complex argument
fr: carg, cargf, cargl - Calculer l'argument d'un nombre complexe

note: type: Plain text
en: A complex number can be described by two real coordinates.  One may use rectangular coordinates and gets
fr: Un nombre complexe peut être décrit avec deux types de coordonnées réelles. La première est d'utiliser les coordonnées rectangulaires, soit

note: type: Plain text
en: where I<x\ =\ creal(z)> and I<y\ =\ cimag(z)>.
fr: où I<x\ =\ creal(z)> et I<y\ =\ cimag(z)>.

note: type: Plain text
en: Or one may use polar coordinates and gets
fr: La seconde est d'utiliser les coordonnées polaires, soit

note: type: Plain text
en: where I<r\ =\ cabs(z)> is the "radius", the "modulus", the absolute value of I<z>, and I<a\ =\ carg(z)> is the "phase angle", the argument of I<z>.
fr: où I<r\ =\ cabs(z)> est le module (le rayon, la valeur absolue) de I<z>, et I<a\ =\ carg(z)>, l'argument (la phase) de I<z>.

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

note: type: Plain text
en: The return value is the range of [-pi,pi].
fr: La valeur renvoyée est comprise dans l'intervalle [-pi,\ pi].

note: type: Plain text
en: casin, casinf, casinl - complex arc sine
fr: casin, casinf, casinl - Fonction arc sinus complexe

note: type: Plain text
en: The B<casin>()  function calculates the complex arc sine of I<z>.  If I<y\ =\ casin(z)>, then I<z\ =\ csin(y)>.  The real part of I<y> is chosen in the interval [-pi/2,pi/2].
fr: La fonction B<casin>() calcule la valeur complexe de l'arc sinus de I<z>. Si I<y\ =\ casin(z)>, alors I<z\ =\ csin(y)>. La partie réelle de I<y> est choisie dans l'intervalle [-pi/2,\ pi/2].

note: type: Plain text
en: casinh, casinhf, casinhl - complex arc sine hyperbolic
fr: casinh, casinhf, casinhl - Fonction arc sinus hyperbolique complexe

note: type: Plain text
en: The B<casinh>()  function calculates the complex arc hyperbolic sine of I<z>.  If I<y\ =\ casinh(z)>, then I<z\ =\ csinh(y)>.  The imaginary part of I<y> is chosen in the interval [-pi/2,pi/2].
fr: La fonction B<casinh>() calcule la valeur complexe de l'arc sinus hyperbolique de I<z>. Si I<y\ =\ casinh(z)>, alors I<z\ =\ csinh(y)>. La partie imaginaire de I<y> est choisie dans l'intervalle [-pi/2,\ pi/2].

note: type: Plain text
en: catan, catanf, catanl - complex arc tangents
fr: catan, catanf, catanl - Fonction arc tangente complexe

note: type: Plain text
en: The B<catan>()  function calculates the complex arc tangent of I<z>.  If I<y\ =\ catan(z)>, then I<z\ =\ ctan(y)>.  The real part of y is chosen in the interval [-pi/2,pi/2].
fr: La fonction B<catan>() calcule la valeur complexe de l'arc tangente de I<z>. Si I<y\ =\ catan(z)>, alors I<z\ =\ ctan(y)>. La partie réelle de I<y> est choisie dans l'intervalle [-pi/2,\ pi/2].

note: type: Plain text
en:     f = (clog(1 + i * z) - clog(1 - i * z)) / (2 * i);
        printf("formula = %6.3f %6.3f*i\en", creal(f2), cimag(f2));
fr:     f = (clog(1 + i * z) - clog(1 - i * z)) / (2 * i);
        printf("formule = %6.3f %6.3f*i\en", creal(f2), cimag(f2));

note: type: Plain text
en: catanh, catanhf, catanhl - complex arc tangents hyperbolic
fr: catanh, catanhf, catanhl - Fonction arc tangente hyperbolique complexe

note: type: Plain text
en: The B<catanh>()  function calculates the complex arc hyperbolic tangent of I<z>.  If I<y\ =\ catanh(z)>, then I<z\ =\ ctanh(y)>.  The imaginary part of I<y> is chosen in the interval [-pi/2,pi/2].
fr: La fonction B<catanh>() calcule l'arc tangente hyperbolique complexe de I<z>. Si I<y\ =\ catanh(z)>, alors I<z\ =\ ctanh(y)>. La partie imaginaire de I<y> est choisie dans l'intervalle [-pi/2,\ pi/2].

note: type: Plain text
en:     f = 0.5 * (clog(1 + z) - clog(1 - z));
        printf("formula  = %6.3f %6.3f*i\en", creal(f2), cimag(f2));
fr:     f = 0.5 * (clog(1 + z) - clog(1 - z));
        printf("formule  = %6.3f %6.3f*i\en", creal(f2), cimag(f2));

note: type: Plain text
en: ccos, ccosf, ccosl - complex cosine function
fr: ccos, ccosf, ccosl - Fonction cosinus complexe

note: type: Plain text
en: The complex cosine function is defined as:
fr: La fonction cosinus complexe est définie par :

note: type: Plain text
en: ccosh, ccoshf, ccoshl - complex hyperbolic cosine
fr: ccosh, ccoshf, ccoshl - Fonction cosinus hyperbolique complexe

note: type: Plain text
en: The complex hyperbolic cosine function is defined as:
fr: La fonction cosinus hyperbolique complexe est définie par\ :

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

note: type: Plain text
en: cerf, cerff, cerfl, cerfc, cerfcf, cerfcl - complex error function
fr: cerf, cerff, cerfl, cerfc, cerfcf, cerfcl - Fonctions d'erreur complexe

note: must check 1/sqrt(2*pi) ? type: Plain text
en: The (unimplemented) function B<cerf>()  is the complex version of the error function.  erf(z) = 2/sqrt(pi) * integral from 0 to z of exp(-t*t) dt.  The function B<cerfc>()  is defined as cerfc(z) = 1-cerf(z).
fr: La fonction (non implémentée) B<cerf>() est la version complexe de la fonction d'erreur. erf(z)\ =\ 2/sqrt(pi)\ *\ intégrale de 0 à z de exp(-t*t).dt. La fonction B<cerfc>() est définie comme cerfc(z)\ =\ 1-cerf(z).

note: type: Plain text
en: The function names are reserved for future use in C99.
fr: Les noms de ces fonctions sont réservés pour une utilisation ultérieure dans C99.

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

note: But reserved in NAMESPACE. type: Plain text
en: Not yet in glibc, as at version 2.12.
fr: Pas encore dans la glibc, prévu pour la glibc 2.12.

note: type: Plain text
en: cexp, cexpf, cexpl - complex exponential function
fr: cexp, cexpf, cexpl - Fonction exponentielle complexe

note: type: Plain text
en: The function calculates e (2.71828..., the base of natural logarithms)  raised to the power of I<z>.
fr: Ces fonctions calculent e (2,71828..., la base des logarithmes népériens) élevé à la puissance I<z>.

note: type: TH
en: 2013-02-27
fr: 27 février 2013

note: type: Plain text
en: cexp2, cexp2f, cexp2l - base-2 exponent of a complex number
fr: cexp2, cexp2f, cexp2l - Exponentielles en base 2 de nombres complexes

note: type: Plain text
en: The function returns 2 raised to the power of I<z>.
fr: Cette fonction renvoie 2 élevé à la puissance I<z>.

note: type: Plain text
en: These function names are reserved for future use in C99.
fr: Les noms de ces fonctions sont réservés pour une utilisation ultérieure dans C99.

note: But reserved in NAMESPACE. type: Plain text
en: Not yet in glibc, as at version 2.17.
fr: Pas encore dans la glibc, prévu pour la glibc 2.17.

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

note: type: Plain text
en: cimag, cimagf, cimagl - get imaginary part of a complex number
fr: cimag, cimagf, cimagl - Obtenir la partie imaginaire d'un nombre complexe

note: type: Plain text
en: The B<cimag>()  function returns the imaginary part of the complex number I<z>.
fr: La fonction B<cimag>() renvoie la partie imaginaire du nombre complexe I<z>.

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<cimag>(), B<cimagf>(), and B<cimagl>()  functions are thread-safe.
fr: Les fonctions B<cimag>(), B<cimagf>() et B<cimagl>() sont sûres dans un contexte multithread.

note: type: Plain text
en: gcc also supports __imag__.  That is a GNU extension.
fr: Le compilateur gcc supporte également __imag__. C'est une extension GNU.

note: type: Plain text
en: clog, clogf, clogl - natural logarithm of a complex number
fr: clog, clogf, clogl - Logarithmes népériens de nombres complexes

note: type: Plain text
en: The logarithm B<clog>()  is the inverse function of the exponential B<cexp>(3).  Thus, if I<y\ =\ clog(z)>, then I<z\ =\ cexp(y)>.  The imaginary part of I<y> is chosen in the interval [-pi,pi].
fr: La fonction logarithme B<clog>() est l'inverse de la fonction exponentielle B<cexp>(3). Ainsi, si I<y\ =\ clog(z)>, alors I<z\ =\ cexp(y)>. La partie imaginaire de I<y> est choisie dans l'intervalle [-pi,\ pi].

note: type: Plain text
en: Note that I<z> close to zero will cause an overflow.
fr: Veuillez noter que si I<z> est proche de zéro, un débordement est possible.

note: type: Plain text
en: clog10, clog10f, clog10l - base-10 logarithm of a complex number
fr: clog10, clog10f, clog10l - Logarithmes décimaux des nombres complexes

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 call I<clog10(z)> is equivalent to I<clog(z)/log(10)>.  The other functions perform the same task for I<float> and I<long double>.
fr: La fonction I<clog10(z)> est équivalente à I<clog(z)/log(10)>. Les autres fonctions réalisent la même opération avec les types I<float> et I<long double>.

note: type: Plain text
en: This function is a GNU extension.  It is reserved for future use in C99.
fr: Cette fonction est une extension GNU. Elle est réservée pour une utilisation ultérieure dans C99.

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

note: type: Plain text
en: clog2, clog2f, clog2l - base-2 logarithm of a complex number
fr: clog2, clog2f, clog2l - Logarithmes en base 2 de nombres complexes

note: type: Plain text
en: The call I<clog2(z)> is equivalent to I<clog(z)/log(2)>.
fr: La fonction I<clog2(z)> est équivalente à I<clog(z)/log(2)>.

note: type: Plain text
en: The other functions perform the same task for I<float> and I<long double>.
fr: Les autres fonctions réalisent la même opération pour les types I<float> et I<long double>.

note: type: TH
en: 2011-09-16
fr: 16 septembre 2011

note: type: Plain text
en: complex - basics of complex mathematics
fr: complex - Bases des mathématiques concernant les nombres complexes

note: type: Plain text
en: Complex numbers are numbers of the form z = a+b*i, where a and b are real numbers and i = sqrt(-1), so that i*i = -1.
fr: Les nombres complexes sont des nombres de la forme z = a+b*i, où a et b sont des nombres réels et i = sqrt(-1), de sorte que i*i = -1.

note: type: Plain text
en: There are other ways to represent that number.  The pair (a,b) of real numbers may be viewed as a point in the plane, given by X- and Y-coordinates.  This same point may also be described by giving the pair of real numbers (r,phi), where r is the distance to the origin O, and phi the angle between the X-axis and the line Oz.  Now z = r*exp(i*phi) = r*(cos(phi)+i*sin(phi)).
fr: Il y a d'autres manières de représenter ce nombre. La paire de nombres réels (a, b) peut être vue comme un point du plan, indiqué par ses coordonnées en X et Y. Le même point peut aussi être décrit par une paire de nombres réels (r, phi), où r est la distance à l'origine O et phi l'angle entre l'axe des X et la ligne Oz. Ce qui donne z = r*exp(i*phi) = r*(cos(phi)+i*sin(phi)).

note: type: Plain text
en: The basic operations are defined on z = a+b*i and w = c+d*i as:
fr: Les opérations de base sur z = a+b*i et w = c+d*i sont définies comme suit :

note: type: TP
en: B<addition: z+w = (a+c) + (b+d)*i>
fr: B<addition : z+w = (a+c) + (b+d)*i>

note: type: TP
en: B<multiplication: z*w = (a*c - b*d) + (a*d + b*c)*i>
fr: B<multiplication : z*w = (a*c - b*d) + (a*d + b*c)*i>

note: type: TP
en: B<division: z/w = ((a*c + b*d)/(c*c + d*d)) + ((b*c - a*d)/(c*c + d*d))*i>
fr: B<division : z/w = ((a*c + b*d)/(c*c + d*d)) + ((b*c - a*d)/(c*c + d*d))*i>

note: type: Plain text
en: Nearly all math function have a complex counterpart but there are some complex-only functions.
fr: Presque toutes les fonctions mathématiques ont leur équivalent complexe mais il existe aussi des fonctions qui ne s'appliquent qu'aux nombres complexes.

note: type: Plain text
en: Your C-compiler can work with complex numbers if it supports the C99 standard.  Link with I<-lm>.  The imaginary unit is represented by I.
fr: Votre compilateur C peut traiter les nombres complexes s'il est conforme à la norme C99. Effectuez l'édition de liens avec I<-lm>. La partie imaginaire est représentée par I.

note: type: Plain text
en: /* check that exp(i * pi) == -1 */
    #include E<lt>math.hE<gt>        /* for atan */
    #include E<lt>stdio.hE<gt>
    #include E<lt>complex.hE<gt>
fr: /* vérifier que exp(i * pi) == -1 */
    #include E<lt>math.hE<gt>        /* pour atan */
    #include E<lt>stdio.hE<gt>
    #include E<lt>complex.hE<gt>

note: type: Plain text
en: conj, conjf, conjl - calculate the complex conjugate
fr: conj, conjf, conjl - Calculer le conjugué d'un complexe

note: type: Plain text
en: The B<conj>()  function returns the complex conjugate value of I<z>.  That is the value obtained by changing the sign of the imaginary part.
fr: La fonction B<conj>() renvoie la valeur conjuguée d'un complexe I<z>. C'est la valeur obtenue en modifiant le signe de la partie imaginaire.

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

note: type: Plain text
en: cpow, cpowf, cpowl - complex power function
fr: cpow, cpowf, cpowl - Fonction puissance complexe

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: The function calculates I<x> raised to the power I<z>.  (With a branch cut for I<x> along the negative real axis.)
fr: Ces fonctions calculent I<x> élevé à la puissance I<z> (avec une branche de coupure pour I<x> appartenant à l'axe réel négatif).

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

note: type: Plain text
en: cproj, cprojf, cprojl - project into Riemann Sphere
fr: cproj, cprojf, cprojl - Projections sur une sphère de Riemann

note: type: Plain text
en: These functions project a point in the plane onto the surface of a Riemann Sphere, the one-point compactification of the complex plane.  Each finite point I<z> projects to I<z> itself.  Every complex infinite value is projected to a single infinite value, namely to positive infinity on the real axis.
fr: Ces fonctions permettent de projeter un point d'un plan sur la surface d'une sphère de Riemann, le compactifié à un point du plan complexe. Chaque point complexe I<z> fini se projette sur lui-même, chaque point complexe ayant une composante infinie se projette en une valeur infinie donnée\ : l'infini positif sur l'axe réel.

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

note: http://sources.redhat.com/bugzilla/show_bug.cgi?id=10401 type: Plain text
en: In glibc 2.11 and earlier, the implementation does something different (a I<stereographic> projection onto a Riemann Sphere).
fr: Dans les versions 2.11 et antérieures de la glibc, l'implémentation effectue une opération différente (une projection I<stéréographique> sur une sphère de Riemann).

note: type: Plain text
en: creal, crealf, creall - get real part of a complex number
fr: creal, crealf, creall - Obtenir la partie réelle d'un nombre complexe

note: type: Plain text
en: The B<creal>()  function returns the real part of the complex number I<z>.
fr: La fonction B<creal>() renvoie la partie réelle du nombre complexe I<z>.

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

note: type: Plain text
en: The gcc supports also __real__.  That is a GNU extension.
fr: Le compilateur gcc supporte aussi la __real__. C'est une extension GNU.

note: type: Plain text
en: csin, csinf, csinl - complex sine function
fr: csin, csinf, csinl - Fonction sinus complexe

note: type: Plain text
en: The complex sine function is defined as:
fr: La fonction sinus complexe est définie par\ :

note: type: Plain text
en: csinh, csinhf, csinhl - complex hyperbolic sine
fr: csinh, csinhf, csinhl - Fonction sinus hyperbolique complexe

note: type: Plain text
en: The complex hyperbolic sine function is defined as:
fr: La fonction sinus hyperbolique complexe définie par\ :

note: type: Plain text
en: csqrt, csqrtf, csqrtl - complex square root
fr: csqrt, csqrtf, csqrtl - Fonction racine carrée complexe

note: type: Plain text
en: Calculate the square root of a given complex number, with nonnegative real part, and with a branch cut along the negative real axis.  (That means that I<csqrt(-1+eps*I)> will be close to I while I<csqrt(-1-eps*I)> will be close to -I, I<if eps> is a small positive real number.)
fr: Calculer la racine carrée d'un nombre complexe, avec une partie réelle positive, et avec une coupure le long de la partie négative de l'axe des réels. Cela signifie que I<csqrt(-1+eps*I)> tendra vers I alors que I<csqrt(-1-eps*I)> tendra vers I<-I>, si I<eps> est un réel positif proche de 0.

note: type: Plain text
en: ctan, ctanf, ctanl - complex tangent function
fr: ctan, ctanf, ctanl - Fonction tangente complexe

note: type: Plain text
en: The complex tangent function is defined as:
fr: La fonction tangente complexe est définie par\ :

note: type: Plain text
en: ctanh, ctanhf, ctanhl - complex hyperbolic tangent
fr: ctanh, ctanhf, ctanhl - Fonction tangente hyperbolique complexe

note: type: Plain text
en: The complex hyperbolic tangent function is defined mathematically as:
fr: La fonction tangente hyperbolique complexe est définie par\ :
