Namespaces
namespace	Colamd

Functions
template<typename T >
constexpr int	ceil_resid (const T x, const T x_whole) noexcept

template<typename T >
constexpr T	ceil_int (const T x, const T x_whole) noexcept

template<typename T >
constexpr T	ceil_check_internal (const T x) noexcept

template<>
constexpr float	ceil_check_internal< float > (const float x) noexcept

template<>
constexpr double	ceil_check_internal< double > (const double x) noexcept

template<>
constexpr long double	ceil_check_internal< long double > (const long double x) noexcept

template<typename T >
constexpr T	ceil_check (const T x) noexcept

template<typename T >
constexpr T	sqrt_recur (const T x, const T xn, const int count) noexcept

template<typename T >
constexpr T	sqrt_check (const T x, const T m_val) 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

constexpr bool	is_odd (const llint_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	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 bool	is_finite (const T x) noexcept

template<typename T1 , typename T2 >
constexpr bool	any_finite (const T1 x, const T2 y) noexcept

template<typename T1 , typename T2 >
constexpr bool	all_finite (const T1 x, const T2 y) noexcept

template<typename T1 , typename T2 , typename T3 >
constexpr bool	any_finite (const T1 x, const T2 y, const T3 z) noexcept

template<typename T1 , typename T2 , typename T3 >
constexpr bool	all_finite (const T1 x, const T2 y, const T3 z) noexcept

template<typename T >
constexpr 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	sinh_check (const T x) noexcept

constexpr bool	is_even (const llint_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 T1 , typename T2 >
constexpr T1	lmgamma_recur (const T1 a, const T2 p) 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 bool	neg_zero (const T x) noexcept

template<typename T >
constexpr T	mantissa (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	atanh_compute (const T x) noexcept

template<typename T >
constexpr T	atanh_check (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_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 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 return_t< T >	log2_check (const T x) noexcept

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

template<typename T >
constexpr T	asinh_compute (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

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 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	atan_series_order_calc (const T x, const T x_pow, const uint_t order) noexcept

template<typename T >
constexpr T	atan_series_order (const T x, const T x_pow, const uint_t order, const uint_t max_order) noexcept

template<typename T >
constexpr T	atan_series_main (const T x) noexcept

template<typename T >
constexpr T	atan_cf_recur (const T xx, const uint_t depth, const uint_t max_depth) noexcept

template<typename T >
constexpr T	atan_cf_main (const T x) noexcept

template<typename T >
constexpr T	atan_begin (const T x) noexcept

template<typename T >
constexpr T	atan_check (const T x) noexcept

template<typename T >
constexpr 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	find_fraction (const T x) 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 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	expm1_compute (const T x) noexcept

template<typename T >
constexpr T	expm1_check (const T x) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_decision (const T value, const T a, const T p, const T direc, const T lg_val, const int iter_count) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_t_val_1 (const T p) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_t_val_2 (const T a) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_initial_val_1_int_begin (const T t_val) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_initial_val_1_int_end (const T value_inp, const T a) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_initial_val_1 (const T a, const T t_val, const T sgn_term) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_initial_val_2 (const T a, const T p, const T t_val) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_initial_val (const T a, const T p) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_err_val (const T value, const T a, const T p) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_deriv_1 (const T value, const T a, const T lg_val) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_deriv_2 (const T value, const T a, const T deriv_1) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_ratio_val_1 (const T value, const T a, const T p, const T deriv_1) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_ratio_val_2 (const T value, const T a, const T deriv_1) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_halley (const T ratio_val_1, const T ratio_val_2) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_recur (const T value, const T a, const T p, const T deriv_1, const T lg_val, const int iter_count) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_begin (const T initial_val, const T a, const T p, const T lg_val) noexcept

template<typename T >
constexpr T	incomplete_gamma_inv_check (const T a, const T p) noexcept

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>
constexpr TC	incomplete_gamma_inv_type_check (const T1 a, const T2 p) noexcept

template<typename T >
constexpr T	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 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	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	cos_compute (const T x) noexcept

template<typename T >
constexpr T	cos_check (const T x) noexcept

template<typename T >
constexpr T	acosh_compute (const T x) noexcept

template<typename T >
constexpr T	sin_compute (const T x) noexcept

template<typename T >
constexpr T	sin_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	hypot_compute (const T x, const T ydx) noexcept

template<typename T >
constexpr T	hypot_vals_check (const T x, const T y) 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 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	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 llint_t	find_whole (const T x) noexcept

template<typename T >
constexpr T	tgamma_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	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

template<typename T >
constexpr T	inv_sqrt_recur (const T x, const T xn, const int count) noexcept

template<typename T >
constexpr T	inv_sqrt_check (const T x) noexcept

template<typename T >
constexpr T	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	cosh_compute (const T x) noexcept

template<typename T >
constexpr T	log1p_compute (const T x) noexcept

template<typename T >
constexpr T	log1p_check (const T x) noexcept

template<typename T >
constexpr T	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

Function Documentation

◆ acos_check()

template<typename T >

constexpr T internal::acos_check ( const T x )

constexprnoexcept

◆ acos_compute()

template<typename T >

constexpr T internal::acos_compute ( const T x )

constexprnoexcept

◆ acosh_compute()

template<typename T >

constexpr T internal::acosh_compute ( const T x )

constexprnoexcept

◆ all_finite() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::all_finite	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ all_finite() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::all_finite	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ all_inf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::all_inf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ all_inf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::all_inf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ all_nan() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::all_nan	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ all_nan() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::all_nan	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ all_neginf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::all_neginf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ all_neginf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::all_neginf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ all_posinf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::all_posinf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ all_posinf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::all_posinf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ any_finite() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::any_finite	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ any_finite() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::any_finite	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ any_inf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::any_inf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ any_inf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::any_inf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ any_nan() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::any_nan	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ any_nan() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::any_nan	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ any_neginf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::any_neginf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ any_neginf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::any_neginf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ any_posinf() [1/2]

template<typename T1 , typename T2 >

constexpr bool internal::any_posinf	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ any_posinf() [2/2]

template<typename T1 , typename T2 , typename T3 >

constexpr bool internal::any_posinf	(	const T1	x,
		const T2	y,
		const T3	z
	)

constexprnoexcept

◆ asin_check()

template<typename T >

constexpr T internal::asin_check ( const T x )

constexprnoexcept

◆ asin_compute()

template<typename T >

constexpr T internal::asin_compute ( const T x )

constexprnoexcept

◆ asinh_compute()

template<typename T >

constexpr T internal::asinh_compute ( const T x )

constexprnoexcept

◆ atan2_compute()

template<typename T >

constexpr T internal::atan2_compute	(	const T	y,
		const T	x
	)

constexprnoexcept

◆ atan2_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::atan2_type_check	(	const T1	y,
		const T2	x
	)

constexprnoexcept

◆ atan_begin()

template<typename T >

constexpr T internal::atan_begin ( const T x )

constexprnoexcept

◆ atan_cf_main()

template<typename T >

constexpr T internal::atan_cf_main ( const T x )

constexprnoexcept

◆ atan_cf_recur()

template<typename T >

constexpr T internal::atan_cf_recur	(	const T	xx,
		const uint_t	depth,
		const uint_t	max_depth
	)

constexprnoexcept

◆ atan_check()

template<typename T >

constexpr T internal::atan_check ( const T x )

constexprnoexcept

◆ atan_series_main()

template<typename T >

constexpr T internal::atan_series_main ( const T x )

constexprnoexcept

◆ atan_series_order()

template<typename T >

constexpr T internal::atan_series_order	(	const T	x,
		const T	x_pow,
		const uint_t	order,
		const uint_t	max_order
	)

constexprnoexcept

◆ atan_series_order_calc()

template<typename T >

constexpr T internal::atan_series_order_calc	(	const T	x,
		const T	x_pow,
		const uint_t	order
	)

constexprnoexcept

◆ atanh_check()

template<typename T >

constexpr T internal::atanh_check ( const T x )

constexprnoexcept

◆ atanh_compute()

template<typename T >

constexpr T internal::atanh_compute ( const T x )

constexprnoexcept

◆ binomial_coef_check()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>

constexpr T internal::binomial_coef_check	(	const T	n,
		const T	k
	)

constexprnoexcept

◆ binomial_coef_recur()

template<typename T >

constexpr T internal::binomial_coef_recur	(	const T	n,
		const T	k
	)

constexprnoexcept

◆ binomial_coef_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>

constexpr TC internal::binomial_coef_type_check	(	const T1	n,
		const T2	k
	)

constexprnoexcept

◆ ceil_check()

template<typename T >

constexpr T internal::ceil_check ( const T x )

constexprnoexcept

◆ ceil_check_internal()

template<typename T >

constexpr T internal::ceil_check_internal ( const T x )

constexprnoexcept

◆ ceil_check_internal< double >()

template<>

constexpr double internal::ceil_check_internal< double > ( const double x )

constexprnoexcept

◆ ceil_check_internal< float >()

template<>

constexpr float internal::ceil_check_internal< float > ( const float x )

constexprnoexcept

◆ ceil_check_internal< long double >()

template<>

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

constexprnoexcept

◆ ceil_int()

template<typename T >

constexpr T internal::ceil_int	(	const T	x,
		const T	x_whole
	)

constexprnoexcept

◆ ceil_resid()

template<typename T >

constexpr int internal::ceil_resid	(	const T	x,
		const T	x_whole
	)

constexprnoexcept

◆ cos_check()

template<typename T >

constexpr T internal::cos_check ( const T x )

constexprnoexcept

◆ cos_compute()

template<typename T >

constexpr T internal::cos_compute ( const T x )

constexprnoexcept

◆ cosh_compute()

template<typename T >

constexpr T internal::cosh_compute ( const T x )

constexprnoexcept

◆ erf_begin()

template<typename T >

constexpr T internal::erf_begin ( const T x )

constexprnoexcept

◆ erf_cf_large_main()

template<typename T >

constexpr T internal::erf_cf_large_main ( const T x )

constexprnoexcept

◆ erf_cf_large_recur()

template<typename T >

constexpr T internal::erf_cf_large_recur	(	const T	x,
		const int	depth
	)

constexprnoexcept

◆ erf_cf_small_main()

template<typename T >

constexpr T internal::erf_cf_small_main ( const T x )

constexprnoexcept

◆ erf_cf_small_recur()

template<typename T >

constexpr T internal::erf_cf_small_recur	(	const T	xx,
		const int	depth
	)

constexprnoexcept

◆ erf_check()

template<typename T >

constexpr T internal::erf_check ( const T x )

constexprnoexcept

◆ erf_inv_begin()

template<typename T >

constexpr T internal::erf_inv_begin ( const T p )

constexprnoexcept

◆ erf_inv_decision()

template<typename T >

constexpr T internal::erf_inv_decision	(	const T	value,
		const T	p,
		const T	direc,
		const int	iter_count
	)

constexprnoexcept

◆ erf_inv_deriv_1()

template<typename T >

constexpr T internal::erf_inv_deriv_1 ( const T value )

constexprnoexcept

◆ erf_inv_deriv_2()

template<typename T >

constexpr T internal::erf_inv_deriv_2	(	const T	value,
		const T	deriv_1
	)

constexprnoexcept

◆ erf_inv_err_val()

template<typename T >

constexpr T internal::erf_inv_err_val	(	const T	value,
		const T	p
	)

constexprnoexcept

◆ erf_inv_halley()

template<typename T >

constexpr T internal::erf_inv_halley	(	const T	ratio_val_1,
		const T	ratio_val_2
	)

constexprnoexcept

◆ erf_inv_initial_val()

template<typename T >

constexpr T internal::erf_inv_initial_val ( const T x )

constexprnoexcept

◆ erf_inv_initial_val_case_1()

template<typename T >

constexpr T internal::erf_inv_initial_val_case_1	(	const T	a,
		const T	p_term,
		const int	order
	)

constexprnoexcept

◆ erf_inv_initial_val_case_2()

template<typename T >

constexpr T internal::erf_inv_initial_val_case_2	(	const T	a,
		const T	p_term,
		const int	order
	)

constexprnoexcept

◆ erf_inv_initial_val_coef_1()

template<typename T >

constexpr T internal::erf_inv_initial_val_coef_1	(	const T	a,
		const T	p_term,
		const int	order
	)

constexprnoexcept

◆ erf_inv_initial_val_coef_2()

template<typename T >

constexpr T internal::erf_inv_initial_val_coef_2	(	const T	a,
		const T	p_term,
		const int	order
	)

constexprnoexcept

◆ erf_inv_initial_val_int()

template<typename T >

constexpr T internal::erf_inv_initial_val_int ( const T a )

constexprnoexcept

◆ erf_inv_ratio_val_1()

template<typename T >

constexpr T internal::erf_inv_ratio_val_1	(	const T	value,
		const T	p,
		const T	deriv_1
	)

constexprnoexcept

◆ erf_inv_ratio_val_2()

template<typename T >

constexpr T internal::erf_inv_ratio_val_2	(	const T	value,
		const T	deriv_1
	)

constexprnoexcept

◆ erf_inv_recur()

template<typename T >

constexpr T internal::erf_inv_recur	(	const T	value,
		const T	p,
		const T	deriv_1,
		const int	iter_count
	)

constexprnoexcept

◆ erf_inv_recur_begin()

template<typename T >

constexpr T internal::erf_inv_recur_begin	(	const T	initial_val,
		const T	p
	)

constexprnoexcept

◆ exp_cf()

template<typename T >

constexpr T internal::exp_cf ( const T x )

constexprnoexcept

◆ exp_cf_recur()

template<typename T >

constexpr T internal::exp_cf_recur	(	const T	x,
		const int	depth
	)

constexprnoexcept

◆ exp_check()

template<typename T >

constexpr T internal::exp_check ( const T x )

constexprnoexcept

◆ exp_split()

template<typename T >

constexpr T internal::exp_split ( const T x )

constexprnoexcept

◆ expm1_check()

template<typename T >

constexpr T internal::expm1_check ( const T x )

constexprnoexcept

◆ expm1_compute()

template<typename T >

constexpr T internal::expm1_compute ( const T x )

constexprnoexcept

◆ factorial_recur()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>

constexpr T internal::factorial_recur ( const T x )

constexprnoexcept

◆ factorial_table()

template<typename T >

constexpr T internal::factorial_table ( const T x )

constexprnoexcept

◆ find_exponent()

template<typename T >

constexpr llint_t internal::find_exponent	(	const T	x,
		const llint_t	exponent
	)

constexprnoexcept

◆ find_fraction()

template<typename T >

constexpr T internal::find_fraction ( const T x )

constexprnoexcept

◆ find_whole()

template<typename T >

constexpr llint_t internal::find_whole ( const T x )

constexprnoexcept

◆ floor_check()

template<typename T >

constexpr T internal::floor_check ( const T x )

constexprnoexcept

◆ floor_check_internal()

template<typename T >

constexpr T internal::floor_check_internal ( const T x )

constexprnoexcept

◆ floor_check_internal< double >()

template<>

constexpr double internal::floor_check_internal< double > ( const double x )

constexprnoexcept

◆ floor_check_internal< float >()

template<>

constexpr float internal::floor_check_internal< float > ( const float x )

constexprnoexcept

◆ floor_check_internal< long double >()

template<>

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

constexprnoexcept

◆ floor_int()

template<typename T >

constexpr T internal::floor_int	(	const T	x,
		const T	x_whole
	)

constexprnoexcept

◆ floor_resid()

template<typename T >

constexpr int internal::floor_resid	(	const T	x,
		const T	x_whole
	)

constexprnoexcept

◆ fmod_check()

template<typename T >

constexpr T internal::fmod_check	(	const T	x,
		const T	y
	)

constexprnoexcept

◆ fmod_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::fmod_type_check	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ gcd_int_check()

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>

constexpr T internal::gcd_int_check	(	const T	a,
		const T	b
	)

constexprnoexcept

◆ gcd_recur()

template<typename T >

constexpr T internal::gcd_recur	(	const T	a,
		const T	b
	)

constexprnoexcept

◆ gcd_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>

constexpr TC internal::gcd_type_check	(	const T1	a,
		const T2	b
	)

constexprnoexcept

◆ hypot_compute()

template<typename T >

constexpr T internal::hypot_compute	(	const T	x,
		const T	ydx
	)

constexprnoexcept

◆ hypot_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::hypot_type_check	(	const T1	x,
		const T2	y
	)

constexprnoexcept

◆ hypot_vals_check()

template<typename T >

constexpr T internal::hypot_vals_check	(	const T	x,
		const T	y
	)

constexprnoexcept

◆ incomplete_beta_begin()

template<typename T >

constexpr T internal::incomplete_beta_begin	(	const T	a,
		const T	b,
		const T	z
	)

constexprnoexcept

◆ incomplete_beta_c_update()

template<typename T >

constexpr T internal::incomplete_beta_c_update	(	const T	a,
		const T	b,
		const T	z,
		const T	c_j,
		const int	depth
	)

constexprnoexcept

◆ incomplete_beta_cf()

template<typename T >

constexpr T internal::incomplete_beta_cf	(	const T	a,
		const T	b,
		const T	z,
		const T	c_j,
		const T	d_j,
		const T	f_j,
		const int	depth
	)

constexprnoexcept

◆ incomplete_beta_check()

template<typename T >

constexpr T internal::incomplete_beta_check	(	const T	a,
		const T	b,
		const T	z
	)

constexprnoexcept

◆ incomplete_beta_coef()

template<typename T >

constexpr T internal::incomplete_beta_coef	(	const T	a,
		const T	b,
		const T	z,
		const int	depth
	)

constexprnoexcept

◆ incomplete_beta_coef_even()

template<typename T >

constexpr T internal::incomplete_beta_coef_even	(	const T	a,
		const T	b,
		const T	z,
		const int	k
	)

constexprnoexcept

◆ incomplete_beta_coef_odd()

template<typename T >

constexpr T internal::incomplete_beta_coef_odd	(	const T	a,
		const T	b,
		const T	z,
		const int	k
	)

constexprnoexcept

◆ incomplete_beta_d_update()

template<typename T >

constexpr T internal::incomplete_beta_d_update	(	const T	a,
		const T	b,
		const T	z,
		const T	d_j,
		const int	depth
	)

constexprnoexcept

◆ incomplete_beta_decision()

template<typename T >

constexpr T internal::incomplete_beta_decision	(	const T	a,
		const T	b,
		const T	z,
		const T	c_j,
		const T	d_j,
		const T	f_j,
		const int	depth
	)

constexprnoexcept

◆ incomplete_beta_inv_begin()

template<typename T >

constexpr T internal::incomplete_beta_inv_begin	(	const T	initial_val,
		const T	alpha_par,
		const T	beta_par,
		const T	p,
		const T	lb_val
	)

constexprnoexcept

◆ incomplete_beta_inv_check()

template<typename T >

constexpr T internal::incomplete_beta_inv_check	(	const T	alpha_par,
		const T	beta_par,
		const T	p
	)

constexprnoexcept

◆ incomplete_beta_inv_decision()

template<typename T >

constexpr T internal::incomplete_beta_inv_decision	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	p,
		const T	direc,
		const T	lb_val,
		const int	iter_count
	)

constexprnoexcept

◆ incomplete_beta_inv_deriv_1()

template<typename T >

constexpr T internal::incomplete_beta_inv_deriv_1	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	lb_val
	)

constexprnoexcept

◆ incomplete_beta_inv_deriv_2()

template<typename T >

constexpr T internal::incomplete_beta_inv_deriv_2	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_beta_inv_err_val()

template<typename T >

constexpr T internal::incomplete_beta_inv_err_val	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	p
	)

constexprnoexcept

◆ incomplete_beta_inv_halley()

template<typename T >

constexpr T internal::incomplete_beta_inv_halley	(	const T	ratio_val_1,
		const T	ratio_val_2
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val	(	const T	alpha_par,
		const T	beta_par,
		const T	p
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1	(	const T	alpha_par,
		const T	beta_par,
		const T	t_val,
		const T	sgn_term
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_ab1()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_ab1	(	const T	alpha_par,
		const T	beta_par
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_ab2()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_ab2	(	const T	alpha_par,
		const T	beta_par
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_begin()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_begin ( const T t_val )

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_end()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_end	(	const T	alpha_par,
		const T	beta_par,
		const T	w_term
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_h()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_h ( const T ab_term_1 )

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_int_w()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_int_w	(	const T	value,
		const T	ab_term_2,
		const T	h_term
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_1_tval()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_1_tval ( const T p )

constexprnoexcept

◆ incomplete_beta_inv_initial_val_2()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_2	(	const T	alpha_par,
		const T	beta_par,
		const T	p,
		const T	s_1,
		const T	s_2
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_2_s1()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_2_s1	(	const T	alpha_par,
		const T	beta_par
	)

constexprnoexcept

◆ incomplete_beta_inv_initial_val_2_s2()

template<typename T >

constexpr T internal::incomplete_beta_inv_initial_val_2_s2	(	const T	alpha_par,
		const T	beta_par
	)

constexprnoexcept

◆ incomplete_beta_inv_ratio_val_1()

template<typename T >

constexpr T internal::incomplete_beta_inv_ratio_val_1	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	p,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_beta_inv_ratio_val_2()

template<typename T >

constexpr T internal::incomplete_beta_inv_ratio_val_2	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_beta_inv_recur()

template<typename T >

constexpr T internal::incomplete_beta_inv_recur	(	const T	value,
		const T	alpha_par,
		const T	beta_par,
		const T	p,
		const T	deriv_1,
		const T	lb_val,
		const int	iter_count
	)

constexprnoexcept

◆ incomplete_beta_inv_type_check()

template<typename T1 , typename T2 , typename T3 , typename TC = common_t<T1,T2,T3>>

constexpr TC internal::incomplete_beta_inv_type_check	(	const T1	a,
		const T2	b,
		const T3	p
	)

constexprnoexcept

◆ incomplete_beta_type_check()

template<typename T1 , typename T2 , typename T3 , typename TC = common_return_t<T1,T2,T3>>

constexpr TC internal::incomplete_beta_type_check	(	const T1	a,
		const T2	b,
		const T3	p
	)

constexprnoexcept

◆ incomplete_gamma_cf_1()

template<typename T >

constexpr T internal::incomplete_gamma_cf_1	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_cf_1_coef()

template<typename T >

constexpr T internal::incomplete_gamma_cf_1_coef	(	const T	a,
		const T	z,
		const int	depth
	)

constexprnoexcept

◆ incomplete_gamma_cf_1_recur()

template<typename T >

constexpr T internal::incomplete_gamma_cf_1_recur	(	const T	a,
		const T	z,
		const int	depth
	)

constexprnoexcept

◆ incomplete_gamma_cf_2()

template<typename T >

constexpr T internal::incomplete_gamma_cf_2	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_cf_2_recur()

template<typename T >

constexpr T internal::incomplete_gamma_cf_2_recur	(	const T	a,
		const T	z,
		const int	depth
	)

constexprnoexcept

◆ incomplete_gamma_check()

template<typename T >

constexpr T internal::incomplete_gamma_check	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_inv_begin()

template<typename T >

constexpr T internal::incomplete_gamma_inv_begin	(	const T	initial_val,
		const T	a,
		const T	p,
		const T	lg_val
	)

constexprnoexcept

◆ incomplete_gamma_inv_check()

template<typename T >

constexpr T internal::incomplete_gamma_inv_check	(	const T	a,
		const T	p
	)

constexprnoexcept

◆ incomplete_gamma_inv_decision()

template<typename T >

constexpr T internal::incomplete_gamma_inv_decision	(	const T	value,
		const T	a,
		const T	p,
		const T	direc,
		const T	lg_val,
		const int	iter_count
	)

constexprnoexcept

◆ incomplete_gamma_inv_deriv_1()

template<typename T >

constexpr T internal::incomplete_gamma_inv_deriv_1	(	const T	value,
		const T	a,
		const T	lg_val
	)

constexprnoexcept

◆ incomplete_gamma_inv_deriv_2()

template<typename T >

constexpr T internal::incomplete_gamma_inv_deriv_2	(	const T	value,
		const T	a,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_gamma_inv_err_val()

template<typename T >

constexpr T internal::incomplete_gamma_inv_err_val	(	const T	value,
		const T	a,
		const T	p
	)

constexprnoexcept

◆ incomplete_gamma_inv_halley()

template<typename T >

constexpr T internal::incomplete_gamma_inv_halley	(	const T	ratio_val_1,
		const T	ratio_val_2
	)

constexprnoexcept

◆ incomplete_gamma_inv_initial_val()

template<typename T >

constexpr T internal::incomplete_gamma_inv_initial_val	(	const T	a,
		const T	p
	)

constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1()

template<typename T >

constexpr T internal::incomplete_gamma_inv_initial_val_1	(	const T	a,
		const T	t_val,
		const T	sgn_term
	)

constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1_int_begin()

template<typename T >

constexpr T internal::incomplete_gamma_inv_initial_val_1_int_begin ( const T t_val )

constexprnoexcept

◆ incomplete_gamma_inv_initial_val_1_int_end()

template<typename T >

constexpr T internal::incomplete_gamma_inv_initial_val_1_int_end	(	const T	value_inp,
		const T	a
	)

constexprnoexcept

◆ incomplete_gamma_inv_initial_val_2()

template<typename T >

constexpr T internal::incomplete_gamma_inv_initial_val_2	(	const T	a,
		const T	p,
		const T	t_val
	)

constexprnoexcept

◆ incomplete_gamma_inv_ratio_val_1()

template<typename T >

constexpr T internal::incomplete_gamma_inv_ratio_val_1	(	const T	value,
		const T	a,
		const T	p,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_gamma_inv_ratio_val_2()

template<typename T >

constexpr T internal::incomplete_gamma_inv_ratio_val_2	(	const T	value,
		const T	a,
		const T	deriv_1
	)

constexprnoexcept

◆ incomplete_gamma_inv_recur()

template<typename T >

constexpr T internal::incomplete_gamma_inv_recur	(	const T	value,
		const T	a,
		const T	p,
		const T	deriv_1,
		const T	lg_val,
		const int	iter_count
	)

constexprnoexcept

◆ incomplete_gamma_inv_t_val_1()

template<typename T >

constexpr T internal::incomplete_gamma_inv_t_val_1 ( const T p )

constexprnoexcept

◆ incomplete_gamma_inv_t_val_2()

template<typename T >

constexpr T internal::incomplete_gamma_inv_t_val_2 ( const T a )

constexprnoexcept

◆ incomplete_gamma_inv_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::incomplete_gamma_inv_type_check	(	const T1	a,
		const T2	p
	)

constexprnoexcept

◆ incomplete_gamma_quad()

template<typename T >

constexpr T internal::incomplete_gamma_quad	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_quad_fn()

template<typename T >

constexpr T internal::incomplete_gamma_quad_fn	(	const T	x,
		const T	a,
		const T	lg_term
	)

constexprnoexcept

◆ incomplete_gamma_quad_inp_vals()

template<typename T >

constexpr T internal::incomplete_gamma_quad_inp_vals	(	const T	lb,
		const T	ub,
		const int	counter
	)

constexprnoexcept

◆ incomplete_gamma_quad_lb()

template<typename T >

constexpr T internal::incomplete_gamma_quad_lb	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_quad_recur()

template<typename T >

constexpr T internal::incomplete_gamma_quad_recur	(	const T	lb,
		const T	ub,
		const T	a,
		const T	lg_term,
		const int	counter
	)

constexprnoexcept

◆ incomplete_gamma_quad_ub()

template<typename T >

constexpr T internal::incomplete_gamma_quad_ub	(	const T	a,
		const T	z
	)

constexprnoexcept

◆ incomplete_gamma_quad_weight_vals()

template<typename T >

constexpr T internal::incomplete_gamma_quad_weight_vals	(	const T	lb,
		const T	ub,
		const int	counter
	)

constexprnoexcept

◆ incomplete_gamma_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::incomplete_gamma_type_check	(	const T1	a,
		const T2	p
	)

constexprnoexcept

◆ inv_sqrt_check()

template<typename T >

constexpr T internal::inv_sqrt_check ( const T x )

constexprnoexcept

◆ inv_sqrt_recur()

template<typename T >

constexpr T internal::inv_sqrt_recur	(	const T	x,
		const T	xn,
		const int	count
	)

constexprnoexcept

◆ is_even()

constexpr bool internal::is_even ( const llint_t x )

constexprnoexcept

◆ is_finite()

template<typename T >

constexpr bool internal::is_finite ( const T x )

constexprnoexcept

◆ is_inf()

template<typename T >

constexpr bool internal::is_inf ( const T x )

constexprnoexcept

◆ is_nan()

template<typename T >

constexpr bool internal::is_nan ( const T x )

constexprnoexcept

◆ is_neginf()

template<typename T >

constexpr bool internal::is_neginf ( const T x )

constexprnoexcept

◆ is_odd()

constexpr bool internal::is_odd ( const llint_t x )

constexprnoexcept

◆ is_posinf()

template<typename T >

constexpr bool internal::is_posinf ( const T x )

constexprnoexcept

◆ lcm_compute()

template<typename T >

constexpr T internal::lcm_compute	(	const T	a,
		const T	b
	)

constexprnoexcept

◆ lcm_type_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>>

constexpr TC internal::lcm_type_check	(	const T1	a,
		const T2	b
	)

constexprnoexcept

◆ lgamma_begin()

template<typename T >

constexpr T internal::lgamma_begin ( const T x )

constexprnoexcept

◆ lgamma_check()

template<typename T >

constexpr T internal::lgamma_check ( const T x )

constexprnoexcept

◆ lgamma_coef_term()

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

constexprnoexcept

◆ lgamma_term_1()

template<typename T >

constexpr T internal::lgamma_term_1 ( const T x )

constexprnoexcept

◆ lgamma_term_2()

template<typename T >

constexpr T internal::lgamma_term_2 ( const T x )

constexprnoexcept

◆ lmgamma_recur()

template<typename T1 , typename T2 >

constexpr T1 internal::lmgamma_recur	(	const T1	a,
		const T2	p
	)

constexprnoexcept

◆ log10_check()

template<typename T >

constexpr return_t< T > internal::log10_check ( const T x )

constexprnoexcept

◆ log1p_check()

template<typename T >

constexpr T internal::log1p_check ( const T x )

constexprnoexcept

◆ log1p_compute()

template<typename T >

constexpr T internal::log1p_compute ( const T x )

constexprnoexcept

◆ log2_check()

template<typename T >

constexpr return_t< T > internal::log2_check ( const T x )

constexprnoexcept

◆ log_binomial_coef_compute()

template<typename T >

constexpr T internal::log_binomial_coef_compute	(	const T	n,
		const T	k
	)

constexprnoexcept

◆ log_binomial_coef_type_check()

template<typename T1 , typename T2 , typename TC = common_return_t<T1,T2>>

constexpr TC internal::log_binomial_coef_type_check	(	const T1	n,
		const T2	k
	)

constexprnoexcept

◆ log_breakup()

template<typename T >

constexpr T internal::log_breakup ( const T x )

constexprnoexcept

◆ log_cf_begin()

template<typename T >

constexpr T internal::log_cf_begin ( const T x )

constexprnoexcept

◆ log_cf_main()

template<typename T >

constexpr T internal::log_cf_main	(	const T	xx,
		const int	depth
	)

constexprnoexcept

◆ log_check()

template<typename T >

constexpr T internal::log_check ( const T x )

constexprnoexcept

◆ log_integral_check()

template<typename T >

constexpr return_t< T > internal::log_integral_check ( const T x )

constexprnoexcept

◆ log_main()

template<typename T >

constexpr T internal::log_main ( const T x )

constexprnoexcept

◆ log_mantissa()

template<typename T >

constexpr T internal::log_mantissa ( const T x )

constexprnoexcept

◆ log_mantissa_integer()

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

constexprnoexcept

◆ mantissa()

template<typename T >

constexpr T internal::mantissa ( const T x )

constexprnoexcept

◆ neg_zero()

template<typename T >

constexpr bool internal::neg_zero ( const T x )

constexprnoexcept

◆ pow_check()

template<typename T1 , typename T2 , typename TC = common_t<T1,T2>, typename std::enable_if<!std::is_integral< T2 >::value >::type * = nullptr>

constexpr TC internal::pow_check	(	const T1	base,
		const T2	exp_term
	)

constexprnoexcept

◆ pow_dbl()

template<typename T >

constexpr T internal::pow_dbl	(	const T	base,
		const T	exp_term
	)

constexprnoexcept

◆ pow_integral()

template<typename T1 , typename T2 >

constexpr T1 internal::pow_integral	(	const T1	base,
		const T2	exp_term
	)

constexprnoexcept

◆ pow_integral_compute()

template<typename T1 , typename T2 >

constexpr T1 internal::pow_integral_compute	(	const T1	base,
		const T2	exp_term
	)

constexprnoexcept

◆ pow_integral_compute_recur()

template<typename T1 , typename T2 >

constexpr T1 internal::pow_integral_compute_recur	(	const T1	base,
		const T1	val,
		const T2	exp_term
	)

constexprnoexcept

◆ pow_integral_sgn_check()

template<typename T1 , typename T2 , typename std::enable_if< std::is_signed< T2 >::value >::type * = nullptr>

constexpr T1 internal::pow_integral_sgn_check	(	const T1	base,
		const T2	exp_term
	)

constexprnoexcept

◆ pow_integral_type_check()

template<typename T1 , typename T2 , typename std::enable_if< std::is_integral< T2 >::value >::type * = nullptr>

constexpr T1 internal::pow_integral_type_check	(	const T1	base,
		const T2	exp_term
	)

constexprnoexcept

◆ round_check()

template<typename T >

constexpr T internal::round_check ( const T x )

constexprnoexcept

◆ round_check_internal()

template<typename T >

constexpr T internal::round_check_internal ( const T x )

constexprnoexcept

◆ round_check_internal< double >()

template<>

constexpr double internal::round_check_internal< double > ( const double x )

constexprnoexcept

◆ round_check_internal< float >()

template<>

constexpr float internal::round_check_internal< float > ( const float x )

constexprnoexcept

◆ round_check_internal< long double >()

template<>

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

constexprnoexcept

◆ round_int()

template<typename T >

constexpr T internal::round_int ( const T x )

constexprnoexcept

◆ sin_check()

template<typename T >

constexpr T internal::sin_check ( const T x )

constexprnoexcept

◆ sin_compute()

template<typename T >

constexpr T internal::sin_compute ( const T x )

constexprnoexcept

◆ sinh_check()

template<typename T >

constexpr T internal::sinh_check ( const T x )

constexprnoexcept

◆ sqrt_check()

template<typename T >

constexpr T internal::sqrt_check	(	const T	x,
		const T	m_val
	)

constexprnoexcept

◆ sqrt_recur()

template<typename T >

constexpr T internal::sqrt_recur	(	const T	x,
		const T	xn,
		const int	count
	)

constexprnoexcept

◆ tan_begin()

template<typename T >

constexpr T internal::tan_begin	(	const T	x,
		const int	count = `0`
	)

constexprnoexcept

◆ tan_cf_main()

template<typename T >

constexpr T internal::tan_cf_main ( const T x )

constexprnoexcept

◆ tan_cf_recur()

template<typename T >

constexpr T internal::tan_cf_recur	(	const T	xx,
		const int	depth,
		const int	max_depth
	)

constexprnoexcept

◆ tan_check()

template<typename T >

constexpr T internal::tan_check ( const T x )

constexprnoexcept

◆ tan_series_exp()

template<typename T >

constexpr T internal::tan_series_exp ( const T x )

constexprnoexcept

◆ tan_series_exp_long()

template<typename T >

constexpr T internal::tan_series_exp_long ( const T z )

constexprnoexcept

◆ tanh_begin()

template<typename T >

constexpr T internal::tanh_begin ( const T x )

constexprnoexcept

◆ tanh_cf()

template<typename T >

constexpr T internal::tanh_cf	(	const T	xx,
		const int	depth
	)

constexprnoexcept

◆ tanh_check()

template<typename T >

constexpr T internal::tanh_check ( const T x )

constexprnoexcept

◆ tgamma_check()

template<typename T >

constexpr T internal::tgamma_check ( const T x )

constexprnoexcept

◆ trunc_check()

template<typename T >

constexpr T internal::trunc_check ( const T x )

constexprnoexcept

◆ trunc_check_internal()

template<typename T >

constexpr T internal::trunc_check_internal ( const T x )

constexprnoexcept

◆ trunc_check_internal< double >()

template<>

constexpr double internal::trunc_check_internal< double > ( const double x )

constexprnoexcept

◆ trunc_check_internal< float >()

template<>

constexpr float internal::trunc_check_internal< float > ( const float x )

constexprnoexcept

◆ trunc_check_internal< long double >()

template<>

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

constexprnoexcept

◆ trunc_int()

template<typename T >

constexpr T internal::trunc_int ( const T x )

constexprnoexcept

Namespaces

Functions

Function Documentation

◆ acos_check()

◆ acos_compute()

◆ acosh_compute()

◆ all_finite() [1/2]

◆ all_finite() [2/2]

◆ all_inf() [1/2]

◆ all_inf() [2/2]

◆ all_nan() [1/2]

◆ all_nan() [2/2]

◆ all_neginf() [1/2]

◆ all_neginf() [2/2]

◆ all_posinf() [1/2]

◆ all_posinf() [2/2]

◆ any_finite() [1/2]

◆ any_finite() [2/2]

◆ any_inf() [1/2]

◆ any_inf() [2/2]

◆ any_nan() [1/2]

◆ any_nan() [2/2]

◆ any_neginf() [1/2]

◆ any_neginf() [2/2]

◆ any_posinf() [1/2]

◆ any_posinf() [2/2]

◆ asin_check()

◆ asin_compute()

◆ asinh_compute()

◆ atan2_compute()

◆ atan2_type_check()

◆ atan_begin()

◆ atan_cf_main()

◆ atan_cf_recur()

◆ atan_check()

◆ atan_series_main()

◆ atan_series_order()

◆ atan_series_order_calc()

◆ atanh_check()

◆ atanh_compute()

◆ binomial_coef_check()

◆ binomial_coef_recur()

◆ binomial_coef_type_check()

◆ ceil_check()

◆ ceil_check_internal()

◆ ceil_check_internal< double >()

◆ ceil_check_internal< float >()

◆ ceil_check_internal< long double >()

◆ ceil_int()

◆ ceil_resid()

◆ cos_check()

◆ cos_compute()

◆ cosh_compute()

◆ erf_begin()

◆ erf_cf_large_main()

◆ erf_cf_large_recur()

◆ erf_cf_small_main()

◆ erf_cf_small_recur()

◆ erf_check()

◆ erf_inv_begin()

◆ erf_inv_decision()

◆ erf_inv_deriv_1()

◆ erf_inv_deriv_2()

◆ erf_inv_err_val()

◆ erf_inv_halley()

◆ erf_inv_initial_val()

◆ erf_inv_initial_val_case_1()

◆ erf_inv_initial_val_case_2()

◆ erf_inv_initial_val_coef_1()

◆ erf_inv_initial_val_coef_2()

◆ erf_inv_initial_val_int()

◆ erf_inv_ratio_val_1()

◆ erf_inv_ratio_val_2()

◆ erf_inv_recur()

◆ erf_inv_recur_begin()

◆ exp_cf()

◆ exp_cf_recur()

◆ exp_check()

◆ exp_split()

◆ expm1_check()