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

类
class	rot_iterator

函数
template<unsigned_basic_integer_type T>
constexpr size_t	countl_zero (const T v) noexcept
	countl_zero
template<unsigned_basic_integer_type T>
constexpr size_t	countr_zero (const T v) noexcept
	countr_zero
template<unsigned_basic_integer_type T>
constexpr size_t	countl_one (const T v) noexcept
	countl_one
template<unsigned_basic_integer_type T>
constexpr size_t	countr_one (const T v) noexcept
	countr_one
template<unsigned_basic_integer_type T>
constexpr size_t	get_bitnum (const T v) noexcept
	获取位数
template<unsigned_basic_integer_type T>
constexpr auto	rotl_nomod (const T v, const auto R) noexcept
	位操作：循环左移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotr_nomod (const T v, const auto r) noexcept
	位操作：循环右移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotr (const T v, const auto R) noexcept
	位操作：循环右移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotl (const T v, const auto R) noexcept
	位操作：循环左移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotl_nomod (const T v, const rot_iterator< T > &r) noexcept
	位操作：循环左移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotr_nomod (const T v, const rot_iterator< T > &r) noexcept
	位操作：循环右移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotl (const T v, const rot_iterator< T > &r) noexcept
	位操作：循环左移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr auto	rotr (const T v, const rot_iterator< T > &r) noexcept
	位操作：循环右移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼
template<unsigned_basic_integer_type T>
constexpr bool	all_bit_is_one (const T v) noexcept
	is_all_bit_one
template<unsigned_basic_integer_type T>
constexpr bool	all_bit_is_zero (const T v) noexcept
	is_all_bit_zero

变量
template<unsigned_basic_integer_type T>
constexpr T	npos_of =T(-1)
	用以指定不存在的位置
constexpr auto	npos =npos_of<size_t>

函数说明

all_bit_is_one()

template<unsigned_basic_integer_type T>

constexpr bool elc::defs::base::bit::all_bit_is_one ( const T  v )

inlineconstexprnoexcept

is_all_bit_one

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

                                                                              {
        return v==npos_of<T>;
    }

函数调用图:

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

all_bit_is_zero()

template<unsigned_basic_integer_type T>

constexpr bool elc::defs::base::bit::all_bit_is_zero ( const T  v )

inlineconstexprnoexcept

is_all_bit_zero

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

                                                                               {
        return v;
    }

函数调用图:

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

countl_one()

template<unsigned_basic_integer_type T>

constexpr size_t elc::defs::base::bit::countl_one ( const T  v )

inlineconstexprnoexcept

countl_one

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

                                                                            {
        if constexpr(sizeof(T)!=1){//优化
            typedef unsigned_specific_size_t<sizeof(T)/2> half_t;
            constexpr size_t half_bitnum = bitnum_of(half_t);
            const half_t high = half_t(v>>half_bitnum);
            if(high == half_t(-1))
                return half_bitnum+countl_one(half_t(v));
            else
                return countl_one(high);
        }
        else{
            //默认通用实现
            //return countl_zero(T(~v));，或者
            constexpr T first_bit = T(1)<<(bitnum_of(T)-1);
            return v&first_bit?countl_one(T(v<<1))+1:0;
        }
    }

函数调用图:

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

countl_zero()

template<unsigned_basic_integer_type T>

constexpr size_t elc::defs::base::bit::countl_zero ( const T  v )

inlineconstexprnoexcept

countl_zero

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

                                                                             {
        if constexpr(sizeof(T)!=1){//优化
            typedef unsigned_specific_size_t<sizeof(T)/2> half_t;
            constexpr size_t half_bitnum = bitnum_of(half_t);
            const half_t high = half_t(v>>half_bitnum);
            if(high)
                return countl_zero(high);
            else
                return half_bitnum+countl_zero(half_t(v));
        }
        else
            //默认通用实现
            return bitnum_of(T)-get_bitnum(v);
    }

函数调用图:

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

countr_one()

template<unsigned_basic_integer_type T>

constexpr size_t elc::defs::base::bit::countr_one ( const T  v )

inlineconstexprnoexcept

countr_one

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

                                                                            {
        if constexpr(sizeof(T)!=1){//优化
            typedef unsigned_specific_size_t<sizeof(T)/2> half_t;
            constexpr size_t half_bitnum = bitnum_of(half_t);
            const half_t low = half_t(v);
            if(low == half_t(-1))
                return half_bitnum+countr_one(half_t(v>>half_bitnum));
            else
                return countr_one(low);
        }
        else
            //默认通用实现
            return v&1?countr_one(T(v>>1))+1:0;
    }

函数调用图:

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

countr_zero()

template<unsigned_basic_integer_type T>

constexpr size_t elc::defs::base::bit::countr_zero ( const T  v )

inlineconstexprnoexcept

countr_zero

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

                                                                             {
        if constexpr(sizeof(T)!=1){//优化
            typedef unsigned_specific_size_t<sizeof(T)/2> half_t;
            constexpr size_t half_bitnum = bitnum_of(half_t);
            const half_t low = half_t(v);
            if(low)
                return countr_zero(low);
            else
                return half_bitnum+countr_zero(half_t(v>>half_bitnum));
        }
        else
            //默认通用实现
            return countr_one(T(~v));
    }

函数调用图:

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

get_bitnum()

template<unsigned_basic_integer_type T>

constexpr size_t elc::defs::base::bit::get_bitnum ( const T  v )

inlineconstexprnoexcept

获取位数

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

                                                                            {
        if constexpr(sizeof(T)!=1){//优化
            typedef unsigned_specific_size_t<sizeof(T)/2> half_t;
            constexpr size_t half_bitnum = bitnum_of(half_t);
            const half_t high = half_t(v>>half_bitnum);
            if(high)
                return half_bitnum+get_bitnum(high);
            else
                return get_bitnum(half_t(v));
        }
        else
            //默认通用实现
            return v?get_bitnum(T(v>>1))+1:0;
    }

函数调用图:

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

rotl() [1/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotl ( const T  v, const auto  R  )

inlineconstexprnoexcept

位操作：循环左移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                 {
        constexpr auto d = ::std::numeric_limits<T>::digits;
        const auto r = mod(R,d);
        return rotl_nomod(v,r);
    }

函数调用图:

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

rotl() [2/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotl ( const T  v, const rot_iterator< T > &  r  )

inlineconstexprnoexcept

位操作：循环左移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                            {
        return rotl_nomod(v,r);
    }

函数调用图:

rotl_nomod() [1/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotl_nomod ( const T  v, const auto  R  )

inlineconstexprnoexcept

位操作：循环左移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                       {
        constexpr auto d = ::std::numeric_limits<T>::digits;
        if constexpr(unsigned_type<decltype(r)>){
            if(r)
                return rot_base(<<,>>);
            else
                return v;
        }
        else{
            if(r>0)
                return rot_base(<<,>>);
            elseif(r==0)
                return v;
            else//r<0
                return rotr_nomod(v,0-r);
        }
    }

函数调用图:

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

rotl_nomod() [2/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotl_nomod ( const T  v, const rot_iterator< T > &  r  )

inlineconstexprnoexcept

位操作：循环左移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                                  {
        return rotl_nomod(v,r.value());
    }

函数调用图:

rotr() [1/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotr ( const T  v, const auto  R  )

inlineconstexprnoexcept

位操作：循环右移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                 {
        constexpr auto d = ::std::numeric_limits<T>::digits;
        const auto r = mod(R,d);
        return rotr_nomod(v,r);
    }

函数调用图:

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

rotr() [2/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotr ( const T  v, const rot_iterator< T > &  r  )

inlineconstexprnoexcept

位操作：循环右移 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                            {
        return rotr_nomod(v,r);
    }

函数调用图:

rotr_nomod() [1/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotr_nomod ( const T  v, const auto  r  )

inlineconstexprnoexcept

位操作：循环右移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                       {
        constexpr auto d = ::std::numeric_limits<T>::digits;
        if constexpr(unsigned_type<decltype(r)>){
            if(r)
                return rot_base(>>,<<);
            else
                return v;
        }
        else{
            if(r>0)
                return rot_base(>>,<<);
            elseif(r==0)
                return v;
            else//r<0
                return rotl_nomod(v,0-r);
        }
    }

函数调用图:

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

rotr_nomod() [2/2]

template<unsigned_basic_integer_type T>

constexpr auto elc::defs::base::bit::rotr_nomod ( const T  v, const rot_iterator< T > &  r  )

inlineconstexprnoexcept

位操作：循环右移（无mod） 不使用std版本而是自己写的原因：std版本右操作数只能是int而不能是size_t或别的，标准会傻逼

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

                                                                                                  {
        return rotr_nomod(v,r.value());
    }

函数调用图:

变量说明

npos

constexpr auto elc::defs::base::bit::npos =npos_of<size_t>

constexpr

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

npos_of

template<unsigned_basic_integer_type T>

constexpr T elc::defs::base::bit::npos_of =T(-1)

constexpr

用以指定不存在的位置

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