WPILibC++ 2024.3.2
gcem::internal Namespace Reference

Functions

constexpr bool is_even (const llint_t x) noexcept
 
template<typename T >
constexpr T acos_compute (const T x) noexcept
 
template<typename T >
constexpr T acos_check (const T x) noexcept
 
template<typename T >
constexpr T binomial_coef_recur (const T n, const T k) noexcept
 
template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T binomial_coef_check (const T n, const T k) noexcept
 
template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC binomial_coef_type_check (const T1 n, const T2 k) noexcept
 
template<typename T >
constexpr T incomplete_beta_cf (const T a, const T b, const T z, const T c_j, const T d_j, const T f_j, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_beta_coef_even (const T a, const T b, const T z, const int k) noexcept
 
template<typename T >
constexpr T incomplete_beta_coef_odd (const T a, const T b, const T z, const int k) noexcept
 
template<typename T >
constexpr T incomplete_beta_coef (const T a, const T b, const T z, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_beta_c_update (const T a, const T b, const T z, const T c_j, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_beta_d_update (const T a, const T b, const T z, const T d_j, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_beta_decision (const T a, const T b, const T z, const T c_j, const T d_j, const T f_j, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_beta_begin (const T a, const T b, const T z) noexcept
 
template<typename T >
constexpr T incomplete_beta_check (const T a, const T b, const T z) noexcept
 
template<typename T1 , typename T2 , typename T3 , typename TC = common_return_t<T1,T2,T3>>
constexpr TC incomplete_beta_type_check (const T1 a, const T2 b, const T3 p) noexcept
 
template<typename T >
constexpr T atan2_compute (const T y, const T x) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC atan2_type_check (const T1 y, const T2 x) noexcept
 
template<typename T1 , typename T2 >
constexpr T1 pow_integral_compute (const T1 base, const T2 exp_term) noexcept
 
template<typename T1 , typename T2 >
constexpr T1 pow_integral_compute_recur (const T1 base, const T1 val, const T2 exp_term) noexcept
 
template<typename T1 , typename T2 , typename std::enable_if< std::is_signed< T2 >::value >::type * = nullptr>
constexpr T1 pow_integral_sgn_check (const T1 base, const T2 exp_term) noexcept
 
template<typename T1 , typename T2 , typename std::enable_if< std::is_integral< T2 >::value >::type * = nullptr>
constexpr T1 pow_integral_type_check (const T1 base, const T2 exp_term) noexcept
 
template<typename T1 , typename T2 >
constexpr T1 pow_integral (const T1 base, const T2 exp_term) noexcept
 
template<typename T >
constexpr T find_fraction (const T x) noexcept
 
constexpr bool is_odd (const llint_t x) noexcept
 
template<typename T >
constexpr T expm1_compute (const T x) noexcept
 
template<typename T >
constexpr T expm1_check (const T x) noexcept
 
template<typename T >
constexpr bool is_nan (const T x) noexcept
 
template<typename T1 , typename T2 >
constexpr bool any_nan (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 >
constexpr bool all_nan (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool any_nan (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool all_nan (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 >
constexpr T1 lmgamma_recur (const T1 a, const T2 p) noexcept
 
template<typename T >
constexpr llint_t find_exponent (const T x, const llint_t exponent) noexcept
 
template<typename T >
constexpr bool neg_zero (const T x) noexcept
 
template<typename T >
constexpr T trunc_int (const T x) noexcept
 
template<typename T >
constexpr T trunc_check_internal (const T x) noexcept
 
template<>
constexpr float trunc_check_internal< float > (const float x) noexcept
 
template<>
constexpr double trunc_check_internal< double > (const double x) noexcept
 
template<>
constexpr long double trunc_check_internal< long double > (const long double x) noexcept
 
template<typename T >
constexpr T trunc_check (const T x) noexcept
 
template<typename T >
constexpr T lcm_compute (const T a, const T b) noexcept
 
template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC lcm_type_check (const T1 a, const T2 b) noexcept
 
template<typename T >
constexpr T erf_cf_large_recur (const T x, const int depth) noexcept
 
template<typename T >
constexpr T erf_cf_large_main (const T x) noexcept
 
template<typename T >
constexpr T erf_cf_small_recur (const T xx, const int depth) noexcept
 
template<typename T >
constexpr T erf_cf_small_main (const T x) noexcept
 
template<typename T >
constexpr T erf_begin (const T x) noexcept
 
template<typename T >
constexpr T erf_check (const T x) noexcept
 
template<typename T >
constexpr T tanh_cf (const T xx, const int depth) noexcept
 
template<typename T >
constexpr T tanh_begin (const T x) noexcept
 
template<typename T >
constexpr T tanh_check (const T x) noexcept
 
template<typename T >
constexpr T atanh_compute (const T x) noexcept
 
template<typename T >
constexpr T atanh_check (const T x) noexcept
 
template<typename T >
constexpr T inv_sqrt_recur (const T x, const T xn, const int count) noexcept
 
template<typename T >
constexpr T inv_sqrt_check (const T x) noexcept
 
template<typename T >
constexpr T log1p_compute (const T x) noexcept
 
template<typename T >
constexpr T log1p_check (const T x) noexcept
 
template<typename T >
constexpr T log_binomial_coef_compute (const T n, const T k) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC log_binomial_coef_type_check (const T1 n, const T2 k) noexcept
 
template<typename T >
constexpr T round_int (const T x) noexcept
 
template<typename T >
constexpr T round_check_internal (const T x) noexcept
 
template<>
constexpr float round_check_internal< float > (const float x) noexcept
 
template<>
constexpr double round_check_internal< double > (const double x) noexcept
 
template<>
constexpr long double round_check_internal< long double > (const long double x) noexcept
 
template<typename T >
constexpr T round_check (const T x) noexcept
 
constexpr long double lgamma_coef_term (const long double x) noexcept
 
template<typename T >
constexpr T lgamma_term_2 (const T x) noexcept
 
template<typename T >
constexpr T lgamma_term_1 (const T x) noexcept
 
template<typename T >
constexpr T lgamma_begin (const T x) noexcept
 
template<typename T >
constexpr T lgamma_check (const T x) noexcept
 
template<typename T >
constexpr T log_cf_main (const T xx, const int depth) noexcept
 
template<typename T >
constexpr T log_cf_begin (const T x) noexcept
 
template<typename T >
constexpr T log_main (const T x) noexcept
 
constexpr long double log_mantissa_integer (const int x) noexcept
 
template<typename T >
constexpr T log_mantissa (const T x) noexcept
 
template<typename T >
constexpr T log_breakup (const T x) noexcept
 
template<typename T >
constexpr T log_check (const T x) noexcept
 
template<typename T >
constexpr return_t< T > log_integral_check (const T x) noexcept
 
template<typename T >
constexpr bool is_finite (const T x) noexcept
 
template<typename T1 , typename T2 >
constexpr bool any_finite (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 >
constexpr bool all_finite (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool any_finite (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool all_finite (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T >
constexpr T pow_dbl (const T base, const T exp_term) noexcept
 
template<typename T1 , typename T2 , typename TC = common_t<T1,T2>, typename std::enable_if<!std::is_integral< T2 >::value >::type * = nullptr>
constexpr TC pow_check (const T1 base, const T2 exp_term) noexcept
 
template<typename T >
constexpr bool is_neginf (const T x) noexcept
 
template<typename T1 , typename T2 >
constexpr bool any_neginf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 >
constexpr bool all_neginf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool any_neginf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool all_neginf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T >
constexpr bool is_posinf (const T x) noexcept
 
template<typename T1 , typename T2 >
constexpr bool any_posinf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 >
constexpr bool all_posinf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool any_posinf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool all_posinf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T >
constexpr bool is_inf (const T x) noexcept
 
template<typename T1 , typename T2 >
constexpr bool any_inf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 >
constexpr bool all_inf (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool any_inf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T1 , typename T2 , typename T3 >
constexpr bool all_inf (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T >
constexpr return_t< T > log2_check (const T x) noexcept
 
template<typename T >
constexpr T mantissa (const T x) noexcept
 
template<typename T >
constexpr T cos_compute (const T x) noexcept
 
template<typename T >
constexpr T cos_check (const T x) noexcept
 
template<typename T >
constexpr T acosh_compute (const T x) noexcept
 
template<typename T >
constexpr T sinh_check (const T x) noexcept
 
template<typename T >
constexpr T asinh_compute (const T x) noexcept
 
template<typename T >
constexpr T sin_compute (const T x) noexcept
 
template<typename T >
constexpr T sin_check (const T x) noexcept
 
template<typename T >
constexpr T atan_series_order_calc (const T x, const T x_pow, const uint_t order) noexcept
 
template<typename T >
constexpr T atan_series_order (const T x, const T x_pow, const uint_t order, const uint_t max_order) noexcept
 
template<typename T >
constexpr T atan_series_main (const T x) noexcept
 
template<typename T >
constexpr T atan_cf_recur (const T xx, const uint_t depth, const uint_t max_depth) noexcept
 
template<typename T >
constexpr T atan_cf_main (const T x) noexcept
 
template<typename T >
constexpr T atan_begin (const T x) noexcept
 
template<typename T >
constexpr T atan_check (const T x) noexcept
 
template<typename T >
constexpr return_t< T > log10_check (const T x) noexcept
 
template<typename T >
constexpr T tan_series_exp_long (const T z) noexcept
 
template<typename T >
constexpr T tan_series_exp (const T x) noexcept
 
template<typename T >
constexpr T tan_cf_recur (const T xx, const int depth, const int max_depth) noexcept
 
template<typename T >
constexpr T tan_cf_main (const T x) noexcept
 
template<typename T >
constexpr T tan_begin (const T x, const int count=0) noexcept
 
template<typename T >
constexpr T tan_check (const T x) noexcept
 
template<typename T >
constexpr T exp_cf_recur (const T x, const int depth) noexcept
 
template<typename T >
constexpr T exp_cf (const T x) noexcept
 
template<typename T >
constexpr T exp_split (const T x) noexcept
 
template<typename T >
constexpr T exp_check (const T x) noexcept
 
template<typename T >
constexpr T factorial_table (const T x) noexcept
 
template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T factorial_recur (const T x) noexcept
 
template<typename T >
constexpr T fmod_check (const T x, const T y) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC fmod_type_check (const T1 x, const T2 y) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_decision (const T value, const T alpha_par, const T beta_par, const T p, const T direc, const T lb_val, const int iter_count) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_tval (const T p) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_begin (const T t_val) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_ab1 (const T alpha_par, const T beta_par) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_ab2 (const T alpha_par, const T beta_par) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_h (const T ab_term_1) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_w (const T value, const T ab_term_2, const T h_term) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1_int_end (const T alpha_par, const T beta_par, const T w_term) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_1 (const T alpha_par, const T beta_par, const T t_val, const T sgn_term) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_2_s1 (const T alpha_par, const T beta_par) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_2_s2 (const T alpha_par, const T beta_par) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val_2 (const T alpha_par, const T beta_par, const T p, const T s_1, const T s_2) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_initial_val (const T alpha_par, const T beta_par, const T p) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_err_val (const T value, const T alpha_par, const T beta_par, const T p) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_deriv_1 (const T value, const T alpha_par, const T beta_par, const T lb_val) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_deriv_2 (const T value, const T alpha_par, const T beta_par, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_ratio_val_1 (const T value, const T alpha_par, const T beta_par, const T p, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_ratio_val_2 (const T value, const T alpha_par, const T beta_par, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_halley (const T ratio_val_1, const T ratio_val_2) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_recur (const T value, const T alpha_par, const T beta_par, const T p, const T deriv_1, const T lb_val, const int iter_count) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_begin (const T initial_val, const T alpha_par, const T beta_par, const T p, const T lb_val) noexcept
 
template<typename T >
constexpr T incomplete_beta_inv_check (const T alpha_par, const T beta_par, const T p) noexcept
 
template<typename T1 , typename T2 , typename T3 , typename TC = common_t<T1,T2,T3>>
constexpr TC incomplete_beta_inv_type_check (const T1 a, const T2 b, const T3 p) noexcept
 
template<typename T >
constexpr llint_t find_whole (const T x) noexcept
 
template<typename T >
constexpr T gcd_recur (const T a, const T b) noexcept
 
template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T gcd_int_check (const T a, const T b) noexcept
 
template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC gcd_type_check (const T1 a, const T2 b) noexcept
 
template<typename T >
constexpr T erf_inv_decision (const T value, const T p, const T direc, const int iter_count) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val_coef_2 (const T a, const T p_term, const int order) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val_case_2 (const T a, const T p_term, const int order) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val_coef_1 (const T a, const T p_term, const int order) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val_case_1 (const T a, const T p_term, const int order) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val_int (const T a) noexcept
 
template<typename T >
constexpr T erf_inv_initial_val (const T x) noexcept
 
template<typename T >
constexpr T erf_inv_err_val (const T value, const T p) noexcept
 
template<typename T >
constexpr T erf_inv_deriv_1 (const T value) noexcept
 
template<typename T >
constexpr T erf_inv_deriv_2 (const T value, const T deriv_1) noexcept
 
template<typename T >
constexpr T erf_inv_ratio_val_1 (const T value, const T p, const T deriv_1) noexcept
 
template<typename T >
constexpr T erf_inv_ratio_val_2 (const T value, const T deriv_1) noexcept
 
template<typename T >
constexpr T erf_inv_halley (const T ratio_val_1, const T ratio_val_2) noexcept
 
template<typename T >
constexpr T erf_inv_recur (const T value, const T p, const T deriv_1, const int iter_count) noexcept
 
template<typename T >
constexpr T erf_inv_recur_begin (const T initial_val, const T p) noexcept
 
template<typename T >
constexpr T erf_inv_begin (const T p) noexcept
 
template<typename T >
constexpr T sqrt_recur (const T x, const T xn, const int count) noexcept
 
template<typename T >
constexpr T sqrt_simplify (const T x, const T m_val) noexcept
 
template<typename T >
constexpr T sqrt_check (const T x) noexcept
 
template<typename T >
constexpr T cosh_compute (const T x) noexcept
 
template<typename T >
constexpr T asin_compute (const T x) noexcept
 
template<typename T >
constexpr T asin_check (const T x) noexcept
 
template<typename T >
constexpr int ceil_resid (const T x, const T x_whole) noexcept
 
template<typename T >
constexpr T ceil_int (const T x, const T x_whole) noexcept
 
template<typename T >
constexpr T ceil_check_internal (const T x) noexcept
 
template<>
constexpr float ceil_check_internal< float > (const float x) noexcept
 
template<>
constexpr double ceil_check_internal< double > (const double x) noexcept
 
template<>
constexpr long double ceil_check_internal< long double > (const long double x) noexcept
 
template<typename T >
constexpr T ceil_check (const T x) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_decision (const T value, const T a, const T p, const T direc, const T lg_val, const int iter_count) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_t_val_1 (const T p) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_t_val_2 (const T a) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_initial_val_1_int_begin (const T t_val) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_initial_val_1_int_end (const T value_inp, const T a) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_initial_val_1 (const T a, const T t_val, const T sgn_term) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_initial_val_2 (const T a, const T p, const T t_val) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_initial_val (const T a, const T p) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_err_val (const T value, const T a, const T p) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_deriv_1 (const T value, const T a, const T lg_val) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_deriv_2 (const T value, const T a, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_ratio_val_1 (const T value, const T a, const T p, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_ratio_val_2 (const T value, const T a, const T deriv_1) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_halley (const T ratio_val_1, const T ratio_val_2) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_recur (const T value, const T a, const T p, const T deriv_1, const T lg_val, const int iter_count) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_begin (const T initial_val, const T a, const T p, const T lg_val) noexcept
 
template<typename T >
constexpr T incomplete_gamma_inv_check (const T a, const T p) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC incomplete_gamma_inv_type_check (const T1 a, const T2 p) noexcept
 
template<typename T >
constexpr T tgamma_check (const T x) noexcept
 
template<typename T >
constexpr T hypot_compute (const T x, const T y) noexcept
 
template<typename T >
constexpr T hypot_compute (const T x, const T y, const T z) noexcept
 
template<typename T >
constexpr T hypot_vals_check (const T x, const T y) noexcept
 
template<typename T >
constexpr T hypot_vals_check (const T x, const T y, const T z) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC hypot_type_check (const T1 x, const T2 y) noexcept
 
template<typename T1 , typename T2 , typename T3 , typename TC = common_return_t<T1,T2,T3>>
constexpr TC hypot_type_check (const T1 x, const T2 y, const T3 z) noexcept
 
template<typename T >
constexpr int floor_resid (const T x, const T x_whole) noexcept
 
template<typename T >
constexpr T floor_int (const T x, const T x_whole) noexcept
 
template<typename T >
constexpr T floor_check_internal (const T x) noexcept
 
template<>
constexpr float floor_check_internal< float > (const float x) noexcept
 
template<>
constexpr double floor_check_internal< double > (const double x) noexcept
 
template<>
constexpr long double floor_check_internal< long double > (const long double x) noexcept
 
template<typename T >
constexpr T floor_check (const T x) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_inp_vals (const T lb, const T ub, const int counter) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_weight_vals (const T lb, const T ub, const int counter) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_fn (const T x, const T a, const T lg_term) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_recur (const T lb, const T ub, const T a, const T lg_term, const int counter) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_lb (const T a, const T z) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad_ub (const T a, const T z) noexcept
 
template<typename T >
constexpr T incomplete_gamma_quad (const T a, const T z) noexcept
 
template<typename T >
constexpr T incomplete_gamma_cf_2_recur (const T a, const T z, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_gamma_cf_2 (const T a, const T z) noexcept
 
template<typename T >
constexpr T incomplete_gamma_cf_1_coef (const T a, const T z, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_gamma_cf_1_recur (const T a, const T z, const int depth) noexcept
 
template<typename T >
constexpr T incomplete_gamma_cf_1 (const T a, const T z) noexcept
 
template<typename T >
constexpr T incomplete_gamma_check (const T a, const T z) noexcept
 
template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC incomplete_gamma_type_check (const T1 a, const T2 p) noexcept
 

Function Documentation

◆ acos_check()

template<typename T >
constexpr T gcem::internal::acos_check ( const T  x)
constexprnoexcept

◆ acos_compute()

template<typename T >
constexpr T gcem::internal::acos_compute ( const T  x)
constexprnoexcept

◆ acosh_compute()

template<typename T >
constexpr T gcem::internal::acosh_compute ( const T  x)
constexprnoexcept

◆ all_finite() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::all_finite ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ all_finite() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::all_finite ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ all_inf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::all_inf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ all_inf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::all_inf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ all_nan() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::all_nan ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ all_nan() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::all_nan ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ all_neginf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::all_neginf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ all_neginf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::all_neginf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ all_posinf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::all_posinf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ all_posinf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::all_posinf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ any_finite() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::any_finite ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ any_finite() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::any_finite ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ any_inf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::any_inf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ any_inf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::any_inf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ any_nan() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::any_nan ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ any_nan() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::any_nan ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ any_neginf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::any_neginf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ any_neginf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::any_neginf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ any_posinf() [1/2]

template<typename T1 , typename T2 >
constexpr bool gcem::internal::any_posinf ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ any_posinf() [2/2]

template<typename T1 , typename T2 , typename T3 >
constexpr bool gcem::internal::any_posinf ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ asin_check()

template<typename T >
constexpr T gcem::internal::asin_check ( const T  x)
constexprnoexcept

◆ asin_compute()

template<typename T >
constexpr T gcem::internal::asin_compute ( const T  x)
constexprnoexcept

◆ asinh_compute()

template<typename T >
constexpr T gcem::internal::asinh_compute ( const T  x)
constexprnoexcept

◆ atan2_compute()

template<typename T >
constexpr T gcem::internal::atan2_compute ( const T  y,
const T  x 
)
constexprnoexcept

◆ atan2_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::atan2_type_check ( const T1  y,
const T2  x 
)
constexprnoexcept

◆ atan_begin()

template<typename T >
constexpr T gcem::internal::atan_begin ( const T  x)
constexprnoexcept

◆ atan_cf_main()

template<typename T >
constexpr T gcem::internal::atan_cf_main ( const T  x)
constexprnoexcept

◆ atan_cf_recur()

template<typename T >
constexpr T gcem::internal::atan_cf_recur ( const T  xx,
const uint_t  depth,
const uint_t  max_depth 
)
constexprnoexcept

◆ atan_check()

template<typename T >
constexpr T gcem::internal::atan_check ( const T  x)
constexprnoexcept

◆ atan_series_main()

template<typename T >
constexpr T gcem::internal::atan_series_main ( const T  x)
constexprnoexcept

◆ atan_series_order()

template<typename T >
constexpr T gcem::internal::atan_series_order ( const T  x,
const T  x_pow,
const uint_t  order,
const uint_t  max_order 
)
constexprnoexcept

◆ atan_series_order_calc()

template<typename T >
constexpr T gcem::internal::atan_series_order_calc ( const T  x,
const T  x_pow,
const uint_t  order 
)
constexprnoexcept

◆ atanh_check()

template<typename T >
constexpr T gcem::internal::atanh_check ( const T  x)
constexprnoexcept

◆ atanh_compute()

template<typename T >
constexpr T gcem::internal::atanh_compute ( const T  x)
constexprnoexcept

◆ binomial_coef_check()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T gcem::internal::binomial_coef_check ( const T  n,
const T  k 
)
constexprnoexcept

◆ binomial_coef_recur()

template<typename T >
constexpr T gcem::internal::binomial_coef_recur ( const T  n,
const T  k 
)
constexprnoexcept

◆ binomial_coef_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC gcem::internal::binomial_coef_type_check ( const T1  n,
const T2  k 
)
constexprnoexcept

◆ ceil_check()

template<typename T >
constexpr T gcem::internal::ceil_check ( const T  x)
constexprnoexcept

◆ ceil_check_internal()

template<typename T >
constexpr T gcem::internal::ceil_check_internal ( const T  x)
constexprnoexcept

◆ ceil_check_internal< double >()

template<>
constexpr double gcem::internal::ceil_check_internal< double > ( const double  x)
constexprnoexcept

◆ ceil_check_internal< float >()

template<>
constexpr float gcem::internal::ceil_check_internal< float > ( const float  x)
constexprnoexcept

◆ ceil_check_internal< long double >()

template<>
constexpr long double gcem::internal::ceil_check_internal< long double > ( const long double  x)
constexprnoexcept

◆ ceil_int()

template<typename T >
constexpr T gcem::internal::ceil_int ( const T  x,
const T  x_whole 
)
constexprnoexcept

◆ ceil_resid()

template<typename T >
constexpr int gcem::internal::ceil_resid ( const T  x,
const T  x_whole 
)
constexprnoexcept

◆ cos_check()

template<typename T >
constexpr T gcem::internal::cos_check ( const T  x)
constexprnoexcept

◆ cos_compute()

template<typename T >
constexpr T gcem::internal::cos_compute ( const T  x)
constexprnoexcept

◆ cosh_compute()

template<typename T >
constexpr T gcem::internal::cosh_compute ( const T  x)
constexprnoexcept

◆ erf_begin()

template<typename T >
constexpr T gcem::internal::erf_begin ( const T  x)
constexprnoexcept

◆ erf_cf_large_main()

template<typename T >
constexpr T gcem::internal::erf_cf_large_main ( const T  x)
constexprnoexcept

◆ erf_cf_large_recur()

template<typename T >
constexpr T gcem::internal::erf_cf_large_recur ( const T  x,
const int  depth 
)
constexprnoexcept

◆ erf_cf_small_main()

template<typename T >
constexpr T gcem::internal::erf_cf_small_main ( const T  x)
constexprnoexcept

◆ erf_cf_small_recur()

template<typename T >
constexpr T gcem::internal::erf_cf_small_recur ( const T  xx,
const int  depth 
)
constexprnoexcept

◆ erf_check()

template<typename T >
constexpr T gcem::internal::erf_check ( const T  x)
constexprnoexcept

◆ erf_inv_begin()

template<typename T >
constexpr T gcem::internal::erf_inv_begin ( const T  p)
constexprnoexcept

◆ erf_inv_decision()

template<typename T >
constexpr T gcem::internal::erf_inv_decision ( const T  value,
const T  p,
const T  direc,
const int  iter_count 
)
constexprnoexcept

◆ erf_inv_deriv_1()

template<typename T >
constexpr T gcem::internal::erf_inv_deriv_1 ( const T  value)
constexprnoexcept

◆ erf_inv_deriv_2()

template<typename T >
constexpr T gcem::internal::erf_inv_deriv_2 ( const T  value,
const T  deriv_1 
)
constexprnoexcept

◆ erf_inv_err_val()

template<typename T >
constexpr T gcem::internal::erf_inv_err_val ( const T  value,
const T  p 
)
constexprnoexcept

◆ erf_inv_halley()

template<typename T >
constexpr T gcem::internal::erf_inv_halley ( const T  ratio_val_1,
const T  ratio_val_2 
)
constexprnoexcept

◆ erf_inv_initial_val()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val ( const T  x)
constexprnoexcept

◆ erf_inv_initial_val_case_1()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val_case_1 ( const T  a,
const T  p_term,
const int  order 
)
constexprnoexcept

◆ erf_inv_initial_val_case_2()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val_case_2 ( const T  a,
const T  p_term,
const int  order 
)
constexprnoexcept

◆ erf_inv_initial_val_coef_1()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val_coef_1 ( const T  a,
const T  p_term,
const int  order 
)
constexprnoexcept

◆ erf_inv_initial_val_coef_2()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val_coef_2 ( const T  a,
const T  p_term,
const int  order 
)
constexprnoexcept

◆ erf_inv_initial_val_int()

template<typename T >
constexpr T gcem::internal::erf_inv_initial_val_int ( const T  a)
constexprnoexcept

◆ erf_inv_ratio_val_1()

template<typename T >
constexpr T gcem::internal::erf_inv_ratio_val_1 ( const T  value,
const T  p,
const T  deriv_1 
)
constexprnoexcept

◆ erf_inv_ratio_val_2()

template<typename T >
constexpr T gcem::internal::erf_inv_ratio_val_2 ( const T  value,
const T  deriv_1 
)
constexprnoexcept

◆ erf_inv_recur()

template<typename T >
constexpr T gcem::internal::erf_inv_recur ( const T  value,
const T  p,
const T  deriv_1,
const int  iter_count 
)
constexprnoexcept

◆ erf_inv_recur_begin()

template<typename T >
constexpr T gcem::internal::erf_inv_recur_begin ( const T  initial_val,
const T  p 
)
constexprnoexcept

◆ exp_cf()

template<typename T >
constexpr T gcem::internal::exp_cf ( const T  x)
constexprnoexcept

◆ exp_cf_recur()

template<typename T >
constexpr T gcem::internal::exp_cf_recur ( const T  x,
const int  depth 
)
constexprnoexcept

◆ exp_check()

template<typename T >
constexpr T gcem::internal::exp_check ( const T  x)
constexprnoexcept

◆ exp_split()

template<typename T >
constexpr T gcem::internal::exp_split ( const T  x)
constexprnoexcept

◆ expm1_check()

template<typename T >
constexpr T gcem::internal::expm1_check ( const T  x)
constexprnoexcept

◆ expm1_compute()

template<typename T >
constexpr T gcem::internal::expm1_compute ( const T  x)
constexprnoexcept

◆ factorial_recur()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T gcem::internal::factorial_recur ( const T  x)
constexprnoexcept

◆ factorial_table()

template<typename T >
constexpr T gcem::internal::factorial_table ( const T  x)
constexprnoexcept

◆ find_exponent()

template<typename T >
constexpr llint_t gcem::internal::find_exponent ( const T  x,
const llint_t  exponent 
)
constexprnoexcept

◆ find_fraction()

template<typename T >
constexpr T gcem::internal::find_fraction ( const T  x)
constexprnoexcept

◆ find_whole()

template<typename T >
constexpr llint_t gcem::internal::find_whole ( const T  x)
constexprnoexcept

◆ floor_check()

template<typename T >
constexpr T gcem::internal::floor_check ( const T  x)
constexprnoexcept

◆ floor_check_internal()

template<typename T >
constexpr T gcem::internal::floor_check_internal ( const T  x)
constexprnoexcept

◆ floor_check_internal< double >()

template<>
constexpr double gcem::internal::floor_check_internal< double > ( const double  x)
constexprnoexcept

◆ floor_check_internal< float >()

template<>
constexpr float gcem::internal::floor_check_internal< float > ( const float  x)
constexprnoexcept

◆ floor_check_internal< long double >()

template<>
constexpr long double gcem::internal::floor_check_internal< long double > ( const long double  x)
constexprnoexcept

◆ floor_int()

template<typename T >
constexpr T gcem::internal::floor_int ( const T  x,
const T  x_whole 
)
constexprnoexcept

◆ floor_resid()

template<typename T >
constexpr int gcem::internal::floor_resid ( const T  x,
const T  x_whole 
)
constexprnoexcept

◆ fmod_check()

template<typename T >
constexpr T gcem::internal::fmod_check ( const T  x,
const T  y 
)
constexprnoexcept

◆ fmod_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::fmod_type_check ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ gcd_int_check()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
constexpr T gcem::internal::gcd_int_check ( const T  a,
const T  b 
)
constexprnoexcept

◆ gcd_recur()

template<typename T >
constexpr T gcem::internal::gcd_recur ( const T  a,
const T  b 
)
constexprnoexcept

◆ gcd_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC gcem::internal::gcd_type_check ( const T1  a,
const T2  b 
)
constexprnoexcept

◆ hypot_compute() [1/2]

template<typename T >
constexpr T gcem::internal::hypot_compute ( const T  x,
const T  y 
)
constexprnoexcept

◆ hypot_compute() [2/2]

template<typename T >
constexpr T gcem::internal::hypot_compute ( const T  x,
const T  y,
const T  z 
)
constexprnoexcept

◆ hypot_type_check() [1/2]

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::hypot_type_check ( const T1  x,
const T2  y 
)
constexprnoexcept

◆ hypot_type_check() [2/2]

template<typename T1 , typename T2 , typename T3 , typename TC = common_return_t<T1,T2,T3>>
constexpr TC gcem::internal::hypot_type_check ( const T1  x,
const T2  y,
const T3  z 
)
constexprnoexcept

◆ hypot_vals_check() [1/2]

template<typename T >
constexpr T gcem::internal::hypot_vals_check ( const T  x,
const T  y 
)
constexprnoexcept

◆ hypot_vals_check() [2/2]

template<typename T >
constexpr T gcem::internal::hypot_vals_check ( const T  x,
const T  y,
const T  z 
)
constexprnoexcept

◆ incomplete_beta_begin()

template<typename T >
constexpr T gcem::internal::incomplete_beta_begin ( const T  a,
const T  b,
const T  z 
)
constexprnoexcept

◆ incomplete_beta_c_update()

template<typename T >
constexpr T gcem::internal::incomplete_beta_c_update ( const T  a,
const T  b,
const T  z,
const T  c_j,
const int  depth 
)
constexprnoexcept

◆ incomplete_beta_cf()

template<typename T >
constexpr T gcem::internal::incomplete_beta_cf ( const T  a,
const T  b,
const T  z,
const T  c_j,
const T  d_j,
const T  f_j,
const int  depth 
)
constexprnoexcept

◆ incomplete_beta_check()

template<typename T >
constexpr T gcem::internal::incomplete_beta_check ( const T  a,
const T  b,
const T  z 
)
constexprnoexcept

◆ incomplete_beta_coef()

template<typename T >
constexpr T gcem::internal::incomplete_beta_coef ( const T  a,
const T  b,
const T  z,
const int  depth 
)
constexprnoexcept

◆ incomplete_beta_coef_even()

template<typename T >
constexpr T gcem::internal::incomplete_beta_coef_even ( const T  a,
const T  b,
const T  z,
const int  k 
)
constexprnoexcept

◆ incomplete_beta_coef_odd()

template<typename T >
constexpr T gcem::internal::incomplete_beta_coef_odd ( const T  a,
const T  b,
const T  z,
const int  k 
)
constexprnoexcept

◆ incomplete_beta_d_update()

template<typename T >
constexpr T gcem::internal::incomplete_beta_d_update ( const T  a,
const T  b,
const T  z,
const T  d_j,
const int  depth 
)
constexprnoexcept

◆ incomplete_beta_decision()

template<typename T >
constexpr T gcem::internal::incomplete_beta_decision ( const T  a,
const T  b,
const T  z,
const T  c_j,
const T  d_j,
const T  f_j,
const int  depth 
)
constexprnoexcept

◆ incomplete_beta_inv_begin()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_begin ( const T  initial_val,
const T  alpha_par,
const T  beta_par,
const T  p,
const T  lb_val 
)
constexprnoexcept

◆ incomplete_beta_inv_check()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_check ( const T  alpha_par,
const T  beta_par,
const T  p 
)
constexprnoexcept

◆ incomplete_beta_inv_decision()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_decision ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  p,
const T  direc,
const T  lb_val,
const int  iter_count 
)
constexprnoexcept

◆ incomplete_beta_inv_deriv_1()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_deriv_1 ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  lb_val 
)
constexprnoexcept

◆ incomplete_beta_inv_deriv_2()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_deriv_2 ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_beta_inv_err_val()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_err_val ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  p 
)
constexprnoexcept

◆ incomplete_beta_inv_halley()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_halley ( const T  ratio_val_1,
const T  ratio_val_2 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val ( const T  alpha_par,
const T  beta_par,
const T  p 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1 ( const T  alpha_par,
const T  beta_par,
const T  t_val,
const T  sgn_term 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_ab1()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_ab1 ( const T  alpha_par,
const T  beta_par 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_ab2()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_ab2 ( const T  alpha_par,
const T  beta_par 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_begin()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_begin ( const T  t_val)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_end()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_end ( const T  alpha_par,
const T  beta_par,
const T  w_term 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_h()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_h ( const T  ab_term_1)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_w()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_int_w ( const T  value,
const T  ab_term_2,
const T  h_term 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_tval()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_1_tval ( const T  p)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_2()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_2 ( const T  alpha_par,
const T  beta_par,
const T  p,
const T  s_1,
const T  s_2 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_2_s1()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_2_s1 ( const T  alpha_par,
const T  beta_par 
)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_2_s2()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_initial_val_2_s2 ( const T  alpha_par,
const T  beta_par 
)
constexprnoexcept

◆ incomplete_beta_inv_ratio_val_1()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_ratio_val_1 ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  p,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_beta_inv_ratio_val_2()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_ratio_val_2 ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_beta_inv_recur()

template<typename T >
constexpr T gcem::internal::incomplete_beta_inv_recur ( const T  value,
const T  alpha_par,
const T  beta_par,
const T  p,
const T  deriv_1,
const T  lb_val,
const int  iter_count 
)
constexprnoexcept

◆ incomplete_beta_inv_type_check()

template<typename T1 , typename T2 , typename T3 , typename TC = common_t<T1,T2,T3>>
constexpr TC gcem::internal::incomplete_beta_inv_type_check ( const T1  a,
const T2  b,
const T3  p 
)
constexprnoexcept

◆ incomplete_beta_type_check()

template<typename T1 , typename T2 , typename T3 , typename TC = common_return_t<T1,T2,T3>>
constexpr TC gcem::internal::incomplete_beta_type_check ( const T1  a,
const T2  b,
const T3  p 
)
constexprnoexcept

◆ incomplete_gamma_cf_1()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_cf_1 ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_cf_1_coef()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_cf_1_coef ( const T  a,
const T  z,
const int  depth 
)
constexprnoexcept

◆ incomplete_gamma_cf_1_recur()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_cf_1_recur ( const T  a,
const T  z,
const int  depth 
)
constexprnoexcept

◆ incomplete_gamma_cf_2()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_cf_2 ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_cf_2_recur()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_cf_2_recur ( const T  a,
const T  z,
const int  depth 
)
constexprnoexcept

◆ incomplete_gamma_check()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_check ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_inv_begin()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_begin ( const T  initial_val,
const T  a,
const T  p,
const T  lg_val 
)
constexprnoexcept

◆ incomplete_gamma_inv_check()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_check ( const T  a,
const T  p 
)
constexprnoexcept

◆ incomplete_gamma_inv_decision()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_decision ( const T  value,
const T  a,
const T  p,
const T  direc,
const T  lg_val,
const int  iter_count 
)
constexprnoexcept

◆ incomplete_gamma_inv_deriv_1()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_deriv_1 ( const T  value,
const T  a,
const T  lg_val 
)
constexprnoexcept

◆ incomplete_gamma_inv_deriv_2()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_deriv_2 ( const T  value,
const T  a,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_gamma_inv_err_val()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_err_val ( const T  value,
const T  a,
const T  p 
)
constexprnoexcept

◆ incomplete_gamma_inv_halley()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_halley ( const T  ratio_val_1,
const T  ratio_val_2 
)
constexprnoexcept

◆ incomplete_gamma_inv_initial_val()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_initial_val ( const T  a,
const T  p 
)
constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_initial_val_1 ( const T  a,
const T  t_val,
const T  sgn_term 
)
constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1_int_begin()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_initial_val_1_int_begin ( const T  t_val)
constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1_int_end()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_initial_val_1_int_end ( const T  value_inp,
const T  a 
)
constexprnoexcept

◆ incomplete_gamma_inv_initial_val_2()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_initial_val_2 ( const T  a,
const T  p,
const T  t_val 
)
constexprnoexcept

◆ incomplete_gamma_inv_ratio_val_1()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_ratio_val_1 ( const T  value,
const T  a,
const T  p,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_gamma_inv_ratio_val_2()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_ratio_val_2 ( const T  value,
const T  a,
const T  deriv_1 
)
constexprnoexcept

◆ incomplete_gamma_inv_recur()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_recur ( const T  value,
const T  a,
const T  p,
const T  deriv_1,
const T  lg_val,
const int  iter_count 
)
constexprnoexcept

◆ incomplete_gamma_inv_t_val_1()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_t_val_1 ( const T  p)
constexprnoexcept

◆ incomplete_gamma_inv_t_val_2()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_inv_t_val_2 ( const T  a)
constexprnoexcept

◆ incomplete_gamma_inv_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::incomplete_gamma_inv_type_check ( const T1  a,
const T2  p 
)
constexprnoexcept

◆ incomplete_gamma_quad()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_quad_fn()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_fn ( const T  x,
const T  a,
const T  lg_term 
)
constexprnoexcept

◆ incomplete_gamma_quad_inp_vals()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_inp_vals ( const T  lb,
const T  ub,
const int  counter 
)
constexprnoexcept

◆ incomplete_gamma_quad_lb()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_lb ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_quad_recur()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_recur ( const T  lb,
const T  ub,
const T  a,
const T  lg_term,
const int  counter 
)
constexprnoexcept

◆ incomplete_gamma_quad_ub()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_ub ( const T  a,
const T  z 
)
constexprnoexcept

◆ incomplete_gamma_quad_weight_vals()

template<typename T >
constexpr T gcem::internal::incomplete_gamma_quad_weight_vals ( const T  lb,
const T  ub,
const int  counter 
)
constexprnoexcept

◆ incomplete_gamma_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::incomplete_gamma_type_check ( const T1  a,
const T2  p 
)
constexprnoexcept

◆ inv_sqrt_check()

template<typename T >
constexpr T gcem::internal::inv_sqrt_check ( const T  x)
constexprnoexcept

◆ inv_sqrt_recur()

template<typename T >
constexpr T gcem::internal::inv_sqrt_recur ( const T  x,
const T  xn,
const int  count 
)
constexprnoexcept

◆ is_even()

constexpr bool gcem::internal::is_even ( const llint_t  x)
constexprnoexcept

◆ is_finite()

template<typename T >
constexpr bool gcem::internal::is_finite ( const T  x)
constexprnoexcept

◆ is_inf()

template<typename T >
constexpr bool gcem::internal::is_inf ( const T  x)
constexprnoexcept

◆ is_nan()

template<typename T >
constexpr bool gcem::internal::is_nan ( const T  x)
constexprnoexcept

◆ is_neginf()

template<typename T >
constexpr bool gcem::internal::is_neginf ( const T  x)
constexprnoexcept

◆ is_odd()

constexpr bool gcem::internal::is_odd ( const llint_t  x)
constexprnoexcept

◆ is_posinf()

template<typename T >
constexpr bool gcem::internal::is_posinf ( const T  x)
constexprnoexcept

◆ lcm_compute()

template<typename T >
constexpr T gcem::internal::lcm_compute ( const T  a,
const T  b 
)
constexprnoexcept

◆ lcm_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>
constexpr TC gcem::internal::lcm_type_check ( const T1  a,
const T2  b 
)
constexprnoexcept

◆ lgamma_begin()

template<typename T >
constexpr T gcem::internal::lgamma_begin ( const T  x)
constexprnoexcept

◆ lgamma_check()

template<typename T >
constexpr T gcem::internal::lgamma_check ( const T  x)
constexprnoexcept

◆ lgamma_coef_term()

constexpr long double gcem::internal::lgamma_coef_term ( const long double  x)
constexprnoexcept

◆ lgamma_term_1()

template<typename T >
constexpr T gcem::internal::lgamma_term_1 ( const T  x)
constexprnoexcept

◆ lgamma_term_2()

template<typename T >
constexpr T gcem::internal::lgamma_term_2 ( const T  x)
constexprnoexcept

◆ lmgamma_recur()

template<typename T1 , typename T2 >
constexpr T1 gcem::internal::lmgamma_recur ( const T1  a,
const T2  p 
)
constexprnoexcept

◆ log10_check()

template<typename T >
constexpr return_t< T > gcem::internal::log10_check ( const T  x)
constexprnoexcept

◆ log1p_check()

template<typename T >
constexpr T gcem::internal::log1p_check ( const T  x)
constexprnoexcept

◆ log1p_compute()

template<typename T >
constexpr T gcem::internal::log1p_compute ( const T  x)
constexprnoexcept

◆ log2_check()

template<typename T >
constexpr return_t< T > gcem::internal::log2_check ( const T  x)
constexprnoexcept

◆ log_binomial_coef_compute()

template<typename T >
constexpr T gcem::internal::log_binomial_coef_compute ( const T  n,
const T  k 
)
constexprnoexcept

◆ log_binomial_coef_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC gcem::internal::log_binomial_coef_type_check ( const T1  n,
const T2  k 
)
constexprnoexcept

◆ log_breakup()

template<typename T >
constexpr T gcem::internal::log_breakup ( const T  x)
constexprnoexcept

◆ log_cf_begin()

template<typename T >
constexpr T gcem::internal::log_cf_begin ( const T  x)
constexprnoexcept

◆ log_cf_main()

template<typename T >
constexpr T gcem::internal::log_cf_main ( const T  xx,
const int  depth 
)
constexprnoexcept

◆ log_check()

template<typename T >
constexpr T gcem::internal::log_check ( const T  x)
constexprnoexcept

◆ log_integral_check()

template<typename T >
constexpr return_t< T > gcem::internal::log_integral_check ( const T  x)
constexprnoexcept

◆ log_main()

template<typename T >
constexpr T gcem::internal::log_main ( const T  x)
constexprnoexcept

◆ log_mantissa()

template<typename T >
constexpr T gcem::internal::log_mantissa ( const T  x)
constexprnoexcept

◆ log_mantissa_integer()

constexpr long double gcem::internal::log_mantissa_integer ( const int  x)
constexprnoexcept

◆ mantissa()

template<typename T >
constexpr T gcem::internal::mantissa ( const T  x)
constexprnoexcept

◆ neg_zero()

template<typename T >
constexpr bool gcem::internal::neg_zero ( const T  x)
constexprnoexcept

◆ pow_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>, typename std::enable_if<!std::is_integral< T2 >::value >::type * = nullptr>
constexpr TC gcem::internal::pow_check ( const T1  base,
const T2  exp_term 
)
constexprnoexcept

◆ pow_dbl()

template<typename T >
constexpr T gcem::internal::pow_dbl ( const T  base,
const T  exp_term 
)
constexprnoexcept

◆ pow_integral()

template<typename T1 , typename T2 >
constexpr T1 gcem::internal::pow_integral ( const T1  base,
const T2  exp_term 
)
constexprnoexcept

◆ pow_integral_compute()

template<typename T1 , typename T2 >
constexpr T1 gcem::internal::pow_integral_compute ( const T1  base,
const T2  exp_term 
)
constexprnoexcept

◆ pow_integral_compute_recur()

template<typename T1 , typename T2 >
constexpr T1 gcem::internal::pow_integral_compute_recur ( const T1  base,
const T1  val,
const T2  exp_term 
)
constexprnoexcept

◆ pow_integral_sgn_check()

template<typename T1 , typename T2 , typename std::enable_if< std::is_signed< T2 >::value >::type * = nullptr>
constexpr T1 gcem::internal::pow_integral_sgn_check ( const T1  base,
const T2  exp_term 
)
constexprnoexcept

◆ pow_integral_type_check()

template<typename T1 , typename T2 , typename std::enable_if< std::is_integral< T2 >::value >::type * = nullptr>
constexpr T1 gcem::internal::pow_integral_type_check ( const T1  base,
const T2  exp_term 
)
constexprnoexcept

◆ round_check()

template<typename T >
constexpr T gcem::internal::round_check ( const T  x)
constexprnoexcept

◆ round_check_internal()

template<typename T >
constexpr T gcem::internal::round_check_internal ( const T  x)
constexprnoexcept

◆ round_check_internal< double >()

template<>
constexpr double gcem::internal::round_check_internal< double > ( const double  x)
constexprnoexcept

◆ round_check_internal< float >()

template<>
constexpr float gcem::internal::round_check_internal< float > ( const float  x)
constexprnoexcept

◆ round_check_internal< long double >()

template<>
constexpr long double gcem::internal::round_check_internal< long double > ( const long double  x)
constexprnoexcept

◆ round_int()

template<typename T >
constexpr T gcem::internal::round_int ( const T  x)
constexprnoexcept

◆ sin_check()

template<typename T >
constexpr T gcem::internal::sin_check ( const T  x)
constexprnoexcept

◆ sin_compute()

template<typename T >
constexpr T gcem::internal::sin_compute ( const T  x)
constexprnoexcept

◆ sinh_check()

template<typename T >
constexpr T gcem::internal::sinh_check ( const T  x)
constexprnoexcept

◆ sqrt_check()

template<typename T >
constexpr T gcem::internal::sqrt_check ( const T  x)
constexprnoexcept

◆ sqrt_recur()

template<typename T >
constexpr T gcem::internal::sqrt_recur ( const T  x,
const T  xn,
const int  count 
)
constexprnoexcept

◆ sqrt_simplify()

template<typename T >
constexpr T gcem::internal::sqrt_simplify ( const T  x,
const T  m_val 
)
constexprnoexcept

◆ tan_begin()

template<typename T >
constexpr T gcem::internal::tan_begin ( const T  x,
const int  count = 0 
)
constexprnoexcept

◆ tan_cf_main()

template<typename T >
constexpr T gcem::internal::tan_cf_main ( const T  x)
constexprnoexcept

◆ tan_cf_recur()

template<typename T >
constexpr T gcem::internal::tan_cf_recur ( const T  xx,
const int  depth,
const int  max_depth 
)
constexprnoexcept

◆ tan_check()

template<typename T >
constexpr T gcem::internal::tan_check ( const T  x)
constexprnoexcept

◆ tan_series_exp()

template<typename T >
constexpr T gcem::internal::tan_series_exp ( const T  x)
constexprnoexcept

◆ tan_series_exp_long()

template<typename T >
constexpr T gcem::internal::tan_series_exp_long ( const T  z)
constexprnoexcept

◆ tanh_begin()

template<typename T >
constexpr T gcem::internal::tanh_begin ( const T  x)
constexprnoexcept

◆ tanh_cf()

template<typename T >
constexpr T gcem::internal::tanh_cf ( const T  xx,
const int  depth 
)
constexprnoexcept

◆ tanh_check()

template<typename T >
constexpr T gcem::internal::tanh_check ( const T  x)
constexprnoexcept

◆ tgamma_check()

template<typename T >
constexpr T gcem::internal::tgamma_check ( const T  x)
constexprnoexcept

◆ trunc_check()

template<typename T >
constexpr T gcem::internal::trunc_check ( const T  x)
constexprnoexcept

◆ trunc_check_internal()

template<typename T >
constexpr T gcem::internal::trunc_check_internal ( const T  x)
constexprnoexcept

◆ trunc_check_internal< double >()

template<>
constexpr double gcem::internal::trunc_check_internal< double > ( const double  x)
constexprnoexcept

◆ trunc_check_internal< float >()

template<>
constexpr float gcem::internal::trunc_check_internal< float > ( const float  x)
constexprnoexcept

◆ trunc_check_internal< long double >()

template<>
constexpr long double gcem::internal::trunc_check_internal< long double > ( const long double  x)
constexprnoexcept

◆ trunc_int()

template<typename T >
constexpr T gcem::internal::trunc_int ( const T  x)
constexprnoexcept