Namespaces
Variants

Standard library header <cmath>

From cppreference.net
C++
Standard library headers

Cet en-tête était à l'origine dans la bibliothèque standard C sous le nom de <math.h> .

Cet en-tête fait partie de la bibliothèque numeric .

Table des matières

Types

float_t
(C++11)
type à virgule flottante le plus efficace d'au moins la largeur de float
(typedef)
double_t
(C++11)
type à virgule flottante le plus efficace d'au moins la largeur de double
(typedef)

Macros

(C++11) (C++11)
indique la valeur de dépassement de capacité pour float , double et long double respectivement
(constante macro)
(C++11)
évalue à l'infini positif ou la valeur garantissant un débordement d'un float
(constante macro)
(C++11)
évalue en un NaN silencieux de type float
(constante macro)
(C++11) (C++11) (C++11)
définit le mécanisme de gestion d'erreur utilisé par les fonctions mathématiques communes
(constante macro)
Classification
(C++11) (C++11) (C++11) (C++11) (C++11)
indique une catégorie de nombres à virgule flottante
(constante macro)

Fonctions

Opérations de base
(C++11) (C++11)
valeur absolue d'une valeur à virgule flottante ( |x| )
(fonction)
(C++11) (C++11)
reste de l'opération de division en virgule flottante
(fonction)
(C++11) (C++11) (C++11)
reste signé de l'opération de division
(fonction)
(C++11) (C++11) (C++11)
reste signé ainsi que les trois derniers bits de l'opération de division
(fonction)
(C++11) (C++11) (C++11)
opération de multiplication-addition fusionnée
(fonction)
(C++11) (C++11) (C++11)
plus grande de deux valeurs à virgule flottante
(fonction)
(C++11) (C++11) (C++11)
plus petite de deux valeurs à virgule flottante
(fonction)
(C++11) (C++11) (C++11)
différence positive de deux valeurs à virgule flottante ( max(0, x-y) )
(fonction)
(C++11) (C++11) (C++11)
pas un nombre (NaN)
(fonction)
Interpolation linéaire
(C++20)
fonction d'interpolation linéaire
(fonction)
Fonctions exponentielles
(C++11) (C++11)
retourne e élevé à la puissance donnée ( e x )
(fonction)
(C++11) (C++11) (C++11)
retourne 2 élevé à la puissance donnée ( 2 x )
(fonction)
(C++11) (C++11) (C++11)
retourne e élevé à la puissance donnée, moins 1 ( e x -1 )
(fonction)
(C++11) (C++11)
calcule le logarithme naturel (base e ) ( ln(x) )
(fonction)
(C++11) (C++11)
calcule le logarithme décimal (base 10 ) ( log 10 (x) )
(fonction)
(C++11) (C++11) (C++11)
logarithme en base 2 du nombre donné ( log 2 (x) )
(fonction)
(C++11) (C++11) (C++11)
logarithme naturel (en base e ) de 1 plus le nombre donné ( ln(1+x) )
(fonction)
Fonctions de puissance
(C++11) (C++11)
élève un nombre à la puissance donnée ( x y )
(fonction)
(C++11) (C++11)
calcule la racine carrée ( √ x )
(fonction)
(C++11) (C++11) (C++11)
calcule la racine cubique ( 3 √ x )
(fonction)
(C++11) (C++11) (C++11)
calcule l'hypoténuse √ x 2
+y 2
et √ x 2
+y 2
+z 2
(depuis C++17)
(fonction)
Fonctions trigonométriques
(C++11) (C++11)
calcule le sinus ( sin(x) )
(fonction)
(C++11) (C++11)
calcule le cosinus ( cos(x) )
(fonction)
(C++11) (C++11)
calcule la tangente ( tan(x) )
(fonction)
(C++11) (C++11)
calcule l'arc sinus ( arcsin(x) )
(fonction)
(C++11) (C++11)
calcule l'arc cosinus ( arccos(x) )
(fonction)
(C++11) (C++11)
calcule l'arc tangente ( arctan(x) )
(fonction)
(C++11) (C++11)
arc tangente, utilisant les signes pour déterminer les quadrants
(fonction)
Fonctions hyperboliques
(C++11) (C++11)
calcule le sinus hyperbolique ( sinh(x) )
(fonction)
(C++11) (C++11)
calcule le cosinus hyperbolique ( cosh(x) )
(fonction)
(C++11) (C++11)
calcule la tangente hyperbolique ( tanh(x) )
(fonction)
(C++11) (C++11) (C++11)
calcule le sinus hyperbolique inverse ( arsinh(x) )
(fonction)
(C++11) (C++11) (C++11)
calcule le cosinus hyperbolique inverse ( arcosh(x) )
(fonction)
(C++11) (C++11) (C++11)
calcule la tangente hyperbolique inverse ( artanh(x) )
(fonction)
Fonctions d'erreur et gamma
(C++11) (C++11) (C++11)
fonction d'erreur
(fonction)
(C++11) (C++11) (C++11)
fonction d'erreur complémentaire
(fonction)
(C++11) (C++11) (C++11)
fonction gamma
(fonction)
(C++11) (C++11) (C++11)
logarithme naturel de la fonction gamma
(fonction)
Opérations en virgule flottante d'entier le plus proche
(C++11) (C++11)
entier le plus proche non inférieur à la valeur donnée
(fonction)
(C++11) (C++11)
entier le plus proche inférieur ou égal à la valeur donnée
(fonction)
(C++11) (C++11) (C++11)
entier le plus proche dont la magnitude n'est pas supérieure à la valeur donnée
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
entier le plus proche, en arrondissant à l'opposé de zéro pour les cas à mi-chemin
(fonction)
(C++11) (C++11) (C++11)
entier le plus proche en utilisant le mode d'arrondi actuel
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
entier le plus proche en utilisant le mode d'arrondi actuel avec
exception si le résultat diffère
(fonction)
Fonctions de manipulation des nombres à virgule flottante
(C++11) (C++11)
décompose un nombre en significande et exposant de base 2
(fonction)
(C++11) (C++11)
multiplie un nombre par 2 élevé à une puissance entière
(fonction)
(C++11) (C++11)
décompose un nombre en parties entière et fractionnaire
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
multiplie un nombre par FLT_RADIX élevé à une puissance
(fonction)
(C++11) (C++11) (C++11)
extrait l'exposant du nombre
(fonction)
(C++11) (C++11) (C++11)
extrait l'exposant du nombre
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
prochaine valeur représentable en virgule flottante vers la valeur donnée
(fonction)
(C++11) (C++11) (C++11)
copie le signe d'une valeur à virgule flottante
(fonction)
Classification et comparaison
(C++11)
catégorise la valeur à virgule flottante donnée
(fonction)
(C++11)
vérifie si le nombre donné a une valeur finie
(fonction)
(C++11)
vérifie si le nombre donné est infini
(fonction)
(C++11)
vérifie si le nombre donné est NaN
(fonction)
(C++11)
vérifie si le nombre donné est normal
(fonction)
(C++11)
vérifie si le nombre donné est négatif
(fonction)
(C++11)
vérifie si le premier argument à virgule flottante est supérieur au second
(fonction)
(C++11)
vérifie si le premier argument à virgule flottante est supérieur ou égal au second
(fonction)
(C++11)
vérifie si le premier argument à virgule flottante est inférieur au second
(fonction)
(C++11)
vérifie si le premier argument à virgule flottante est inférieur ou égal au second
(fonction)
(C++11)
vérifie si le premier argument à virgule flottante est inférieur ou supérieur au second
(fonction)
(C++11)
vérifie si deux valeurs à virgule flottante ne sont pas ordonnées
(fonction)
Fonctions spéciales mathématiques
(C++17) (C++17) (C++17)
polynômes de Laguerre associés
(fonction)
(C++17) (C++17) (C++17)
polynômes de Legendre associés
(fonction)
(C++17) (C++17) (C++17)
fonction bêta
(fonction)
(C++17) (C++17) (C++17)
intégrale elliptique complète de première espèce
(fonction)
(C++17) (C++17) (C++17)
intégrale elliptique complète de deuxième espèce
(fonction)
(C++17) (C++17) (C++17)
Intégrale elliptique complète de troisième espèce
(fonction)
(C++17) (C++17) (C++17)
fonctions de Bessel cylindriques modifiées régulières
(fonction)
(C++17) (C++17) (C++17)
fonctions de Bessel cylindriques (de première espèce)
(fonction)
(C++17) (C++17) (C++17)
fonctions de Bessel cylindriques modifiées irrégulières
(fonction)
(C++17) (C++17) (C++17)
fonctions de Neumann cylindriques
(fonction)
(C++17) (C++17) (C++17)
intégrale elliptique incomplète de première espèce
(fonction)
(C++17) (C++17) (C++17)
intégrale elliptique incomplète de seconde espèce
(fonction)
(C++17) (C++17) (C++17)
intégrale elliptique incomplète de troisième espèce
(fonction)
(C++17) (C++17) (C++17)
intégrale exponentielle
(fonction)
(C++17) (C++17) (C++17)
Polynômes d'Hermite
(fonction)
(C++17) (C++17) (C++17)
Polynômes de Legendre
(fonction)
(C++17) (C++17) (C++17)
Polynômes de Laguerre
(fonction)
(C++17) (C++17) (C++17)
Fonction zêta de Riemann
(fonction)
(C++17) (C++17) (C++17)
fonctions de Bessel sphériques (de première espèce)
(fonction)
(C++17) (C++17) (C++17)
fonctions de Legendre associées sphériques
(fonction)
(C++17) (C++17) (C++17)
fonctions de Neumann sphériques
(fonction)

Synopsis

Pour chaque fonction ayant au moins un paramètre de type /* floating-point-type */ , une surcharge pour chaque type flottant non qualifié cv est fournie, où toutes les utilisations de /* floating-point-type */ dans la signature de la fonction sont remplacées par ce type flottant.

Pour chaque fonction ayant au moins un paramètre de type /* floating-point-type */ autre que std::abs , des surcharges supplémentaires sont fournies pour garantir que, si chaque argument correspondant à un paramètre /* floating-point-type */ a un type arithmétique, alors chaque argument de ce type est effectivement converti vers le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante parmi les types de tous ces arguments, où les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double . Si aucun type à virgule flottante avec le rang et la sous-catégorie les plus élevés n'existe, alors la résolution de surcharge ne produit aucun candidat utilisable parmi les surcharges fournies. 

namespace std {
  using float_t = /* voir description */;
  using double_t = /* voir description */;
}
#define HUGE_VAL /* voir description */
#define HUGE_VALF /* voir description */
#define HUGE_VALL /* voir description */
#define INFINITY /* voir description */
#define NAN /* voir description */
#define FP_INFINITE /* voir description */
#define FP_NAN /* voir description */
#define FP_NORMAL /* voir description */
#define FP_SUBNORMAL /* voir description */
#define FP_ZERO /* voir description */
#define FP_FAST_FMA /* voir description */
#define FP_FAST_FMAF /* voir description */
#define FP_FAST_FMAL /* voir description */
#define FP_ILOGB0 /* voir description */
#define FP_ILOGBNAN /* voir description */
#define MATH_ERRNO /* voir description */
#define MATH_ERREXCEPT /* voir description */
#define math_errhandling /* voir description */
namespace std {
  /* type à virgule flottante */ acos(/* type à virgule flottante */ x);
  float acosf(float x);
  long double acosl(long double x);
  /* type à virgule flottante */ asin(/* type à virgule flottante */ x);
  float asinf(float x);
  long double asinl(long double x);
  /* type à virgule flottante */ atan(/* type à virgule flottante */ x);
  float atanf(float x);
  long double atanl(long double x);
  /* type à virgule flottante */ atan2(/* type à virgule flottante */ y,
                                  /* type à virgule flottante */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
  /* type à virgule flottante */ cos(/* type à virgule flottante */e x);
  float cosf(float x);
  long double cosl(long double x);
  /* type à virgule flottante */ sin(/* type à virgule flottante */ x);
  float sinf(float x);
  long double sinl(long double x);
  /* type à virgule flottante */ tan(/* type à virgule flottante */ x);
  float tanf(float x);
  long double tanl(long double x);
  /* type à virgule flottante */ acosh(/* type à virgule flottante */ x);
  float acoshf(float x);
  long double acoshl(long double x);
  /* type à virgule flottante */ asinh(/* type à virgule flottante */ x);
  float asinhf(float x);
  long double asinhl(long double x);
  /* type à virgule flottante */ atanh(/* type à virgule flottante */ x);
  float atanhf(float x);
  long double atanhl(long double x);
  /* type à virgule flottante */ cosh(/* type à virgule flottante */ x);
  float coshf(float x);
  long double coshl(long double x);
  /* type à virgule flottante */ sinh(/* type à virgule flottante */ x);
  float sinhf(float x);
  long double sinhl(long double x);
  /* type à virgule flottante */ tanh(/* type à virgule flottante */ x);
  float tanhf(float x);
  long double tanhl(long double x);
  /* type à virgule flottante */ exp(/* type à virgule flottante */ x);
  float expf(float x);
  long double expl(long double x);
  /* type à virgule flottante */ exp2(/* type à virgule flottante */ x);
  float exp2f(float x);
  long double exp2l(long double x);
  /* type à virgule flottante */ expm1(/* type à virgule flottante */ x);
  float expm1f(float x);
  long double expm1l(long double x);
  constexpr /* type à virgule flottante */ frexp(/* type à virgule flottante */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
  constexpr int ilogb(/* type à virgule flottante */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
  constexpr /* type à virgule flottante */ ldexp(/* type à virgule flottante */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
  /* type à virgule flottante */ log(/* type à virgule flottante */ x);
  float logf(float x);
  long double logl(long double x);
  /* type à virgule flottante */ log10(/* type à virgule flottante */ x);
  float log10f(float x);
  long double log10l(long double x);
  /* type à virgule flottante */ log1p(/* type à virgule flottante */ x);
  float log1pf(float x);
  long double log1pl(long double x);
  /* type à virgule flottante */ log2(/* type à virgule flottante */ x);
  float log2f(float x);
  long double log2l(long double x);
  constexpr /* type à virgule flottante */ logb(/* type à virgule flottante */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
  constexpr /* type à virgule flottante */ modf(/* type à virgule flottante */ value,
                                           /* type à virgule flottante */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
  constexpr /* type à virgule flottante */ scalbn(/* type à virgule flottante */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
  constexpr /* type à virgule flottante */ scalbln(/* type à virgule flottante */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
  /* type à virgule flottante */ cbrt(/* type à virgule flottante */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
  // valeurs absolues
  constexpr int abs(int j);                     // freestanding
  constexpr long int abs(long int j);           // autonome
  constexpr long long int abs(long long int j); // autonome
  constexpr /* type à virgule flottante */
    abs(/* type à virgule flottante */ j);           // freestanding-deleted
  constexpr /* type à virgule flottante */ fabs(/* type à virgule flottante */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
  /* type à virgule flottante */ hypot(/* type à virgule flottante */ x,
                                  /* type à virgule flottante */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
  // hypoténuse tridimensionnelle
  float hypot(/* type à virgule flottante */ x,
              /* type à virgule flottante */ y,
              /* type à virgule flottante */ z);
  /* type à virgule flottante */ pow(/* type à virgule flottante */ x,
                                /* type à virgule flottante */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
  /* type à virgule flottante */ sqrt(/* type à virgule flottante */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
  /* type à virgule flottante */ erf(/* type à virgule flottante */ x);
  float erff(float x);
  long double erfl(long double x);
  /* type à virgule flottante */ erfc(/* type à virgule flottante */ x);
  float erfcf(float x);
  long double erfcl(long double x);
  /* type à virgule flottante */ lgamma(/* type à virgule flottante */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
  /* type à virgule flottante */ tgamma(/* type à virgule flottante */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
  constexpr /* type à virgule flottante */ ceil(/* type à virgule flottante */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
  constexpr /* type à virgule flottante */ floor(/* type à virgule flottante */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
  /* type à virgule flottante */ nearbyint(/* type à virgule flottante */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
  /* type à virgule flottante */ rint(/* type à virgule flottante */ x);
  float rintf(float x);
  long double rintl(long double x);
  long int lrint(/* type à virgule flottante */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
  long long int llrint(/* type à virgule flottante */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
  constexpr /* type à virgule flottante */ round(/* type à virgule flottante */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
  constexpr long int lround(/* type à virgule flottante */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
  constexpr long long int llround(/* type à virgule flottante */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
  constexpr /* type à virgule flottante */ trunc(/* type à virgule flottante */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
  constexpr /* type à virgule flottante */ fmod(/* type à virgule flottante */ x,
                                           /* type à virgule flottante */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
  constexpr /* type à virgule flottante */ remainder(/* type à virgule flottante */ x,
                                                /* type à virgule flottante */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
  constexpr /* type à virgule flottante */ remquo(/* type à virgule flottante */ x,
                                             /* type à virgule flottante */ y, int* quo);
  constexpr float remquof(float x, float y, int* quo);
  constexpr long double remquol(long double x, long double y, int* quo);
  constexpr /* type à virgule flottante */ copysign(/* type à virgule flottante */ x,
                                               /* type à virgule flottante */ y);
  constexpr float copysignf(float x, float y);
  constexpr long double copysignl(long double x, long double y);
  double nan(const char* tagp);
  float nanf(const char* tagp);
  long double nanl(const char* tagp);
  constexpr /* type à virgule flottante */ nextafter(/* type à virgule flottante */ x,
                                                /* type à virgule flottante */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
  constexpr /* type à virgule flottante */ nexttoward(/* type à virgule flottante */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
  constexpr /* type à virgule flottante */ fdim(/* type à virgule flottante */ x,
                                           /* type à virgule flottante */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
  constexpr /* type à virgule flottante */ fmax(/* type à virgule flottante */ x,
                                           /* type à virgule flottante */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
  constexpr /* type à virgule flottante */ fmin(/* type à virgule flottante */ x,
                                           /* type à virgule flottante */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
  constexpr /* type à virgule flottante */ fma(/* type à virgule flottante */ x,
                                          /* type à virgule flottante */ y,
                                          /* type à virgule flottante */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
  // interpolation linéaire
  constexpr /* type à virgule flottante */ lerp(/* type à virgule flottante */ a,
                                           /* type à virgule flottante */ b,
                                           /* type à virgule flottante */ t) noexcept;
  // fonctions de classification / comparaison
  constexpr int fpclassify(/* type à virgule flottante */ x);
  constexpr bool isfinite(/* type à virgule flottante */ x);
  constexpr bool isinf(/* type à virgule flottante */ x);
  constexpr bool isnan(/* type à virgule flottante */ x);
  constexpr bool isnormal(/* type à virgule flottante */ x);
  constexpr bool signbit(/* type à virgule flottante */ x);
  constexpr bool isgreater(/* type à virgule flottante */ x,
                           /* type à virgule flottante */ y);
  constexpr bool isgreaterequal(/* type à virgule flottante */ x,
                                /* type à virgule flottante */ y);
  constexpr bool isless(/* type à virgule flottante */ x,
                        /* type à virgule flottante */ y);
  constexpr bool islessequal(/* type à virgule flottante */ x,
                             /* type à virgule flottante */ y);
  constexpr bool islessgreater(/* type à virgule flottante */ x,
                               /* type à virgule flottante */ y);
  constexpr bool isunordered(/* type à virgule flottante */ x,
                             /* type à virgule flottante */ y);
  // fonctions mathématiques spéciales
  // polynômes de Laguerre associés
  /* type à virgule flottante */ assoc_laguerre(unsigned n, unsigned m,
                                           /* type à virgule flottante */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
  // fonctions de Legendre associées
  /* type à virgule flottante */ assoc_legendre(unsigned l, unsigned m,
                                           /* type à virgule flottante */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
  // fonction bêta
  /* type à virgule flottante */ beta(/* type à virgule flottante */ x,
                                 /* type à virgule flottante */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
  // intégrale elliptique complète de première espèce
  /* type à virgule flottante */ comp_ellint_1(/* type à virgule flottante */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
  // intégrale elliptique complète de la seconde espèce
  /* type à virgule flottante */ comp_ellint_2(/* type à virgule flottante */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
  // intégrale elliptique complète de la troisième espèce
  /* type à virgule flottante */ comp_ellint_3(/* type à virgule flottante */ k,
                                          /* type à virgule flottante */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
  // fonctions de Bessel cylindriques modifiées régulières
  /* type à virgule flottante */ cyl_bessel_i(/* type à virgule flottante */ nu,
                                         /* type à virgule flottante */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
  // fonctions de Bessel cylindriques de première espèce
  /* type à virgule flottante */ cyl_bessel_j(/* type à virgule flottante */ nu,
                                         /* type à virgule flottante */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
  // fonctions de Bessel cylindriques modifiées irrégulières
  /* type à virgule flottante */ cyl_bessel_k(/* type à virgule flottante */ nu,
                                         /* type à virgule flottante */ x);
  float cyl_bessel_kf(float nu, float x);
  long double cyl_bessel_kl(long double nu, long double x);
  // fonctions de Neumann cylindriques;
  // fonctions de Bessel cylindriques de seconde espèce
  /* type à virgule flottante */ cyl_neumann(/* type à virgule flottante */ nu,
                                        /* type à virgule flottante */ x);
  float cyl_neumannf(float nu, float x);
  long double cyl_neumannl(long double nu, long double x);
  // intégrale elliptique incomplète de première espèce
  /* type à virgule flottante */ ellint_1(/* type à virgule flottante */ k,
                                     /* type à virgule flottante */ phi);
  float ellint_1f(float k, float phi);
  long double ellint_1l(long double k, long double phi);
  // intégrale elliptique incomplète de la seconde espèce
  /* type à virgule flottante */ ellint_2(/* type à virgule flottante */ k,
                                     /* type à virgule flottante */ phi);
  float ellint_2f(float k, float phi);
  long double ellint_2l(long double k, long double phi);
  // intégrale elliptique incomplète de la troisième espèce
  /* type à virgule flottante */ ellint_3(/* type à virgule flottante */ k,
                                     /* type à virgule flottante */ nu,
                                     /* type à virgule flottante */ phi);
  float ellint_3f(float k, float nu, float phi);
  long double ellint_3l(long double k, long double nu, long double phi);
  // intégrale exponentielle
  /* type à virgule flottante */ expint(/* type à virgule flottante */ x);
  float expintf(float x);
  long double expintl(long double x);
  // Polynômes d'Hermite
  /* type à virgule flottante */ hermite(unsigned n, /* type à virgule flottante */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
  // Polynômes de Laguerre
  /* type à virgule flottante */ laguerre(unsigned n, /* type à virgule flottante */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
  // Polynômes de Legendre
  /* type à virgule flottante */ legendre(unsigned l, /* type à virgule flottante */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
  // Fonction zêta de Riemann
  /* type à virgule flottante */ riemann_zeta(/* type à virgule flottante */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
  // fonctions de Bessel sphériques de première espèce
  /* type à virgule flottante */ sph_bessel(unsigned n, /* type à virgule flottante */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
  // fonctions de Legendre associées sphériques
  /* type à virgule flottante */ sph_legendre(unsigned l, unsigned m,
                                         /* type à virgule flottante */ theta);
  float sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
  // fonctions de Neumann sphériques ;
  // fonctions de Bessel sphériques de seconde espèce
  /* type à virgule flottante */ sph_neumann(unsigned n, /* type à virgule flottante */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}