elc::defs::base::math 命名空间参考

命名空间
namespace	concepts
	概念名称空间 基于标准库的概念，但是使用帮助类型来便于后续定义中的新算数类型重载
namespace	linear_interpolation
	线性插值.

类
struct	arithmetic_type_info_prover
	算术类型帮助类型 任何后续定义的新算术类型都可以重载这些类型来实现数学库的泛型支持 更多...
struct	get_prime_factorization_t
struct	prime_factorization_table_t
struct	rounding_auto_setter
struct	unique_prime_factorization_table_t

类型定义
template<typename T >
using	to_unsigned_t = typename arithmetic_type_info_prover< remove_cvref< T > >::unsigned_type
template<typename T >
using	to_signed_t = typename arithmetic_type_info_prover< remove_cvref< T > >::signed_type
template<typename T >
using	float_type_of = typename arithmetic_type_info_prover< remove_cvref< T > >::float_type
template<typename T >
using	integer_type_of = typename arithmetic_type_info_prover< remove_cvref< T > >::integer_type

函数
template<arithmetic_type T>
constexpr bool	isNaN (const T &v) noexcept
template<basic_type T>
constexpr bool	isInf (const T &v) noexcept
template<arithmetic_type T> requires (!has_inf<T>)
constexpr bool	isInf (const T &) noexcept
template<arithmetic_type T>
constexpr bool	is_negative (const T &x) noexcept
template<typename T = void, typename Arg_t = void>
constexpr auto	copy_as_negative (Arg_t x, bool negative=1) noexcept
template<arithmetic_type T>
constexpr auto	reverse_sign (const T &x) noexcept
template<arithmetic_type T>
constexpr auto	reverse_sign_if (bool x, const T &y) noexcept
template<basic_float_type T>
constexpr auto	reciprocal (const T &x) noexcept
template<arithmetic_type T, arithmetic_type U>
constexpr T	safe_arithmetic_cast (U x) noexcept
template<arithmetic_type T>
constexpr size_t	to_size_t (T x) noexcept
template<arithmetic_type T>
constexpr uintmax_t	to_uintmax_t (T x) noexcept
template<arithmetic_type T1, arithmetic_type T2>
constexpr auto	mod (const T1 &a, const T2 &b)
template<arithmetic_type T>
constexpr bool	is_odd (const T &x) noexcept
template<arithmetic_type T>
constexpr bool	is_even (const T &x) noexcept
template<arithmetic_type T1, arithmetic_type T2> requires (!is_big_type<T1>&&!is_big_type<T2>)
constexpr auto	divmod (const T1 &a, const T2 &b)
template<arithmetic_type T, arithmetic_type U>
constexpr auto	ceil_div (const T &a, const U &b) noexcept
template<typename T >
constexpr void	set_rounding (int mode)
template<typename T >
constexpr int	get_rounding ()
template<arithmetic_type T>
constexpr auto	abs (const T &v) noexcept
template<arithmetic_type T>
constexpr bool	is_close (const T &a, const T &b) noexcept
template<arithmetic_type T1, arithmetic_type T2>
constexpr auto	sub (const T1 &a, const T2 &b) noexcept
template<float_type T>
constexpr T	exp (const T &v) noexcept
template<arithmetic_type T>
constexpr auto	log (const T &a) noexcept
template<arithmetic_type T, arithmetic_type U>
constexpr auto	log (const T &a, const U &b) noexcept
template<unsigned_integer_type T>
constexpr size_t	integer_log (const T &a, const auto &b) noexcept
template<arithmetic_type T, arithmetic_type U = unsigned> requires (!is_big_type<T>)
constexpr auto	pow (const T &a, const U &b=2) noexcept
template<big_type T, unsigned_integer_type U = unsigned>
constexpr auto	pow (T a, U b=2) noexcept
template<float_type T> requires is_basic_type<T>
constexpr auto	trunc (const T &v) noexcept
template<float_type T> requires is_basic_type<T>
constexpr auto	ceil (const T &v) noexcept
template<float_type T> requires is_basic_type<T>
constexpr auto	floor (const T &v) noexcept
template<float_type T> requires (has_ε<T>)
constexpr T	invsqrt (const T &v) noexcept
template<float_type T, arithmetic_type U = T>
constexpr T	invsqrt_iteration (const T &num, const U &v) noexcept
template<float_type T, arithmetic_type U = T>
constexpr T	invsqrt_to_new_ε (T num, const U &v, const to_unsigned_t< T > &ε, to_unsigned_t< T > &ε_saver) noexcept
template<float_type T>
constexpr T	quick_invsqrt (const T &v) noexcept
template<float_type T>
constexpr T	invsqrt (const T &v, const to_unsigned_t< T > &ε, to_unsigned_t< T > &ε_saver) noexcept
template<float_type T>
constexpr T	invsqrt (const T &v, const to_unsigned_t< T > &ε) noexcept
template<integer_type T>
constexpr auto	invsqrt (const T &v) noexcept
template<float_type T> requires (has_ε<T>)
constexpr T	sqrt (const T &v) noexcept
template<float_type T, arithmetic_type U = T>
constexpr T	sqrt_iteration (const T &num, const U &v) noexcept
template<float_type T, arithmetic_type U = T>
constexpr T	sqrt_to_new_ε (T num, const U &v, const to_unsigned_t< T > &ε, to_unsigned_t< T > &ε_saver) noexcept
template<float_type T, arithmetic_type U = T>
constexpr T	sqrt_to_new_ε (T num, const U &v, const to_unsigned_t< T > &ε) noexcept
template<float_type T>
constexpr T	quick_sqrt (const T &v) noexcept
template<float_type T>
constexpr T	sqrt (const T &v, const to_unsigned_t< T > &ε, to_unsigned_t< T > &ε_saver) noexcept
template<float_type T>
constexpr T	sqrt (const T &v, const to_unsigned_t< T > &ε) noexcept
template<integer_type T>
constexpr auto	sqrt (const T &v) noexcept
template<arithmetic_type T>
constexpr bool	is_prime_num_no_pre_check (T a) noexcept
template<arithmetic_type T>
constexpr bool	is_prime_num (T a) noexcept
template<arithmetic_type T>
constexpr T	get_prime_num_less_or_eq_than (T a) noexcept
	求小于或等于某数的素数
template<arithmetic_type T>
constexpr T	get_prime_num_big_or_eq_than (T a) noexcept
	求大于或等于某数的素数
template<arithmetic_type T>
constexpr auto	get_prime_num_big_than (T a) noexcept
	求大于某数的素数
template<unsigned_integer_type size_T>
constexpr size_T	get_next_gold_size_to_resize_for_array (size_T size) noexcept
	已知当前array的size，求下一个合适的提前分配大小
template<unsigned_integer_type size_T>
constexpr size_T	get_next_gold_size_to_resize_for_hash (size_T size) noexcept
	已知当前hash table的size，求下一个合适的桶大小
template<unsigned_integer_type T>
constexpr auto	factorial (unsigned n, unsigned start=1u) noexcept
template<integer_type T>
auto	binary_gcd (T x, T y) noexcept
template<integer_type T>
auto	euclidean_gcd (T x, T y) noexcept
template<integer_type T>
auto	base_gcd (T x, T y) noexcept
template<unsigned_big_integer_type T>
auto	lehmer_gcd (T x, T y) noexcept
template<integer_type T>
auto	gcd (T x, T y) noexcept
template<signed_float_type T>
constexpr T	sin (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	sin (T num) noexcept
template<float_type T>
constexpr T	arctan (T num, const to_unsigned_t< T > &ε) noexcept
template<float_type T> requires (has_ε<T>)
constexpr T	arctan (T num) noexcept
template<signed_float_type T>
constexpr T	cos (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	cos (T num) noexcept
template<signed_float_type T>
constexpr T	tan (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	tan (T num) noexcept
template<signed_float_type T>
constexpr T	cot (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	cot (T num) noexcept
template<signed_float_type T>
constexpr T	sec (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	sec (T num) noexcept
template<signed_float_type T>
constexpr T	csc (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	csc (T num) noexcept
template<signed_float_type T>
constexpr to_unsigned_t< T >	arccos (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr to_unsigned_t< T >	arccos (T num) noexcept
template<float_type T>
constexpr T	arcsin (T num, const to_unsigned_t< T > &ε) noexcept
template<float_type T> requires (has_ε<T>)
constexpr T	arcsin (T num) noexcept
template<signed_float_type T>
constexpr to_unsigned_t< T >	arccot (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr to_unsigned_t< T >	arccot (T num) noexcept
template<signed_float_type T>
constexpr T	arcsec (T num, const to_unsigned_t< T > &ε) noexcept
template<signed_float_type T> requires (has_ε<T>)
constexpr T	arcsec (T num) noexcept
template<float_type T>
constexpr T	arccsc (T num, const to_unsigned_t< T > &ε) noexcept
template<float_type T> requires (has_ε<T>)
constexpr T	arccsc (T num) noexcept

变量
constexpr struct elc::defs::base::math::get_prime_factorization_t	get_prime_factorization

类型定义说明

float_type_of

template<typename T >

using elc::defs::base::math::float_type_of = typedef typename arithmetic_type_info_prover<remove_cvref<T> >::float_type

对应的浮点数类型

在文件 all_defs.cpp 第 1600 行定义.

integer_type_of

template<typename T >

using elc::defs::base::math::integer_type_of = typedef typename arithmetic_type_info_prover<remove_cvref<T> >::integer_type

对应的整数类型

在文件 all_defs.cpp 第 1603 行定义.

to_signed_t

template<typename T >

using elc::defs::base::math::to_signed_t = typedef typename arithmetic_type_info_prover<remove_cvref<T> >::signed_type

有符号位的对应类型

在文件 all_defs.cpp 第 1597 行定义.

to_unsigned_t

template<typename T >

using elc::defs::base::math::to_unsigned_t = typedef typename arithmetic_type_info_prover<remove_cvref<T> >::unsigned_type

无符号位的对应类型

在文件 all_defs.cpp 第 1594 行定义.

函数说明

abs()

template<arithmetic_type T>

constexpr auto elc::defs::base::math::abs ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4506 行定义.

                                                                   {
        if constexpr(is_signed<T>){
            //符号转无符号而不是num=-num避免INT_MAX这种情况下的溢出
            typedef to_unsigned_t<T> UT;
            return is_negative(v)?UT(-v):UT(v);
        }
        else
            return v;
    }

函数调用图:

这是这个函数的调用关系图:

arccos() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr to_unsigned_t< T > elc::defs::base::math::arccos ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5518 行定义.

                                                                              {
        return arccos(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arccos() [2/2]

template<signed_float_type T>

constexpr to_unsigned_t< T > elc::defs::base::math::arccos ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5514 行定义.

                                                                                            {
        return to_unsigned_t<T>(π_with_ε(ε)/2u - arctan(num, ε));
    }

函数调用图:

这是这个函数的调用关系图:

arccot() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr to_unsigned_t< T > elc::defs::base::math::arccot ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5536 行定义.

                                                                              {
        return arccot(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arccot() [2/2]

template<signed_float_type T>

constexpr to_unsigned_t< T > elc::defs::base::math::arccot ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5532 行定义.

                                                                                            {
        return to_unsigned_t<T>(π_with_ε(ε)/2u - arctan(num, ε));
    }

函数调用图:

这是这个函数的调用关系图:

arccsc() [1/2]

template<float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::arccsc ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5554 行定义.

                                                               {
        return arccsc(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arccsc() [2/2]

template<float_type T>

constexpr T elc::defs::base::math::arccsc ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5550 行定义.

                                                                             {
        return arcsin(reciprocal(num), ε);
    }

函数调用图:

这是这个函数的调用关系图:

arcsec() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::arcsec ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5545 行定义.

                                                               {
        return arcsec(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arcsec() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::arcsec ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5541 行定义.

                                                                             {
        return arccos(reciprocal(num), ε);
    }

函数调用图:

这是这个函数的调用关系图:

arcsin() [1/2]

template<float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::arcsin ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5527 行定义.

                                                               {
        return arcsin(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arcsin() [2/2]

template<float_type T>

constexpr T elc::defs::base::math::arcsin ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5523 行定义.

                                                                             {
        return arctan(num/reciprocal(sqrt(1-pow(num), ε)), ε);
    }

函数调用图:

这是这个函数的调用关系图:

arctan() [1/2]

template<float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::arctan ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5464 行定义.

                                                               {
        return arctan(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

arctan() [2/2]

template<float_type T>

constexpr T elc::defs::base::math::arctan ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5442 行定义.

                                                                             {
        /*
        arctan (-x) = -arctan(x)
        arctan (1/x) = 0.5 * π - arctan(x) [x > 0]
        */
        if constexpr(signed_type<T>)
            if (num < 0) return -arctan(abs(num), ε);
        if (num > 1) return π_with_ε(ε)/2u - arctan(reciprocal(move(num)), ε);
 
        size_t i = 1; bool negation = false; // 取反
        to_signed_t<T> result = num;
        T numerator_base = num, sum, num_pow = pow(num); // 求num2的次方
        do {
            numerator_base *= num_pow; // 求阶乘
            negation = !negation; // 每次循环取反
            sum = numerator_base/i; // 单步计算结果
            result += reverse_sign_if(negation,sum); // 求和
            i += 2;
        }while (abs(sum) > ε);
        return (T)result;
    }

函数调用图:

这是这个函数的调用关系图:

base_gcd()

template<integer_type T>

auto elc::defs::base::math::base_gcd ( T  x, T  y  )

inlinenoexcept

在文件 all_defs.cpp 第 5257 行定义.

                                                       {
        if constexpr(BIT_POSSIBILITY==2)
            return binary_gcd(move(x), move(y));
        else
            return euclidean_gcd(move(x), move(y));
    }

函数调用图:

这是这个函数的调用关系图:

binary_gcd()

template<integer_type T>

auto elc::defs::base::math::binary_gcd ( T  x, T  y  )

inlinenoexcept

在文件 all_defs.cpp 第 5226 行定义.

                                                         {
        static_assert(BIT_POSSIBILITY==2);
        size_t shift = 0;
        while(y){
            //都是偶数时，shift++并位移
            const auto x_rzero=countr_zero(x);
            const auto y_rzero=countr_zero(y);
            shift+=min(x_rzero,y_rzero);
            //一偶一奇时，只移动偶数 直到都是奇数
            x>>=x_rzero;
            y>>=y_rzero;
            //都是奇数时，大数-=小数
            if(x < y)swap(x, y);
            x-=y;
        }
        // 返回 x 左移 shift 位的结果
        return move(x) << shift;
    }

函数调用图:

这是这个函数的调用关系图:

ceil()

template<float_type T>
requires is_basic_type<T>

constexpr auto elc::defs::base::math::ceil ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4653 行定义.

                                                                    {
        if in_consteval{
            auto ceil_impl = λ(T x, T y)noexcept{
                return is_close(x,y) ? y : y+T{1};
            };
            return v<0 ? -static_cast<T>(to_uintmax_t(-v)) : ceil_impl(v,static_cast<T>(to_uintmax_t(v)));
        }
        else
            return ::std::ceil(v);
    }

函数调用图:

这是这个函数的调用关系图:

ceil_div()

template<arithmetic_type T, arithmetic_type U>

constexpr auto elc::defs::base::math::ceil_div ( const T &  a, const U &  b  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4472 行定义.

                                                                                  {
        const auto[quot,mod]=divmod(a,b);
        return quot+(mod?1u:0u);
    }

函数调用图:

这是这个函数的调用关系图:

copy_as_negative()

template<typename T = void, typename Arg_t = void>

constexpr auto elc::defs::base::math::copy_as_negative ( Arg_t  x, bool  negative = 1  )

inlineconstexprnoexcept

符号位设置

在文件 all_defs.cpp 第 4381 行定义.

                                                                                              {
        if constexpr(is_unsigned<T>)
            template_error("copy_as_negative:unsigned type");
        elseif constexpr(type_info<T> == type_info<void>)
            return copy_as_negative<to_signed_t<Arg_t>>(x,negative);
        elseif constexpr(is_basic_type<Arg_t>) {
            if constexpr(is_float_type<Arg_t>)
                return(T)::std::copysign(x,negative?-1:1);
            else
                return(T)negative?T{}-x:x;
        }
        else
            return(T)negative?T{}-x:x;
    }

函数调用图:

这是这个函数的调用关系图:

cos() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::cos ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5473 行定义.

                                                            {
        return cos(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

cos() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::cos ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5469 行定义.

                                                                          {
        return sin(π_with_ε(ε)/2u - num, ε);
    }

函数调用图:

这是这个函数的调用关系图:

cot() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::cot ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5491 行定义.

                                                            {
        return cot(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

cot() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::cot ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5487 行定义.

                                                                          {
        return cos(num, ε)/sin(num, ε);
    }

函数调用图:

这是这个函数的调用关系图:

csc() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::csc ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5509 行定义.

                                                            {
        return csc(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

csc() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::csc ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5505 行定义.

                                                                          {
        return reciprocal(sin(num, ε));
    }

函数调用图:

这是这个函数的调用关系图:

divmod()

template<arithmetic_type T1, arithmetic_type T2>
requires (!is_big_type<T1>&&!is_big_type<T2>)

constexpr auto elc::defs::base::math::divmod ( const T1 &  a, const T2 &  b  )

inlineconstexpr

在文件 all_defs.cpp 第 4458 行定义.

                                                                          {
        typedef decltype(a/b) quot_t;
        typedef decltype(a%b) mod_t;
        struct divmod_result{
            quot_t quot;
            mod_t mod;
        };
        if constexpr(basic_float_type<T1>||basic_float_type<T2>)
            return divmod_result{::std::floor(a/b),::std::fmod(a,b)};
        else
            return divmod_result{a/b,a%b};
    }

函数调用图:

这是这个函数的调用关系图:

euclidean_gcd()

template<integer_type T>

auto elc::defs::base::math::euclidean_gcd ( T  x, T  y  )

inlinenoexcept

在文件 all_defs.cpp 第 5246 行定义.

                                                            {
        if constexpr(is_signed<T>)
            if(is_negative(x) && is_negative(y))
                return euclidean_gcd(abs(x), abs(y));
        while(y){
            if(x < y)swap(x, y);
            x = swap(y, x%y);
        }
        return x;
    }

函数调用图:

这是这个函数的调用关系图:

exp()

template<float_type T>

constexpr T elc::defs::base::math::exp ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4540 行定义.

                                                                {
        if(in_consteval||!is_basic_type<T>){
            typedef decltype(λ{
                if constexpr(is_basic_type<T>)
                    return ::std::exp(T{});
                else
                    return T{};
            }()) RT;
            auto exp_impl = recursive_λ(RT x,RT sum,RT n,size_t i,RT t)noexcept -> RT{
                const auto ε=sum+t/n;
                if(is_close(sum,ε))
                    return sum;
                else
                    return self_recursion(x,ε,n*i,i+1,t*x);
            };
            auto exp_impl_caller = get_recursive_λ_caller(exp_impl);
            return exp_impl_caller(RT{v},RT{1u},RT{1u},2,RT{v});
        }
        elseif constexpr(is_basic_type<T>)
            return ::std::exp(v);
    }

函数调用图:

这是这个函数的调用关系图:

factorial()

template<unsigned_integer_type T>

constexpr auto elc::defs::base::math::factorial ( unsigned  n, unsigned  start = 1u  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5150 行定义.

                                                                                      {
        constexpr size_t threshold=1<<4;
        if (n < threshold) {
            T s = 1u;
            unsigned end = start + n;
            while(start < end)
                s *= start++;
            return s;
        }
        unsigned m = (n+1u)/2;
        return factorial<T>(m,start)*factorial<T>(n-m,start+m);
    }

函数调用图:

这是这个函数的调用关系图:

floor()

template<float_type T>
requires is_basic_type<T>

constexpr auto elc::defs::base::math::floor ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4666 行定义.

                                                                     {
        if in_consteval{
            auto floor_impl = λ(T x, T y)noexcept{
                return is_close(x,y) ? y : y-T{1};
            };
            return v<0 ? -static_cast<T>(to_uintmax_t(-v+T{1})) : floor_impl(v,static_cast<T>(to_uintmax_t(v)));
        }
        else
            return ::std::floor(v);
    }

函数调用图:

这是这个函数的调用关系图:

gcd()

template<integer_type T>

auto elc::defs::base::math::gcd ( T  x, T  y  )

inlinenoexcept

在文件 all_defs.cpp 第 5315 行定义.

                                                  {
        if constexpr(BIT_POSSIBILITY==2){
            if constexpr(is_big_type<T>){
                constexpr size_t lehmer_threshold = 1<<8;
                if(max(x.size_in_base_type(),y.size_in_base_type()) >= lehmer_threshold)
                    return lehmer_gcd(move(x), move(y));
            }
            return binary_gcd(move(x), move(y));
        }
        else
            return lehmer_gcd(move(x), move(y));
    }

函数调用图:

这是这个函数的调用关系图:

get_next_gold_size_to_resize_for_array()

template<unsigned_integer_type size_T>

constexpr size_T elc::defs::base::math::get_next_gold_size_to_resize_for_array ( size_T  size )

inlineconstexprnoexcept

已知当前array的size，求下一个合适的提前分配大小

在文件 all_defs.cpp 第 4898 行定义.

                                                                                                    {
        /*
        每次扩容后的空间与原空间比大致为φ可以最小化时空负担.
        */
        return size_T(size*magic_number::φ);
    }

函数调用图:

这是这个函数的调用关系图:

get_next_gold_size_to_resize_for_hash()

template<unsigned_integer_type size_T>

constexpr size_T elc::defs::base::math::get_next_gold_size_to_resize_for_hash ( size_T  size )

inlineconstexprnoexcept

已知当前hash table的size，求下一个合适的桶大小

在文件 all_defs.cpp 第 4906 行定义.

                                                                                                   {
        /*
        素数大小的桶数可以使hash table中的每个桶尽可能活跃.
        每次扩容后的空间与原空间比大致为φ可以最小化时空负担.
        */
        return size_T(get_prime_num_big_or_eq_than(size*magic_number::φ));
    }

函数调用图:

这是这个函数的调用关系图:

get_prime_num_big_or_eq_than()

template<arithmetic_type T>

constexpr T elc::defs::base::math::get_prime_num_big_or_eq_than ( T  a )

inlineconstexprnoexcept

求大于或等于某数的素数

在文件 all_defs.cpp 第 4848 行定义.

                                                                             {
        if constexpr(is_float_type<T>)
            a=ceil(a);
        if constexpr(is_signed<T>)
            if(is_negative(a)){
                auto tmp = get_prime_num_less_or_eq_than(abs(a));
                return copy_as_negative(tmp);
            }
        if(a<4u)return a;
        //将a转换为6x-1的形式.
        {
            T b=mod(a,6u);
            if(b==1u && is_prime_num_no_pre_check(a))return a;
            a+=b?5u-b:1u;
        }
        //循环判断.
        for(;;a+=6u)
            if(is_prime_num_no_pre_check(a))return a;
            elseif(is_prime_num_no_pre_check(a+2u))return a+2u;
    }

函数调用图:

这是这个函数的调用关系图:

get_prime_num_big_than()

template<arithmetic_type T>

constexpr auto elc::defs::base::math::get_prime_num_big_than ( T  a )

inlineconstexprnoexcept

求大于某数的素数

在文件 all_defs.cpp 第 4892 行定义.

                                                                          {
        return get_prime_num_big_or_eq_than(a+1u);
    }

函数调用图:

这是这个函数的调用关系图:

get_prime_num_less_or_eq_than()

template<arithmetic_type T>

constexpr T elc::defs::base::math::get_prime_num_less_or_eq_than ( T  a )

inlineconstexprnoexcept

求小于或等于某数的素数

在文件 all_defs.cpp 第 4870 行定义.

                                                                              {
        if constexpr(is_float_type<T>)
            a=floor(a);
        if constexpr(is_signed<T>)
            if(is_negative(a)){
                auto tmp = get_prime_num_big_or_eq_than(abs(a));
                return copy_as_negative(tmp);
            }
        if(a<4u)return a;
        //将a转换为6x-1的形式.
        {
            T b=mod(a,6u);
            if(b==1u && is_prime_num_no_pre_check(a))return a;
            a-=b?b-1u:5u;
        }
        //循环判断.
        for(;;a-=6u)
            if(is_prime_num_no_pre_check(a))return a;
            elseif(is_prime_num_no_pre_check(a-2u))return a-2u;
    }

函数调用图:

这是这个函数的调用关系图:

get_rounding()

template<typename T >

constexpr int elc::defs::base::math::get_rounding ( )

inlineconstexpr

获取浮点舍入

在文件 all_defs.cpp 第 4485 行定义.

                                                          {
        if constexpr(basic_float_type<T>)
            return ::std::fegetround();
        else
            return 0;
    }

函数调用图:

这是这个函数的调用关系图:

integer_log()

template<unsigned_integer_type T>

constexpr size_t elc::defs::base::math::integer_log ( const T &  a, const auto &  b  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4591 行定义.

                                                                                            {
        auto integer_log_impl = recursive_λ(const T& a,T& tester,const T this_lv,const size_t num)noexcept -> size_t{
            size_t aret=0;
            {
                const auto next_lv=this_lv*this_lv;
                if(next_lv<a)
                    aret=self_recursion(a,tester,next_lv,num*2);
            }
            floop
                if(auto tmp=tester*this_lv;tmp>a)return aret;
                else{
                    tester=move(tmp);
                    aret+=num;
                }
        };
        auto integer_log_impl_caller = get_recursive_λ_caller(integer_log_impl,noexcept);
        T tester=1u;
        return integer_log_impl_caller(a,tester,move(b),1u);
    }

函数调用图:

这是这个函数的调用关系图:

invsqrt() [1/4]

template<float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::invsqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4721 行定义.

                                                                    {
        return invsqrt(v,arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

这是这个函数的调用关系图:

invsqrt() [2/4]

template<integer_type T>

constexpr auto elc::defs::base::math::invsqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4725 行定义.

                                                                       {
        return invsqrt(static_cast<float_type_of<T>>(v));
    }

函数调用图:

invsqrt() [3/4]

template<float_type T>

constexpr T elc::defs::base::math::invsqrt ( const T &  v, const to_unsigned_t< T > &  ε  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4713 行定义.

                                                                                        {
        if constexpr(has_NaN<T> && has_inf<T>)
            if(v < 0u || v >= arithmetic_type_info_prover<T>::Inf())
                return arithmetic_type_info_prover<T>::NaN();
        return invsqrt_to_new_ε(quick_invsqrt(v),v,ε);
    }

函数调用图:

invsqrt() [4/4]

template<float_type T>

constexpr T elc::defs::base::math::invsqrt ( const T &  v, const to_unsigned_t< T > &  ε, to_unsigned_t< T > &  ε_saver  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4706 行定义.

                                                                                                                  {
        if constexpr(has_NaN<T> && has_inf<T>)
            if(v < 0u || v >= arithmetic_type_info_prover<T>::Inf())
                return arithmetic_type_info_prover<T>::NaN();
        return invsqrt_to_new_ε(quick_invsqrt(v),v,ε,ε_saver);
    }

函数调用图:

invsqrt_iteration()

template<float_type T, arithmetic_type U = T>

constexpr T elc::defs::base::math::invsqrt_iteration ( const T &  num, const U &  v  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4680 行定义.

                                                                       {
        //newton-raphson
        return num*(3u-v*num*num)/2u;
    }

函数调用图:

这是这个函数的调用关系图:

invsqrt_to_new_ε()

template<float_type T, arithmetic_type U = T>

constexpr T elc::defs::base::math::invsqrt_to_new_ε ( T  num, const U &  v, const to_unsigned_t< T > &  ε, to_unsigned_t< T > &  ε_saver  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4685 行定义.

                                                                                                                     {
        while(ε_saver>ε){
            auto next_ret=invsqrt_iteration(num,v);
            ε_saver=abs(next_ret-num);
            num=move(next_ret);
        }
        return num;
    }

函数调用图:

这是这个函数的调用关系图:

is_close()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_close ( const T &  a, const T &  b  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4517 行定义.

                                                                                  {
        if constexpr(basic_float_type<T>)
            return abs(a-b)<=arithmetic_type_info_prover<T>::ε();
        else
            return a==b;
    }

函数调用图:

这是这个函数的调用关系图:

is_even()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_even ( const T &  x )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4453 行定义.

                                                                       {
        return !is_odd(x);
    }

函数调用图:

这是这个函数的调用关系图:

is_negative()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_negative ( const T &  x )

inlineconstexprnoexcept

符号位查询

在文件 all_defs.cpp 第 4369 行定义.

                                                                           {
        if constexpr(is_signed<T>){
            if constexpr(has_NaN<T>)
                if(isNaN(x))
                    return false;
            return x<T{};
        }
        else
            return false;
    }

函数调用图:

这是这个函数的调用关系图:

is_odd()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_odd ( const T &  x )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4445 行定义.

                                                                      {
        if constexpr(is_integer_type<T>)
            return x&1;
        else
            return mod(x,T(2));
    }

函数调用图:

这是这个函数的调用关系图:

is_prime_num()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_prime_num ( T  a )

inlineconstexprnoexcept

判断某数是否是素数

在文件 all_defs.cpp 第 4818 行定义.

                                                                {
        if constexpr(is_float_type<T>)
            if(a != ceil(a))
                return false;
        auto b=abs(a);
 
        if(b<4)
            return true;//1和0也是prime,我不管.
        /*
        当x≥1,那么≥5的自然数如下:
        6x-1 6x 6x+1 6x+2 6x+3 6x+4
        6(x+1)-1 6(x+1) 6(x+1)+1 ... //这已经是下一周期了.
 
        考虑单个周期:
        6x+2 6x+3 6x+4 是 2(3x+1) 3(2x+1) 2(3x+2),排除.
        6x,排除.
        那么,只用考虑6x±1是否是prime.
        */
        if(mod(mod(b,6)-1u,4u))
            return false;
        /*
        因为no_pre_check判定没有考虑到≤5的数,所以本函数第一个if进行判定补全.
        */
        return is_prime_num_no_pre_check(b);
    }

函数调用图:

这是这个函数的调用关系图:

is_prime_num_no_pre_check()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::is_prime_num_no_pre_check ( T  a )

inlineconstexprnoexcept

判断某数是否是素数,无预先检查以供其他素数相关函数快速调用.

在文件 all_defs.cpp 第 4788 行定义.

                                                                             {
        /*
        应某人的要求补注释(都是主人的任务罢了.).
        建议先看有预先检查的部分以便理解思路.
        */
        T b=safe_arithmetic_cast<T>(sqrt(a));//若一个数可以分解为两因数之积,其中一个因数必定≤其开方:反指数式减少遍历范围.
        /*
        接下来:
        设要判定的数n(6x±1的缩写).
        测试数可以看为6i-1 6i 6i+1 6i+2 6i+3 6i+4的其中之一,同样以6为周期.
        对于测试数的整个周期,其中:
            如果n能被6i 6i+2 6i+4整除:则n要是偶数,但±1,排除.
            如果n能被6i+3整除:则n要是3倍数,但±1,排除.
        综上,循环中只要考虑6i±1的情况.
        所以以5起始,前进6(自然选择号,前进4!),逐次判断0与+2.
        虽然很想写成以6为起始逐次判断±1的对称格式但是这样会加重时空负担.(不甘心.....)
        */
        for(T c=5u;c<=b;c+=6u)//遍历判断是否能被因数分解——不会有人看不懂吧?
            if((!mod(a,c))||(!mod(a,(c+2u))))
                return false;
        /*
        最后,为什么是6?
        就结论来说,此数值选择最常出现的两因数(除0或1外.)之积可以最大程度减少时间占用.
        所以虽然更喜欢7/8/9之类的数不过使用6收益最大.
        要不是这样早就写成7了.
        */
        return true;
    }

函数调用图:

这是这个函数的调用关系图:

isInf() [1/2]

template<arithmetic_type T>
requires (!has_inf<T>)

constexpr bool elc::defs::base::math::isInf ( const T &  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4364 行定义.

                                                                    {
        return false;
    }

函数调用图:

isInf() [2/2]

template<basic_type T>

constexpr bool elc::defs::base::math::isInf ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4357 行定义.

                                                                     {
        if constexpr(has_inf<T>)
            return v==arithmetic_type_info_prover<T>::Inf() || v==arithmetic_type_info_prover<T>::negative_Inf();
        else
            return false;
    }

函数调用图:

这是这个函数的调用关系图:

isNaN()

template<arithmetic_type T>

constexpr bool elc::defs::base::math::isNaN ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4349 行定义.

                                                                     {
        if constexpr(has_NaN<T>)
            return v!=v;
        else
            return false;
    }

函数调用图:

这是这个函数的调用关系图:

lehmer_gcd()

template<unsigned_big_integer_type T>

auto elc::defs::base::math::lehmer_gcd ( T  x, T  y  )

inlinenoexcept

在文件 all_defs.cpp 第 5264 行定义.

                                                         {
        //假设x≥y
        if(x < y)swap(x, y);
 
        size_t m=y.size_in_base_type();
        if(m <= 1)return base_gcd(move(x), move(y));//如果y只包含一位数（或根本没有），则使用其他方法求出结果
        T A, B, C, D;
    outer_loop:
        while(x && y) {//外循环
            --m;//提高精度
            T a = x.right_shift_in_base_type(m), b = y.right_shift_in_base_type(m);//取最显著数位
            /*初始化矩阵[A B a]为扩展的同一矩阵[1 0 a]
                      [C D b]              [0 1 b]
            */
            A = D = 1u; B = C = T{};
            //对(a+A,b+C)和(a+B,b+D)同时执行欧几里得算法，直到商不同为止
            do{//内循环
                const auto w = (a+A) / (b+C);//w为欧几里得算法长除法链中当前长除法的商
                {
                    const auto w2 = (a+B) / (b+D);
                    if(w != w2)break;
                }
                /*根据扩展欧几里得算法的矩阵表述替换当前矩阵[A B a]到矩阵积[0  1]    [A B a]   [C    D    a   ]
                                                     [C D b]              ⋅         =
                                                                   [1 −w]   [C D b]   [A−wC B−wD a−wb]
                */
                A-=w*C;swap(A,C);
                B-=w*D;swap(B,D);
                a-=w*b;swap(a,b);
            }while(B);//B≠0则继续
            if(!B){//B=0意味着陷入了死锁；执行欧几里得算法的正常步骤，然后重新开始外循环
                x = swap(y, x%y);
                goto outer_loop;
            }
            //将对压缩形式的前数位执行的欧几里得算法步骤应用到x和y上
            auto new_x = A*x+B*y, new_y = C*x+D*y;
            x = move(new_x),y = move(new_y);
        }
        return x;
    }

函数调用图:

这是这个函数的调用关系图:

log() [1/2]

template<arithmetic_type T>

constexpr auto elc::defs::base::math::log ( const T &  a )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4564 行定义.

                                                                   {
        if(in_consteval||!is_basic_type<T>){
            typedef decltype(λ()noexcept{
                if constexpr(is_basic_type<T>)
                    return ::std::log(T{});
                else
                    return T{};
            }()) RT;
            auto log_impl = recursive_λ(const RT x,const RT y)noexcept -> RT{
                auto log_iter = λ(RT x,RT y)noexcept{
                    const auto exp_y = exp(y);
                    return y + T{2u}*(x-exp_y)/(x+exp_y);
                };
                return RT(is_close(y,log_iter(x,y)) ? y : self_recursion(x,log_iter(x,y)));
            };
            auto log_impl_caller = get_recursive_λ_caller(log_impl);
            return log_impl_caller((RT)a,RT{0u});
        }
        elseif constexpr(is_basic_type<T>)
            return ::std::log(a);
    }

函数调用图:

这是这个函数的调用关系图:

log() [2/2]

template<arithmetic_type T, arithmetic_type U>

constexpr auto elc::defs::base::math::log ( const T &  a, const U &  b  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4586 行定义.

                                                                             {
        return log(a)/log(b);
    }

函数调用图:

mod()

template<arithmetic_type T1, arithmetic_type T2>

constexpr auto elc::defs::base::math::mod ( const T1 &  a, const T2 &  b  )

inlineconstexpr

求余

在文件 all_defs.cpp 第 4437 行定义.

                                                                       {
        if constexpr(basic_float_type<T1>||basic_float_type<T2>)
            return ::std::fmod(a,b);
        else
            return a%b;
    }

函数调用图:

这是这个函数的调用关系图:

pow() [1/2]

template<arithmetic_type T, arithmetic_type U = unsigned>
requires (!is_big_type<T>)

constexpr auto elc::defs::base::math::pow ( const T &  a, const U &  b = 2  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4614 行定义.

                                                                               {
        if(in_consteval||!is_basic_type<T>){
            typedef decltype(::std::pow(a,b)) RT;
            return RT(exp(b*log(a)));
        }
        elseif constexpr(is_basic_type<T>)
            return ::std::pow(a,b);
    }

函数调用图:

这是这个函数的调用关系图:

pow() [2/2]

template<big_type T, unsigned_integer_type U = unsigned>

constexpr auto elc::defs::base::math::pow ( T  a, U  b = 2  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4623 行定义.

                                                                   {
        if constexpr(is_signed<T>){
            const bool isneg=is_negative(a) && is_odd(b);
            const auto abs_ret=pow(abs(a),b);
            return copy_as_negative(abs_ret,isneg);
        }
        else{
            T aret=1u;
            while(b){
                if(is_odd(b))aret*=a;
                a*=a;
                b>>=1u;
            }
            return aret;
        }
    }

函数调用图:

quick_invsqrt()

template<float_type T>

constexpr T elc::defs::base::math::quick_invsqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4694 行定义.

                                                                    {
        if constexpr(BIT_POSSIBILITY==2)// evil floating point bit level hacking
            if(!in_consteval)//编译期计算不能使用union_cast，让编译器慢慢算去吧
                if constexpr(is_big_type<T>)
                    return quick_invsqrt(static_cast<long double>(v));
                else{
                    using namespace basic_environment::float_infos;
                    return union_cast<T>((quick_invsqrt_magic_number<T> - union_cast<const data_type<T>>(v))>>1);
                }
        return 2u/v;
    }

函数调用图:

这是这个函数的调用关系图:

quick_sqrt()

template<float_type T>

constexpr T elc::defs::base::math::quick_sqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4751 行定义.

                                                                 {
        if constexpr(BIT_POSSIBILITY==2)// evil floating point bit level hacking
            if(!in_consteval)//编译期计算不能使用union_cast，让编译器慢慢算去吧
                if constexpr(is_big_type<T>)
                    return quick_sqrt(static_cast<long double>(v));
                else{
                    using namespace basic_environment::float_infos;
                    return union_cast<T>((union_cast<const data_type<T>>(v)>>1) + (data_type<T>(exponent_diff<T>) << (precision_base_bit<T> - 1)));
                }
        return v/2u;
        //return reciprocal(quick_invsqrt(v));
    }

函数调用图:

这是这个函数的调用关系图:

reciprocal()

template<basic_float_type T>

constexpr auto elc::defs::base::math::reciprocal ( const T &  x )

inlineconstexprnoexcept

倒数

在文件 all_defs.cpp 第 4408 行定义.

                                                                          {
        return T{1}/x;
    }

函数调用图:

这是这个函数的调用关系图:

reverse_sign()

template<arithmetic_type T>

constexpr auto elc::defs::base::math::reverse_sign ( const T &  x )

inlineconstexprnoexcept

符号位反转

在文件 all_defs.cpp 第 4398 行定义.

                                                                            {
        return copy_as_negative(x,!is_negative(x));
    }

函数调用图:

这是这个函数的调用关系图:

reverse_sign_if()

template<arithmetic_type T>

constexpr auto elc::defs::base::math::reverse_sign_if ( bool  x, const T &  y  )

inlineconstexprnoexcept

符号位反转，如果X为真

在文件 all_defs.cpp 第 4403 行定义.

                                                                                      {
        return x?reverse_sign(y):y;
    }

函数调用图:

这是这个函数的调用关系图:

safe_arithmetic_cast()

template<arithmetic_type T, arithmetic_type U>

constexpr T elc::defs::base::math::safe_arithmetic_cast ( U  x )

inlineconstexprnoexcept

任意算数类型安全转型(ub避免.).

在文件 all_defs.cpp 第 4413 行定义.

                                                                           {
        if constexpr(basic_float_type<U> && unsigned_type<T>)
            if(is_negative(x))
                return (T)(intmax_t)x;
            else{
                push_and_disable_msvc_warning(26467);//x已非负
                return (T)(uintmax_t)x;
                pop_msvc_warning();
            }
        else
            return (T)x;
    }

函数调用图:

这是这个函数的调用关系图:

sec() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::sec ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5500 行定义.

                                                            {
        return sec(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

sec() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::sec ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5496 行定义.

                                                                          {
        return reciprocal(cos(num, ε));
    }

函数调用图:

这是这个函数的调用关系图:

set_rounding()

template<typename T >

constexpr void elc::defs::base::math::set_rounding ( int  mode )

inlineconstexpr

设置浮点舍入

在文件 all_defs.cpp 第 4479 行定义.

                                                      {
        if constexpr(basic_float_type<T>)
            ::std::fesetround(mode);
    }

函数调用图:

这是这个函数的调用关系图:

sin() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::sin ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5437 行定义.

                                                            {
        return sin(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

sin() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::sin ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5425 行定义.

                                                                          {
        size_t i = 1; bool negation = false; // 取反
        T base = num, result = num, num_pow = pow(num); // 求num2的次方
        while (abs(base) > ε) {
            base *= num_pow/((i+1)*(i+2)); // 求阶乘
            negation = !negation; // 每次循环取反
            result += reverse_sign_if(negation,base); // 求和
            i += 2;
        }
        return result;
    }

函数调用图:

这是这个函数的调用关系图:

sqrt() [1/4]

template<float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::sqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4779 行定义.

                                                                 {
        return sqrt(v,arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

这是这个函数的调用关系图:

sqrt() [2/4]

template<integer_type T>

constexpr auto elc::defs::base::math::sqrt ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4783 行定义.

                                                                    {
        return sqrt(static_cast<float_type_of<T>>(v));
    }

函数调用图:

sqrt() [3/4]

template<float_type T>

constexpr T elc::defs::base::math::sqrt ( const T &  v, const to_unsigned_t< T > &  ε  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4771 行定义.

                                                                                     {
        if constexpr(has_NaN<T> && has_inf<T>)
            if(v < 0u || v >= arithmetic_type_info_prover<T>::Inf())
                return arithmetic_type_info_prover<T>::NaN();
        return sqrt_to_new_ε(quick_sqrt(v),v,ε);
    }

函数调用图:

sqrt() [4/4]

template<float_type T>

constexpr T elc::defs::base::math::sqrt ( const T &  v, const to_unsigned_t< T > &  ε, to_unsigned_t< T > &  ε_saver  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4764 行定义.

                                                                                                               {
        if constexpr(has_NaN<T> && has_inf<T>)
            if(v < 0u || v >= arithmetic_type_info_prover<T>::Inf())
                return arithmetic_type_info_prover<T>::NaN();
        return sqrt_to_new_ε(quick_sqrt(v),v,ε,ε_saver);
    }

函数调用图:

sqrt_iteration()

template<float_type T, arithmetic_type U = T>

constexpr T elc::defs::base::math::sqrt_iteration ( const T &  num, const U &  v  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4732 行定义.

                                                                    {
        //newton-raphson
        return (num+v/num)/2u;
    }

函数调用图:

这是这个函数的调用关系图:

sqrt_to_new_ε() [1/2]

template<float_type T, arithmetic_type U = T>

constexpr T elc::defs::base::math::sqrt_to_new_ε ( T  num, const U &  v, const to_unsigned_t< T > &  ε  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4746 行定义.

                                                                                        {
        auto ε_saver=to_unsigned_t<T>{ε*BIT_POSSIBILITY};
        return sqrt_to_new_ε(num,v,ε,ε_saver);
    }

函数调用图:

sqrt_to_new_ε() [2/2]

template<float_type T, arithmetic_type U = T>

constexpr T elc::defs::base::math::sqrt_to_new_ε ( T  num, const U &  v, const to_unsigned_t< T > &  ε, to_unsigned_t< T > &  ε_saver  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4737 行定义.

                                                                                                                  {
        while(ε_saver>ε){
            auto next_ret=sqrt_iteration(num,v);
            ε_saver=abs(next_ret-num);
            num=move(next_ret);
        }
        return num;
    }

函数调用图:

这是这个函数的调用关系图:

sub()

template<arithmetic_type T1, arithmetic_type T2>

constexpr auto elc::defs::base::math::sub ( const T1 &  a, const T2 &  b  )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4525 行定义.

                                                                               {
        if constexpr(is_basic_type<T1>&&is_basic_type<T2>){
            if constexpr(is_float_type<T1>||is_float_type<T2>)
                return a-b;
            else{
                using signedT = ::std::make_signed_t<::std::common_type_t<T1,T2,signed char>>;
                return static_cast<signedT>(a)-static_cast<signedT>(b);
            }
        }
        else
            return a-b;
    }

函数调用图:

这是这个函数的调用关系图:

tan() [1/2]

template<signed_float_type T>
requires (has_ε<T>)

constexpr T elc::defs::base::math::tan ( T  num )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 5482 行定义.

                                                            {
        return tan(num, arithmetic_type_info_prover<T>::ε());
    }

函数调用图:

tan() [2/2]

template<signed_float_type T>

constexpr T elc::defs::base::math::tan ( T  num, const to_unsigned_t< T > &  ε  )

constexprnoexcept

在文件 all_defs.cpp 第 5478 行定义.

                                                                          {
        return sin(num, ε)/cos(num, ε);
    }

函数调用图:

这是这个函数的调用关系图:

to_size_t()

template<arithmetic_type T>

constexpr size_t elc::defs::base::math::to_size_t ( T  x )

inlineconstexprnoexcept

任意算数类型转size_t

在文件 all_defs.cpp 第 4427 行定义.

                                                                     {
        return safe_arithmetic_cast<size_t>(x);
    }

函数调用图:

这是这个函数的调用关系图:

to_uintmax_t()

template<arithmetic_type T>

constexpr uintmax_t elc::defs::base::math::to_uintmax_t ( T  x )

inlineconstexprnoexcept

任意算数类型转uintmax_t

在文件 all_defs.cpp 第 4432 行定义.

                                                                           {
        return safe_arithmetic_cast<uintmax_t>(x);
    }

函数调用图:

这是这个函数的调用关系图:

trunc()

template<float_type T>
requires is_basic_type<T>

constexpr auto elc::defs::base::math::trunc ( const T &  v )

inlineconstexprnoexcept

在文件 all_defs.cpp 第 4642 行定义.

                                                                     {
        if in_consteval{
            typedef decltype(::std::trunc(v)) RT;
            return static_cast<RT>((intmax_t)v);
        }
        else
            return ::std::trunc(v);
    }

函数调用图:

这是这个函数的调用关系图:

变量说明

get_prime_factorization

constexpr struct elc::defs::base::math::get_prime_factorization_t elc::defs::base::math::get_prime_factorization