gcem

GCE-Mathématiques

GCE-Math ( G eneralized C onstant Expression Math) est une bibliothèque C++ basée sur un modèle permettant le calcul de fonctions mathématiques au moment de la compilation.

Caractéristiques:

• La bibliothèque est écrite au format C++11 constexpr et est compatible C++11/14/17/20.
• Des expansions de fractions continues et des expansions de séries sont mises en œuvre à l'aide de modèles récursifs.
• La syntaxe gcem:: est identique à celle de la bibliothèque standard C++ ( std:: ).
• Testé et précis avec une précision en virgule flottante par rapport à la bibliothèque standard C++.
• Publié sous une licence permissive et non GPL.

Auteur : Keith O'Hara

Contenu:

• Statut et documentation
• Installation
• Suite de tests
• Carnet Jupyter
• Syntaxe générale
• Exemples

Statut et documentation

La bibliothèque est activement entretenue et est toujours en cours d'extension. Une liste de fonctionnalités comprend :

• Fonctions de base de la bibliothèque :
  • abs , max , min , pow , sqrt , inv_sqrt ,
  • ceil , floor , round , trunc , fmod ,
  • exp , expm1 , log , log1p , log2 , log10 et plus
• Fonctions trigonométriques :
  • basique : cos , sin , tan
  • inverse : acos , asin , atan , atan2
• Fonctions hyperboliques (surface) :
  • cosh , sinh , tanh , acosh , asinh , atanh
• Algorithmes :
  • gcd , lcm
• Fonctions spéciales :
  • factorielles et coefficient binomial : factorial , binomial_coef
  • Fonctions bêta, gamma et gamma multivariée : beta , lbeta , lgamma , tgamma , lmgamma
  • la fonction d'erreur gaussienne et la fonction d'erreur inverse : erf , erf_inv
  • Fonctions bêta incomplètes (régularisées) et gamma incomplètes : incomplete_beta , incomplete_gamma
  • Fonctions inverses bêta incomplètes et gamma incomplètes : incomplete_beta_inv , incomplete_gamma_inv

La documentation complète est disponible en ligne :

Une version PDF de la documentation est disponible ici.

Installation

GCE-Math est une bibliothèque d'en-tête uniquement et ne nécessite aucune bibliothèque ou utilitaire supplémentaire (au-delà d'un compilateur compatible C++11). Ajoutez simplement les fichiers d'en-tête à votre projet en utilisant :

# include " gcem.hpp "

Conda

Vous pouvez installer GCE-Math à l'aide du gestionnaire de packages Conda.

conda install -c conda-forge gcem

CMake

Vous pouvez également installer la bibliothèque à partir des sources à l'aide de CMake.

 # clone gcem from GitHub
git clone https://github.com/kthohr/gcem ./gcem

# make a build directory
cd ./gcem
mkdir build
cd build

# generate Makefiles and install
cmake .. -DCMAKE_INSTALL_PREFIX=/gcem/install/location
make install

Par exemple, /gcem/install/location pourrait être /usr/local/ .

Suite de tests

Il existe deux manières de créer la suite de tests. Sur les systèmes de type Unix, un Makefile est disponible sous tests/ .

 cd ./gcem/tests
make
./run_tests

Avec CMake, l'option GCEM_BUILD_TESTS=1 génère les Makefiles nécessaires pour construire la suite de tests.

 cd ./gcem
mkdir build

cd build
cmake ../ -DGCEM_BUILD_TESTS=1 -DCMAKE_INSTALL_PREFIX=/gcem/install/location
make gcem_tests

cd tests
./exp.test

Carnet Jupyter

Vous pouvez tester la bibliothèque en ligne à l'aide d'un bloc-notes Jupyter interactif :

Syntaxe générale

Les fonctions GCE-Math sont écrites sous forme de modèles C++ avec des spécificateurs constexpr , dont le format peut paraître déroutant aux utilisateurs peu familiers avec la programmation basée sur des modèles.

Par exemple, la fonction d'erreur gaussienne ( erf ) est définie comme :

 template < typename T>
constexpr
return_t <T>
erf ( const T x) noexcept ;

Un ensemble de fonctions constexpr internes basées sur un modèle implémentera une expansion continue de fraction et renverra une valeur de type return_t<T> . Le type de sortie (« return_t<T> ») est généralement déterminé par le type d'entrée, par exemple int , float , double , long double , etc. ; lorsque T est un type intégral, la sortie sera mise à niveau vers return_t<T> = double , sinon return_t<T> = T . Pour les types non couverts par std::is_integral , des refontes doivent être utilisées.

Exemples

Pour calculer 10 ! :

# include " gcem.hpp "

int main ()
{
    constexpr int x = 10 ;
    constexpr int res = gcem::factorial (x);

    return 0 ;
}

Inspection du code assembleur généré par Clang 7.0.0 :

        push    rbp
        mov     rbp , rsp
        xor     eax , eax
        mov     dword ptr [ rbp - 4 ], 0
        mov     dword ptr [ rbp - 8 ], 10
        mov     dword ptr [ rbp - 12 ], 3628800
        pop     rbp
        ret

On voit qu'un appel de fonction a été remplacé par une valeur numérique (10! = 3628800).

De même, pour calculer la fonction log Gamma en un point :

# include " gcem.hpp "

int main ()
{
    constexpr long double x = 1.5 ;
    constexpr long double res = gcem::lgamma (x);

    return 0 ;
}

Code d'assemblage :

 .LCPI0_0:
        .long   1069547520              # float 1 . 5
.LCPI0_1:
        .quad   - 622431863250842976     # x86_fp80 - 0 . 120782237635245222719
        .short  49147
        .zero   6
main:                                   # @main
        push    rbp
        mov     rbp , rsp
        xor     eax , eax
        mov     dword ptr [ rbp - 4 ], 0
        fld     dword ptr [ rip + .LCPI0_0 ]
        fstp    tbyte ptr [ rbp - 32 ]
        fld     tbyte ptr [ rip + .LCPI0_1 ]
        fstp    tbyte ptr [ rbp - 48 ]
        pop     rbp
        ret 

Bibliothèques associées

• StatsLib est construit sur la fonctionnalité de compilation de GCEM.