Merge pull request #6 from kthohr/v1.7.0

Version 1.7.0

Author: kthohr

.appveyor.yml

@@ -40,10 +40,12 @@ build_script:
   - .\erf.test
   - .\erf_inv.test
   - .\factorial.test
+  - .\gcd.test
   - .\incomplete_beta.test
   - .\incomplete_beta_inv.test
   - .\incomplete_gamma.test
   - .\incomplete_gamma_inv.test
+  - .\lcm.test
   - .\lgamma.test
   - .\log.test
   - .\other.test

README.md

@@ -116,7 +116,7 @@ GCE-Math functions are written as C++ templates with `constexpr` specifiers, the
 template<typename T>
 constexpr
 return_t<T>
-erf(const T x);
+erf(const T x) noexcept;
 ```
 where a set of internal templated ```constexpr``` functions will implement a continued fraction expansion to return a value of type ```return_t<T>```. This output type ('```return_t<T>```') is generally determined by the input type, e.g., ```int```, ```float```, ```double```, ```long double```, etc. When ```T``` is an intergral type, the output will be upgraded to ```return_t<T> = double```, otherwise ```return_t<T> = T```. For types not covered by ```std::is_integral```, recasts should be used.
 

docs/source/api/algorithms.rst

@@ -8,9 +8,9 @@ Algorithms
 ===============
 
 .. _gcd-function-reference:
-.. doxygenfunction:: gcd(const T, const T)
+.. doxygenfunction:: gcd(const T1, const T2)
    :project: gcem
 
 .. _lcm-function-reference:
-.. doxygenfunction:: lcm(const T, const T)
+.. doxygenfunction:: lcm(const T1, const T2)
    :project: gcem

docs/source/api/basic_functions.rst

@@ -24,15 +24,15 @@ Basic functions
    :project: gcem
 
 .. _max-function-reference:
-.. doxygenfunction:: max(const T, const T)
+.. doxygenfunction:: max(const T1, const T2)
    :project: gcem
 
 .. _min-function-reference:
-.. doxygenfunction:: min(const T, const T)
+.. doxygenfunction:: min(const T1, const T2)
    :project: gcem
 
 .. _pow-function-reference:
-.. doxygenfunction:: pow(const Ta, const Tb)
+.. doxygenfunction:: pow(const T1, const T2)
    :project: gcem
 
 .. _sgn-function-reference:

docs/source/api/special_functions.rst

@@ -8,15 +8,15 @@ Special functions
 ===============
 
 .. _binomial-func-ref:
-.. doxygenfunction:: binomial_coef(const pT, const pT)
+.. doxygenfunction:: binomial_coef(const T1, const T2)
    :project: gcem
 
 .. _beta-function-reference:
-.. doxygenfunction:: beta(const T, const T)
+.. doxygenfunction:: beta(const T1, const T2)
    :project: gcem
 
 .. _lbeta-func-ref:
-.. doxygenfunction:: lbeta(const T, const T)
+.. doxygenfunction:: lbeta(const T1, const T2)
    :project: gcem
 
 .. _tgamma-func-ref:
@@ -28,7 +28,7 @@ Special functions
    :project: gcem
 
 .. _lmgamma-func-ref:
-.. doxygenfunction:: lmgamma(const pT, const eT)
+.. doxygenfunction:: lmgamma(const T1, const T2)
    :project: gcem
 
 Incomplete integral functions
@@ -39,11 +39,11 @@ Incomplete integral functions
    :project: gcem
 
 .. _ib-func-ref:
-.. doxygenfunction:: incomplete_beta(const pT, const pT, const eT)
+.. doxygenfunction:: incomplete_beta(const T1, const T2, const T3)
    :project: gcem
 
 .. _ig-func-ref:
-.. doxygenfunction:: incomplete_gamma(const pT, const eT)
+.. doxygenfunction:: incomplete_gamma(const T1, const T2)
    :project: gcem
 
 Inverse incomplete integral functions
@@ -54,9 +54,9 @@ Inverse incomplete integral functions
    :project: gcem
 
 .. _iib-ref:
-.. doxygenfunction:: incomplete_beta_inv(const pT, const pT, const eT)
+.. doxygenfunction:: incomplete_beta_inv(const T1, const T2, const T3)
    :project: gcem
 
 .. _iig-ref:
-.. doxygenfunction:: incomplete_gamma_inv(const pT, const eT)
+.. doxygenfunction:: incomplete_gamma_inv(const T1, const T2)
    :project: gcem

docs/source/index.rst

@@ -47,7 +47,7 @@ GCE-Math functions are written as C++ templates with ``constexpr`` specifiers, t
     template<typename T>
     constexpr
     return_t<T>
-    erf(const T x);
+    erf(const T x) noexcept;
 
 where a set of internal templated ``constexpr`` functions will implement a continued fraction expansion to return a value of type ``return_t<T>``. This output type ('``return_t<T>``') is generally determined by the input type, e.g., ``int``, ``float``, ``double``, ``long double``, etc. When ``T`` is an intergral type, the output will be upgraded to ``return_t<T> = double``, otherwise ``return_t<T> = T``. For types not covered by ``std::is_integral``, recasts should be used.
 

include/gcem_incl/abs.hpp

@@ -32,6 +32,7 @@ template<typename T>
 constexpr
 T
 abs(const T x)
+noexcept
 {
     return( x < T(0) ? - x : x );
 }

include/gcem_incl/acos.hpp

@@ -32,6 +32,7 @@ template<typename T>
 constexpr
 T
 acos_compute(const T x)
+noexcept
 {
     return( // only defined on [-1,1]
             abs(x) > T(1) ? \
@@ -49,6 +50,7 @@ template<typename T>
 constexpr
 T
 acos_check(const T x)
+noexcept
 {
     return( x > T(0) ? \
             // if
@@ -70,8 +72,9 @@ template<typename T>
 constexpr
 return_t<T>
 acos(const T x)
+noexcept
 {
-    return internal::acos_check<return_t<T>>(x);
+    return internal::acos_check( static_cast<return_t<T>>(x) );
 }
 
 #endif

include/gcem_incl/acosh.hpp

@@ -32,6 +32,7 @@ template<typename T>
 constexpr
 T
 acosh_compute(const T x)
+noexcept
 {
     return( // function defined for x >= 1
             x < T(1) ? \
@@ -56,8 +57,9 @@ template<typename T>
 constexpr
 return_t<T>
 acosh(const T x)
+noexcept
 {
-    return internal::acosh_compute<return_t<T>>(x);
+    return internal::acosh_compute( static_cast<return_t<T>>(x) );
 }
 
 #endif

include/gcem_incl/asin.hpp

@@ -32,6 +32,7 @@ template<typename T>
 constexpr
 T
 asin_compute(const T x)
+noexcept
 {
     return( // only defined on [-1,1]
             x > T(1) ? \
@@ -49,6 +50,7 @@ template<typename T>
 constexpr
 T
 asin_check(const T x)
+noexcept
 {
     return( x < T(0) ? - asin_compute(-x) : asin_compute(x) );
 }
@@ -66,8 +68,9 @@ template<typename T>
 constexpr
 return_t<T>
 asin(const T x)
+noexcept
 {
-    return internal::asin_check<return_t<T>>(x);
+    return internal::asin_check( static_cast<return_t<T>>(x) );
 }
 
 #endif