elc::defs::basic_environment 命名空间参考

命名空间
namespace	float_infos

类
class	to_arithmetic_t

概念
concept	is_elc_expansion_base_type

类型定义
typedef bool	bit_type
typedef ::std::uintmax_t	basic_uintmax_t
typedef ::std::intmax_t	basic_intmax_t
typedef decltype(λ{ return basic_uintmax_t{};}())	uintmax_t
typedef decltype(λ{ return basic_intmax_t{};}())	intmax_t
typedef basic_uintmax_t	uintmax_index_t
typedef basic_intmax_t	intmax_index_t
template<size_t size>
using	unsigned_specific_size_t = decltype(λ{ if constexpr(size==sizeof(uint8_t)) return(uint8_t) 0
template<size_t size>
using	unsigned_specific_size_fast_t = decltype(λ{ if constexpr(size<=sizeof(uint_fast8_t)) return(uint_fast8_t) 0
template<size_t size>
using	signed_specific_size_t = decltype(λ{ if constexpr(size==sizeof(int8_t)) return(int8_t) 0
template<size_t size>
using	signed_specific_size_fast_t = decltype(λ{ if constexpr(size<=sizeof(int_fast8_t)) return(int_fast8_t) 0
template<basic_float_type T>
using	float_precision_base_t = decltype(get_precision_base< T >())
template<basic_float_type T>
using	float_exponent_t = signed_specific_size_fast_t< sizeof(float_infos::exponent_type< T >)+1 >

函数
constexpr bool	is_rounding_bit (bit_type v) noexcept
template<class T >
constexpr bool	is_elc_expansion_base_type_helper () noexcept
else if	constexpr (size==sizeof(uint16_t)) return(uint16_t) 0
else if	constexpr (size<=sizeof(uint_fast16_t)) return(uint_fast16_t) 0
else if	constexpr (size<=sizeof(uint_fast32_t)) return(uint_fast32_t) 0
else if	constexpr (size<=sizeof(uint_fast64_t)) return(uint_fast64_t) 0
else if	constexpr (size<=sizeof(int_fast16_t)) return(int_fast16_t) 0
else if	constexpr (size<=sizeof(int_fast32_t)) return(int_fast32_t) 0
else if	constexpr (size<=sizeof(int_fast64_t)) return(int_fast64_t) 0
template<unsigned_basic_integer_type T>
constexpr bool	add_carry (T a, T b, T &c) noexcept
template<unsigned_basic_integer_type T>
constexpr T	add_carry (T a, T b, bool &is_overflow) noexcept
template<unsigned_basic_integer_type T>
constexpr T	add_carry (T a, bool &is_overflow) noexcept
template<unsigned_basic_integer_type T>
constexpr bool	sub_borrow (T a, T b, T &c) noexcept
template<unsigned_basic_integer_type T>
constexpr T	sub_borrow (T a, T b, bool &is_underflow) noexcept
template<unsigned_basic_integer_type T>
constexpr T	sub_borrow (T a, bool &is_underflow) noexcept
template<basic_float_type T>
constexpr auto	get_native_precision (T v) noexcept
template<basic_float_type T>
constexpr auto	get_precision_base (T=T{}) noexcept
template<basic_float_type T>
constexpr auto	base_get_exponent (T v) noexcept
template<basic_float_type T>
constexpr float_infos::exponent_type< T >	get_native_exponent (T v) noexcept
template<basic_float_type T>
constexpr float_precision_base_t< T >	get_base_num (T v) noexcept
template<basic_float_type T>
constexpr float_precision_base_t< T >	get_precision (T v) noexcept
template<basic_float_type T>
constexpr float_exponent_t< T >	get_exponent (T v) noexcept
template<basic_float_type T>
constexpr auto	get_precision_and_exponent (T v) noexcept
template<basic_float_type T>
constexpr T	make_float (float_precision_base_t< T > base_num, float_exponent_t< T > exponent) noexcept

变量
constexpr size_t	BIT_POSSIBILITY =1<<1
	每个bit（不是字节）的可能性 为什么c艹委员会不定义这个？
	else
constexpr class elc::defs::basic_environment::to_arithmetic_t	to_arithmetic
constexpr bool	wchar_t_same_as_char_t =sizeof(wchar_t)==sizeof(char_t)
constexpr bool	wchar_t_same_as_char16_t =sizeof(wchar_t)==sizeof(char16_t)
template<basic_float_type T>
constexpr auto	threshold_precision_bit =float_infos::precision_base_bit<T>+1

类型定义说明

basic_intmax_t

typedef ::std::intmax_t elc::defs::basic_environment::basic_intmax_t

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

basic_uintmax_t

typedef ::std::uintmax_t elc::defs::basic_environment::basic_uintmax_t

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

bit_type

typedef bool elc::defs::basic_environment::bit_type

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

float_exponent_t

template<basic_float_type T>

using elc::defs::basic_environment::float_exponent_t = typedef signed_specific_size_fast_t<sizeof(float_infos::exponent_type<T>)+1>

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

float_precision_base_t

template<basic_float_type T>

using elc::defs::basic_environment::float_precision_base_t = typedef decltype(get_precision_base<T>())

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

intmax_index_t

typedef basic_intmax_t elc::defs::basic_environment::intmax_index_t

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

intmax_t

typedef decltype(λ{ return basic_intmax_t{}; }()) elc::defs::basic_environment::intmax_t

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

signed_specific_size_fast_t

template<size_t size>

using elc::defs::basic_environment::signed_specific_size_fast_t = typedef decltype(λ{ if constexpr(size <= sizeof( int_fast8_t ))return ( int_fast8_t )0

至少有给定大小的快速有符号整数类型

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

signed_specific_size_t

template<size_t size>

using elc::defs::basic_environment::signed_specific_size_t = typedef decltype(λ{ if constexpr(size == sizeof( int8_t ))return ( int8_t )0

给定大小的有符号整数类型

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

uintmax_index_t

typedef basic_uintmax_t elc::defs::basic_environment::uintmax_index_t

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

uintmax_t

typedef decltype(λ{ return basic_uintmax_t{}; }()) elc::defs::basic_environment::uintmax_t

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

unsigned_specific_size_fast_t

template<size_t size>

using elc::defs::basic_environment::unsigned_specific_size_fast_t = typedef decltype(λ{ if constexpr(size <= sizeof( uint_fast8_t ))return ( uint_fast8_t )0

至少有给定大小的快速无符号整数类型

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

unsigned_specific_size_t

template<size_t size>

using elc::defs::basic_environment::unsigned_specific_size_t = typedef decltype(λ{ if constexpr(size == sizeof( uint8_t ))return ( uint8_t )0

给定大小的无符号整数类型

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

函数说明

add_carry() [1/3]

template<unsigned_basic_integer_type T>

constexpr T elc::defs::basic_environment::add_carry ( T  a, bool &  is_overflow  )

inlineconstexprnoexcept

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

                                                                  {
    #if HAS_MSVC_INTRINSICS
        if(!in_consteval){
            T c;is_overflow=_msvc_builtin_add_carry(is_overflow, a, T{}, &c);
            return c;
        }
        else
    #endif
    {
        T c=a+is_overflow;
        if(c)//若c为0，保持is_overflow不变（原理见上）
            is_overflow=false;
        return c;
    }
}

函数调用图:

add_carry() [2/3]

template<unsigned_basic_integer_type T>

constexpr T elc::defs::basic_environment::add_carry ( T  a, T  b, bool &  is_overflow  )

inlineconstexprnoexcept

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

                                                                       {
    #if HAS_MSVC_INTRINSICS
        if(!in_consteval){
            T c;is_overflow=_msvc_builtin_add_carry(is_overflow, a, b, &c);
            return c;
        }
        else
    #endif
    {
        T c=a+is_overflow;
        if(c){
            is_overflow=add_carry(c,b,c);
            return c;
        }
        else{
            //现在我们得知a+is_overflow的结果为0:
            //若is_overflow为true，溢出确实发生了，我们需要将is_overflow设置为true，所以什么都不用管
            //若is_overflow为false，溢出没有发生，我们需要将is_overflow设置为false，我们仍然什么都不用管
            return b;
        }
    }
}

函数调用图:

add_carry() [3/3]

template<unsigned_basic_integer_type T>

constexpr bool elc::defs::basic_environment::add_carry ( T  a, T  b, T &  c  )

inlineconstexprnoexcept

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

                                                             {
    if(!in_consteval){
        #if HAS_GCC_BUILTINS
            return __builtin_add_overflow(a, b, &c);
        #elif HAS_MSVC_INTRINSICS
            return _msvc_builtin_add_carry(0, a, b, &c);
        #elif HAS_X86_ASM
            //x86/x86-64
            __asm__ (
                "add %2, %1\n\t"
                "setc %0\n\t"
                : "=r"(c)
                : "r"(a), "r"(b)
            );
            return c;
        #elif HAS_ARM_ASM || HAS_ARM64_ASM
            //arm/arm64
            __asm__ (
                "adds %1, %1, %2\n\t"
                "adc %0, xzr, xzr\n\t"
                : "=r"(c)
                : "r"(a), "r"(b)
            );
            return c;
        #endif
    }
    c = a + b;
    return c < a;
}

函数调用图:

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

base_get_exponent()

template<basic_float_type T>

constexpr auto elc::defs::basic_environment::base_get_exponent ( T  v )

inlineconstexprnoexcept

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

                                                                  {
            using namespace float_infos;
            auto tmp=get_float_data(v);
            tmp&=exponent_mask<T>;
            tmp>>=precision_base_bit<T>;
            return exponent_unsigned_type<T>(tmp);
        }

函数调用图:

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

constexpr() [1/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofint_fast16_t

)

constexpr() [2/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofint_fast32_t

)

constexpr() [3/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofint_fast64_t

)

constexpr() [4/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofuint_fast16_t

)

constexpr() [5/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofuint_fast32_t

)

constexpr() [6/7]

else if elc::defs::basic_environment::constexpr

(

size<=

sizeofuint_fast64_t

)

constexpr() [7/7]

else if elc::defs::basic_environment::constexpr

(

size

= =sizeof(uint16_t)

)

get_base_num()

template<basic_float_type T>

constexpr float_precision_base_t< T > elc::defs::basic_environment::get_base_num ( T  v )

inlineconstexprnoexcept

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

                                                                                  {
            //特殊情况处理（exp=0时，base=0）
            const auto tmp=base_get_exponent(v);
            return tmp?get_precision_base(v):float_precision_base_t<T>{};
        }

函数调用图:

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

get_exponent()

template<basic_float_type T>

constexpr float_exponent_t< T > elc::defs::basic_environment::get_exponent ( T  v )

inlineconstexprnoexcept

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

                                                                            {
            using namespace float_infos;
            return float_exponent_t<T>(get_native_exponent(v)) - precision_base_bit<T>;
        }

函数调用图:

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

get_native_exponent()

template<basic_float_type T>

constexpr float_infos::exponent_type< T > elc::defs::basic_environment::get_native_exponent ( T  v )

inlineconstexprnoexcept

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

                                                                                           {
            const auto tmp=base_get_exponent(v);
            using namespace float_infos;
            if(tmp==0)return exponent_min<T>;
            else return exponent_type<T>(tmp)-exponent_diff<T>;
        }

函数调用图:

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

get_native_precision()

template<basic_float_type T>

constexpr auto elc::defs::basic_environment::get_native_precision ( T  v )

inlineconstexprnoexcept

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

                                                                     {
            using namespace float_infos;
            auto tmp=get_float_data(v);
            tmp&=precision_mask<T>;
            return tmp;
        }

函数调用图:

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

get_precision()

template<basic_float_type T>

constexpr float_precision_base_t< T > elc::defs::basic_environment::get_precision ( T  v )

inlineconstexprnoexcept

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

                                                                                   {
            return get_native_precision(v)+get_base_num(v);
        }

函数调用图:

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

get_precision_and_exponent()

template<basic_float_type T>

constexpr auto elc::defs::basic_environment::get_precision_and_exponent ( T  v )

inlineconstexprnoexcept

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

                                                                           {
            struct precision_and_exponent_t{
                float_precision_base_t<T> precision;
                float_exponent_t<T>       exponent;
            };
            const auto precision=get_precision(v);
            const auto exponent=get_exponent(v);
            return precision_and_exponent_t{precision,exponent};
        }

函数调用图:

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

get_precision_base()

template<basic_float_type T>

constexpr auto elc::defs::basic_environment::get_precision_base ( T  = T{} )

inlineconstexprnoexcept

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

                                                          {})noexcept{
            return float_infos::precision_base<T>;
        }

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

is_elc_expansion_base_type_helper()

template<class T >

constexpr bool elc::defs::basic_environment::is_elc_expansion_base_type_helper ( )

inlineconstexprnoexcept

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

                                                                         {
            #if defined(ELC_BASE_ENV_HAS_INT128)
            if constexpr(sizeof(basic_uintmax_t) < sizeof(uint128_t) && type_info<T> == type_info<uint128_t>)
                return true;
            if constexpr(sizeof(basic_intmax_t) < sizeof(int128_t) && type_info<T> == type_info<int128_t>)
                return true;
            #endif
            return false;
        }

函数调用图:

is_rounding_bit()

constexpr bool elc::defs::basic_environment::is_rounding_bit ( bit_type  v )

inlineconstexprnoexcept

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

                                                                                    {
            if constexpr(BIT_POSSIBILITY==2)
                return v;
            else{
                push_and_disable_msvc_warning(4804);//？
                return v>=BIT_POSSIBILITY/2;
                pop_msvc_warning();
            }
        }

函数调用图:

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

make_float()

template<basic_float_type T>

constexpr T elc::defs::basic_environment::make_float ( float_precision_base_t< T >  base_num, float_exponent_t< T >  exponent  )

inlineconstexprnoexcept

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

                                                                                                                    {
            using namespace float_infos;
            //首先将基数转换为precision_base（2^precision_base_bit）为分母的分数的分子
            //并在此过程中加减指数
            //需要注意的是，这里的基数是包含1的，所以转换目标是base_num>>precision_base_bit为1
            {
                const auto tmp=countl_zero(base_num);
                constexpr auto need_shift=bitnum_of(base_num)-threshold_precision_bit<T>;
                const float_exponent_t<T> shift=float_exponent_t<T>(tmp)-need_shift;
                if(shift>0){
                    base_num<<=shift;
                    exponent-=shift;
                }
                elseif(shift<0){
                    base_num>>=-shift;
                    exponent-=shift;
                }
            }
            //适当放缩后，需要偏移指数部分，原因如下：
            //原有逻辑是num=base_num*2^exponent，这是大分数的表达逻辑
            //但是浮点数的逻辑是num=(base_num/precision_base)*2^exponent
            //将precision_base合并到exponent中，即可得到浮点数的逻辑
            exponent+=precision_base_bit<T>;
            if(exponent < exponent_min<T>){//指数过小，需要舍去
                const auto diff=exponent_min<T> - exponent;
                base_num>>=diff;
                exponent+=diff;
                if(!base_num)return 0;//基数过小，无法表示
            }
            if(exponent>exponent_max<T>)return 0;//指数过大，无法表示
            //DEN情况判断
            const bool is_den=!(base_num>>precision_base_bit<T>);//若基数最高位为0，则exponent一定为exponent_min，不用判断
            if(is_den)
                return get_float_from_data<T>(base_num);
            else{//非DEN情况下，根据浮点数表示规则去掉基数多余的1
                const auto exp=exponent_unsigned_type<T>(exponent+exponent_diff<T>);
                base_num-=get_precision_base<T>();
                data_type<T> data=base_num;
                data|=data_type<T>(exp)<<precision_base_bit<T>;
                return get_float_from_data<T>(data);
            }
        }

函数调用图:

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

sub_borrow() [1/3]

template<unsigned_basic_integer_type T>

constexpr T elc::defs::basic_environment::sub_borrow ( T  a, bool &  is_underflow  )

inlineconstexprnoexcept

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

                                                                    {
    #if HAS_MSVC_INTRINSICS
        if(!in_consteval){
            T c;is_underflow=_msvc_builtin_sub_borrow(is_underflow, a, T{}, &c);
            return c;
        }
        else
    #endif
    {
        if(is_underflow){
            is_underflow=!a;
            return a-1;
        }
        else
            return a;
    }
}

函数调用图:

sub_borrow() [2/3]

template<unsigned_basic_integer_type T>

constexpr T elc::defs::basic_environment::sub_borrow ( T  a, T  b, bool &  is_underflow  )

inlineconstexprnoexcept

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

                                                                         {
    #if HAS_MSVC_INTRINSICS
        if(!in_consteval){
            T c;is_underflow=_msvc_builtin_sub_borrow(is_underflow, a, b, &c);
            return c;
        }
        else
    #endif
    {
        T c=b+is_underflow;
        if(c){
            is_underflow=sub_borrow(a,c,c);
            return c;
        }
        else{
            //现在我们得知b+is_underflow的结果为0:
            //若is_underflow为true，溢出肯定该发生，我们需要将is_underflow设置为true，所以什么都不用管
            //若is_underflow为false，溢出不会发生，我们需要将is_underflow设置为false，我们仍然什么都不用管
            return a;
        }
    }
}

函数调用图:

sub_borrow() [3/3]

template<unsigned_basic_integer_type T>

constexpr bool elc::defs::basic_environment::sub_borrow ( T  a, T  b, T &  c  )

inlineconstexprnoexcept

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

                                                              {
    if(!in_consteval){
        #if HAS_GCC_BUILTINS
            return __builtin_sub_overflow(a, b, &c);
        #elif HAS_MSVC_INTRINSICS
            return _msvc_builtin_sub_borrow(0, a, b, &c);
        #elif HAS_X86_ASM
            //x86/x86-64
            __asm__ (
                "sub %2, %1\n\t"
                "setc %0\n\t"
                : "=r"(c)
                : "r"(a), "r"(b)
            );
            return c;
        #elif HAS_ARM_ASM || HAS_ARM64_ASM
            //arm/arm64
            __asm__ (
                "subs %1, %1, %2\n\t"
                "sbc %0, xzr, xzr\n\t"
                : "=r"(c)
                : "r"(a), "r"(b)
            );
            return c;
        #endif
    }
    c = a - b;
    return c > a;
}

函数调用图:

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

变量说明

BIT_POSSIBILITY

constexpr size_t elc::defs::basic_environment::BIT_POSSIBILITY =1<<1

constexpr

每个bit（不是字节）的可能性 为什么c艹委员会不定义这个？

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

else

elc::defs::basic_environment::else

初始值:

{}
        }())

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

            {}
        }());

threshold_precision_bit

template<basic_float_type T>

constexpr auto elc::defs::basic_environment::threshold_precision_bit =float_infos::precision_base_bit<T>+1

constexpr

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

to_arithmetic

constexpr class elc::defs::basic_environment::to_arithmetic_t elc::defs::basic_environment::to_arithmetic

wchar_t_same_as_char16_t

constexpr bool elc::defs::basic_environment::wchar_t_same_as_char16_t =sizeof(wchar_t)==sizeof(char16_t)

inlineconstexpr

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

wchar_t_same_as_char_t

constexpr bool elc::defs::basic_environment::wchar_t_same_as_char_t =sizeof(wchar_t)==sizeof(char_t)

inlineconstexpr

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