gcem

GCE-Matemática

GCE-Math ( G eneralized C onstant Expression Math) é uma biblioteca C++ modelada que permite a computação em tempo de compilação de funções matemáticas.

Características:

• A biblioteca é escrita no formato constexpr C++ 11 e é compatível com C++ 11/14/17/20.
• Expansões de frações contínuas e expansões de séries são implementadas usando modelos recursivos.
• A sintaxe gcem:: é idêntica à da biblioteca padrão C++ ( std:: ).
• Testado e preciso com precisão de ponto flutuante em relação à biblioteca padrão C++.
• Lançado sob uma licença permissiva e não GPL.

Autor : Keith O'Hara

Conteúdo:

• Status e Documentação
• Instalação
• Conjunto de testes
• Caderno Jupyter
• Sintaxe Geral
• Exemplos

Status e Documentação

A biblioteca é mantida ativamente e ainda está sendo ampliada. Uma lista de recursos inclui:

• Funções básicas da biblioteca:
  • abs , max , min , pow , sqrt , inv_sqrt ,
  • ceil , floor , round , trunc , fmod ,
  • exp , expm1 , log , log1p , log2 , log10 e mais
• Funções trigonométricas:
  • básico: cos , sin , tan
  • inverso: acos , asin , atan , atan2
• Funções hiperbólicas (área):
  • cosh , sinh , tanh , acosh , asinh , atanh
• Algoritmos:
  • gcd , lcm
• Funções especiais:
  • fatoriais e o coeficiente binomial: factorial , binomial_coef
  • funções beta, gama e gama multivariada: beta , lbeta , lgamma , tgamma , lmgamma
  • a função de erro gaussiana e a função de erro inverso: erf , erf_inv
  • (regularizado) funções beta incompletas e gama incompleta: incomplete_beta , incomplete_gamma
  • funções inversas beta incompleta e gama incompleta: incomplete_beta_inv , incomplete_gamma_inv

A documentação completa está disponível online:

Uma versão em PDF da documentação está disponível aqui.

Instalação

GCE-Math é uma biblioteca somente de cabeçalho e não requer nenhuma biblioteca ou utilitário adicional (além de um compilador compatível com C++ 11). Basta adicionar os arquivos de cabeçalho ao seu projeto usando:

# include " gcem.hpp "

Conda

Você pode instalar o GCE-Math usando o gerenciador de pacotes Conda.

conda install -c conda-forge gcem

CMake

Você também pode instalar a biblioteca do código-fonte usando 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

Por exemplo, /gcem/install/location poderia ser /usr/local/ .

Conjunto de testes

Existem duas maneiras de construir o conjunto de testes. Em sistemas semelhantes ao Unix, um Makefile está disponível em tests/ .

 cd ./gcem/tests
make
./run_tests

Com CMake, a opção GCEM_BUILD_TESTS=1 gera os Makefiles necessários para construir o conjunto de testes.

 cd ./gcem
mkdir build

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

cd tests
./exp.test

Caderno Jupyter

Você pode testar a biblioteca online usando um notebook Jupyter interativo:

Sintaxe Geral

As funções GCE-Math são escritas como modelos C++ com especificadores constexpr , cujo formato pode parecer confuso para usuários não familiarizados com programação baseada em modelos.

Por exemplo, a função de erro gaussiana ( erf ) é definida como:

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

Um conjunto de funções constexpr de modelo interno implementará uma expansão de fração contínua e retornará um valor do tipo return_t<T> . O tipo de saída (' return_t<T> ') é geralmente determinado pelo tipo de entrada, por exemplo, int , float , double , long double , etc.; quando T é um tipo integral, a saída será atualizada para return_t<T> = double , caso contrário return_t<T> = T . Para tipos não cobertos por std::is_integral , reformulações devem ser usadas.

Exemplos

Para calcular 10!:

# include " gcem.hpp "

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

    return 0 ;
}

Inspecionando o código assembly gerado pelo 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

Vemos que uma chamada de função foi substituída por um valor numérico (10! = 3628800).

Da mesma forma, para calcular a função log Gamma em um ponto:

# include " gcem.hpp "

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

    return 0 ;
}

Código de montagem:

 .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 

Bibliotecas relacionadas

• StatsLib é baseado na funcionalidade de tempo de compilação do GCEM.