std:: lgamma, std:: lgammaf, std:: lgammal

Paramètres

Valeur de retour

Si aucune erreur ne se produit, la valeur du logarithme de la fonction gamma de num , c'est-à-dire \(\log_{e}|{\int_0^\infty t^{num-1} e^{-t} \mathsf{d}t}|\) log e | ∫ ∞
0 t num-1
e ^-t d t | , est retournée.

Si une erreur de pôle se produit, +HUGE_VAL , +HUGE_VALF , ou +HUGE_VALL est renvoyé.

Si une erreur de plage due à un dépassement de capacité se produit, ±HUGE_VAL , ±HUGE_VALF , ou ±HUGE_VALL est renvoyé.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si num est nul ou est un entier inférieur à zéro, une erreur de pôle peut survenir.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

• Si l'argument est 1, +0 est retourné.
• Si l'argument est 2, +0 est retourné.
• Si l'argument est ±0, +∞ est retourné et FE_DIVBYZERO est déclenché.
• Si l'argument est un entier négatif, +∞ est retourné et FE_DIVBYZERO est déclenché.
• Si l'argument est ±∞, +∞ est retourné.
• Si l'argument est NaN, NaN est retourné.

Notes

Si num est un nombre naturel, std :: lgamma ( num ) est le logarithme de la factorielle de num - 1 .

La version POSIX de lgamma n'est pas thread-safe : chaque exécution de la fonction stocke le signe de la fonction gamma de num dans la variable externe statique signgam . Certaines implémentations fournissent lgamma_r , qui prend un pointeur vers un stockage fourni par l'utilisateur pour singgam comme second paramètre, et est thread-safe.

Il existe une fonction non standard nommée gamma dans diverses implémentations, mais sa définition est incohérente. Par exemple, la version glibc et 4.2BSD de gamma exécute lgamma , mais la version 4.4BSD de gamma exécute tgamma .

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: lgamma ( num ) ait le même effet que std :: lgamma ( static_cast < double > ( num ) ) .

Exemple

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1); // or std::numbers::pi since C++20
int main()
{
    std::cout << "lgamma(10) = " << std::lgamma(10)
              << ", log(9!) = " << std::log(std::tgamma(10))
              << ", exp(lgamma(10)) = " << std::exp(std::lgamma(10)) << '\n'
              << "lgamma(0.5) = " << std::lgamma(0.5)
              << ", log(sqrt(pi)) = " << std::log(std::sqrt(pi)) << '\n';
    // special values
    std::cout << "lgamma(1) = " << std::lgamma(1) << '\n'
              << "lgamma(+Inf) = " << std::lgamma(INFINITY) << '\n';
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "lgamma(0) = " << std::lgamma(0) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

lgamma(10) = 12.8018, log(9!) = 12.8018, exp(lgamma(10)) = 362880
lgamma(0.5) = 0.572365, log(sqrt(pi)) = 0.572365
lgamma(1) = 0
lgamma(+Inf) = inf
lgamma(0) = inf
    errno == ERANGE: Résultat numérique hors limites
    FE_DIVBYZERO raised

Voir aussi

Liens externes