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