WPILibC++ 2025.2.1
Loading...
Searching...
No Matches
gcem::internal Namespace Reference

Functions

constexpr bool is_odd (const llint_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 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 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
 
constexpr bool is_even (const llint_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 T >
constexpr T find_fraction (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 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_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
 
template<typename T >
constexpr T tgamma_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 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 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 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
 
template<typename T >
constexpr llint_t find_whole (const T x) noexcept
 
template<typename T >
constexpr T acosh_compute (const T 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 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
 
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 cosh_compute (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 cos_compute (const T x) noexcept
 
template<typename T >
constexpr T cos_check (const T x) 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 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 T atan_series_order_calc (const T xx, 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 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 T1 , typename T2 >
constexpr T1 lmgamma_recur (const T1 a, const T2 p) 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 mantissa (const T x) noexcept
 
template<typename T >
constexpr return_t< T > log10_check (const T x) noexcept
 
template<typename T >
constexpr T sinh_check (const T x) 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 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 return_t< T > log2_check (const T x) noexcept
 
template<typename T >
constexpr T asinh_compute (const T x) noexcept
 
template<typename T >
constexpr llint_t find_exponent (const T x, const llint_t exponent) 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 bool neg_zero (const 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_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 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 acos_compute (const T x) noexcept
 
template<typename T >
constexpr T acos_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 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 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 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 asin_compute (const T x) noexcept
 
template<typename T >
constexpr T asin_check (const T x) 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 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 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 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 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
 

Function Documentation

◆ acos_check()

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

◆ acos_compute()

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

◆ acosh_compute()

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

◆ all_finite() [1/2]

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

◆ all_finite() [2/2]

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

◆ all_inf() [1/2]

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

◆ all_inf() [2/2]

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

◆ all_nan() [1/2]

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

◆ all_nan() [2/2]

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

◆ all_neginf() [1/2]

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

◆ all_neginf() [2/2]

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

◆ all_posinf() [1/2]

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

◆ all_posinf() [2/2]

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

◆ any_finite() [1/2]

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

◆ any_finite() [2/2]

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

◆ any_inf() [1/2]

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

◆ any_inf() [2/2]

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

◆ any_nan() [1/2]

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

◆ any_nan() [2/2]

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

◆ any_neginf() [1/2]

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

◆ any_neginf() [2/2]

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

◆ any_posinf() [1/2]

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

◆ any_posinf() [2/2]

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

◆ asin_check()

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

◆ asin_compute()

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

◆ asinh_compute()

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

◆ atan2_compute()

template<typename T >
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>>
TC gcem::internal::atan2_type_check ( const T1 y,
const T2 x )
constexprnoexcept

◆ atan_begin()

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

◆ atan_cf_main()

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

◆ atan_cf_recur()

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

◆ atan_check()

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

◆ atan_series_main()

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

◆ atan_series_order()

template<typename T >
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 >
T gcem::internal::atan_series_order_calc ( const T xx,
const T x_pow,
const uint_t order )
constexprnoexcept

◆ atanh_check()

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

◆ atanh_compute()

template<typename T >
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>
T gcem::internal::binomial_coef_check ( const T n,
const T k )
constexprnoexcept

◆ binomial_coef_recur()

template<typename T >
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>>
TC gcem::internal::binomial_coef_type_check ( const T1 n,
const T2 k )
constexprnoexcept

◆ ceil_check()

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

◆ ceil_check_internal()

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

◆ ceil_check_internal< double >()

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

◆ ceil_check_internal< float >()

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

◆ ceil_check_internal< long double >()

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

◆ ceil_int()

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

◆ ceil_resid()

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

◆ cos_check()

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

◆ cos_compute()

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

◆ cosh_compute()

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

◆ erf_begin()

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

◆ erf_cf_large_main()

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

◆ erf_cf_large_recur()

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

◆ erf_cf_small_main()

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

◆ erf_cf_small_recur()

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

◆ erf_check()

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

◆ erf_inv_begin()

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

◆ erf_inv_decision()

template<typename T >
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 >
T gcem::internal::erf_inv_deriv_1 ( const T value)
constexprnoexcept

◆ erf_inv_deriv_2()

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

◆ erf_inv_err_val()

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

◆ erf_inv_halley()

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

◆ erf_inv_initial_val()

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

◆ erf_inv_initial_val_case_1()

template<typename T >
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 >
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 >
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 >
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 >
T gcem::internal::erf_inv_initial_val_int ( const T a)
constexprnoexcept

◆ erf_inv_ratio_val_1()

template<typename T >
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 >
T gcem::internal::erf_inv_ratio_val_2 ( const T value,
const T deriv_1 )
constexprnoexcept

◆ erf_inv_recur()

template<typename T >
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 >
T gcem::internal::erf_inv_recur_begin ( const T initial_val,
const T p )
constexprnoexcept

◆ exp_cf()

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

◆ exp_cf_recur()

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

◆ exp_check()

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

◆ exp_split()

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

◆ expm1_check()

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

◆ expm1_compute()

template<typename T >
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>
T gcem::internal::factorial_recur ( const T x)
constexprnoexcept

◆ factorial_table()

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

◆ find_exponent()

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

◆ find_fraction()

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

◆ find_whole()

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

◆ floor_check()

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

◆ floor_check_internal()

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

◆ floor_check_internal< double >()

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

◆ floor_check_internal< float >()

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

◆ floor_check_internal< long double >()

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

◆ floor_int()

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

◆ floor_resid()

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

◆ fmod_check()

template<typename T >
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>>
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>
T gcem::internal::gcd_int_check ( const T a,
const T b )
constexprnoexcept

◆ gcd_recur()

template<typename T >
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>>
TC gcem::internal::gcd_type_check ( const T1 a,
const T2 b )
constexprnoexcept

◆ hypot_compute() [1/2]

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

◆ hypot_compute() [2/2]

template<typename T >
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>>
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>>
TC gcem::internal::hypot_type_check ( const T1 x,
const T2 y,
const T3 z )
constexprnoexcept

◆ hypot_vals_check() [1/2]

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

◆ hypot_vals_check() [2/2]

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

◆ incomplete_beta_begin()

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

◆ incomplete_beta_c_update()

template<typename T >
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 >
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 >
T gcem::internal::incomplete_beta_check ( const T a,
const T b,
const T z )
constexprnoexcept

◆ incomplete_beta_coef()

template<typename T >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
T gcem::internal::incomplete_beta_inv_initial_val_1_tval ( const T p)
constexprnoexcept

◆ incomplete_beta_inv_initial_val_2()

template<typename T >
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 >
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 >
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 >
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 >
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 >
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>>
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>>
TC gcem::internal::incomplete_beta_type_check ( const T1 a,
const T2 b,
const T3 p )
constexprnoexcept

◆ incomplete_gamma_cf_1()

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

◆ incomplete_gamma_cf_1_coef()

template<typename T >
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 >
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 >
T gcem::internal::incomplete_gamma_cf_2 ( const T a,
const T z )
constexprnoexcept

◆ incomplete_gamma_cf_2_recur()

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

◆ incomplete_gamma_check()

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

◆ incomplete_gamma_inv_begin()

template<typename T >
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 >
T gcem::internal::incomplete_gamma_inv_check ( const T a,
const T p )
constexprnoexcept

◆ incomplete_gamma_inv_decision()

template<typename T >
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 >
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 >
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 >
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 >
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 >
T gcem::internal::incomplete_gamma_inv_initial_val ( const T a,
const T p )
constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1()

template<typename T >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
T gcem::internal::incomplete_gamma_inv_t_val_1 ( const T p)
constexprnoexcept

◆ incomplete_gamma_inv_t_val_2()

template<typename T >
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>>
TC gcem::internal::incomplete_gamma_inv_type_check ( const T1 a,
const T2 p )
constexprnoexcept

◆ incomplete_gamma_quad()

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

◆ incomplete_gamma_quad_fn()

template<typename T >
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 >
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 >
T gcem::internal::incomplete_gamma_quad_lb ( const T a,
const T z )
constexprnoexcept

◆ incomplete_gamma_quad_recur()

template<typename T >
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 >
T gcem::internal::incomplete_gamma_quad_ub ( const T a,
const T z )
constexprnoexcept

◆ incomplete_gamma_quad_weight_vals()

template<typename T >
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>>
TC gcem::internal::incomplete_gamma_type_check ( const T1 a,
const T2 p )
constexprnoexcept

◆ inv_sqrt_check()

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

◆ inv_sqrt_recur()

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

◆ is_even()

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

◆ is_finite()

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

◆ is_inf()

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

◆ is_nan()

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

◆ is_neginf()

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

◆ is_odd()

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

◆ is_posinf()

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

◆ lcm_compute()

template<typename T >
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>>
TC gcem::internal::lcm_type_check ( const T1 a,
const T2 b )
constexprnoexcept

◆ lgamma_begin()

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

◆ lgamma_check()

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

◆ lgamma_coef_term()

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

◆ lgamma_term_1()

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

◆ lgamma_term_2()

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

◆ lmgamma_recur()

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

◆ log10_check()

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

◆ log1p_check()

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

◆ log1p_compute()

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

◆ log2_check()

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

◆ log_binomial_coef_compute()

template<typename T >
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>>
TC gcem::internal::log_binomial_coef_type_check ( const T1 n,
const T2 k )
constexprnoexcept

◆ log_breakup()

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

◆ log_cf_begin()

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

◆ log_cf_main()

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

◆ log_check()

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

◆ log_integral_check()

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

◆ log_main()

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

◆ log_mantissa()

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

◆ log_mantissa_integer()

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

◆ mantissa()

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

◆ neg_zero()

template<typename T >
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>
TC gcem::internal::pow_check ( const T1 base,
const T2 exp_term )
constexprnoexcept

◆ pow_dbl()

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

◆ pow_integral()

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

◆ pow_integral_compute()

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

◆ pow_integral_compute_recur()

template<typename T1 , typename T2 >
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>
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>
T1 gcem::internal::pow_integral_type_check ( const T1 base,
const T2 exp_term )
constexprnoexcept

◆ round_check()

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

◆ round_check_internal()

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

◆ round_check_internal< double >()

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

◆ round_check_internal< float >()

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

◆ round_check_internal< long double >()

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

◆ round_int()

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

◆ sin_check()

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

◆ sin_compute()

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

◆ sinh_check()

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

◆ sqrt_check()

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

◆ sqrt_recur()

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

◆ sqrt_simplify()

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

◆ tan_begin()

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

◆ tan_cf_main()

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

◆ tan_cf_recur()

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

◆ tan_check()

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

◆ tan_series_exp()

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

◆ tan_series_exp_long()

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

◆ tanh_begin()

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

◆ tanh_cf()

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

◆ tanh_check()

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

◆ tgamma_check()

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

◆ trunc_check()

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

◆ trunc_check_internal()

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

◆ trunc_check_internal< double >()

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

◆ trunc_check_internal< float >()

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

◆ trunc_check_internal< long double >()

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

◆ trunc_int()

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