Get number of digits

Functions
template<class T>
auto	c4::digits_dec (T v) noexcept -> typename std::enable_if< sizeof(T)==1u, unsigned >::type
	decimal digits for 8 bit integers
template<class T>
auto	c4::digits_dec (T v) noexcept -> typename std::enable_if< sizeof(T)==2u, unsigned >::type
	decimal digits for 16 bit integers
template<class T>
auto	c4::digits_dec (T v) noexcept -> typename std::enable_if< sizeof(T)==4u, unsigned >::type
	decimal digits for 32 bit integers
template<class T>
auto	c4::digits_dec (T v) noexcept -> typename std::enable_if< sizeof(T)==8u, unsigned >::type
	decimal digits for 64 bit integers
template<class T>
unsigned	c4::digits_hex (T v) noexcept
	return the number of digits required to encode an hexadecimal number.
template<class T>
unsigned	c4::digits_bin (T v) noexcept
	return the number of digits required to encode a binary number.
template<class T>
unsigned	c4::digits_oct (T v_) noexcept
	return the number of digits required to encode an octal number.

Detailed Description

Note

At first sight this code may look heavily branchy and therefore inefficient. However, measurements revealed this to be the fastest among the alternatives.

See also

https://github.com/biojppm/c4core/pull/77

Function Documentation

digits_dec() [1/4]

template<class T>

auto c4::digits_dec ( T v ) ->typenamestd::enable_if< sizeof(T)==1u, unsigned >::type

inlinenoexcept

decimal digits for 8 bit integers

Definition at line 433 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    return ((v >= 100) ? 3u : ((v >= 10) ? 2u : 1u));
}

digits_dec() [2/4]

template<class T>

auto c4::digits_dec ( T v ) ->typenamestd::enable_if< sizeof(T)==2u, unsigned >::type

inlinenoexcept

decimal digits for 16 bit integers

Definition at line 444 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    return ((v >= 10000) ? 5u : (v >= 1000) ? 4u : (v >= 100) ? 3u : (v >= 10) ? 2u : 1u);
}

digits_dec() [3/4]

template<class T>

auto c4::digits_dec ( T v ) ->typenamestd::enable_if< sizeof(T)==4u, unsigned >::type

inlinenoexcept

decimal digits for 32 bit integers

Definition at line 455 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    return ((v >= 1000000000) ? 10u : (v >= 100000000) ? 9u : (v >= 10000000) ? 8u :
            (v >= 1000000) ? 7u : (v >= 100000) ? 6u : (v >= 10000) ? 5u :
            (v >= 1000) ? 4u : (v >= 100) ? 3u : (v >= 10) ? 2u : 1u);
}

digits_dec() [4/4]

template<class T>

auto c4::digits_dec ( T v ) ->typenamestd::enable_if< sizeof(T)==8u, unsigned >::type

inlinenoexcept

decimal digits for 64 bit integers

Definition at line 468 of file charconv.hpp.

{
    // thanks @fargies!!!
    // https://github.com/biojppm/c4core/pull/77#issuecomment-1063753568
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    if(v >= 1000000000) // 10
    {
        if(v >= 100000000000000) // 15 [15-20] range
        {
            if(v >= 100000000000000000) // 18 (15 + (20 - 15) / 2)
            {
                if((typename std::make_unsigned<T>::type)v >= 10000000000000000000u) // 20
                    return 20u;
                else
                    return (v >= 1000000000000000000) ? 19u : 18u;
            }
            else if(v >= 10000000000000000) // 17
            {
                return 17u;
            }
            else
            {
                return(v >= 1000000000000000) ? 16u : 15u;
            }
        }
        else if(v >= 1000000000000) // 13
        {
            return (v >= 10000000000000) ? 14u : 13u;
        }
        else if(v >= 100000000000) // 12
        {
            return 12;
        }
        else
        {
            return(v >= 10000000000) ? 11u : 10u;
        }
    }
    else if(v >= 10000) // 5 [5-9] range
    {
        if(v >= 10000000) // 8
            return (v >= 100000000) ? 9u : 8u;
        else if(v >= 1000000) // 7
            return 7;
        else
            return (v >= 100000) ? 6u : 5u;
    }
    else if(v >= 100)
    {
        return (v >= 1000) ? 4u : 3u;
    }
    else
    {
        return (v >= 10) ? 2u : 1u;
    }
}

digits_hex()

template<class T>

unsigned c4::digits_hex ( T v )

inlinenoexcept

return the number of digits required to encode an hexadecimal number.

Definition at line 530 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    return v ? 1u + (msb((typename std::make_unsigned<T>::type)v) >> 2u) : 1u;
}

digits_bin()

template<class T>

unsigned c4::digits_bin ( T v )

inlinenoexcept

return the number of digits required to encode a binary number.

Definition at line 539 of file charconv.hpp.

{
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v >= 0);
    return v ? 1u + msb((typename std::make_unsigned<T>::type)v) : 1u;
}

digits_oct()

template<class T>

unsigned c4::digits_oct ( T v_ )

inlinenoexcept

return the number of digits required to encode an octal number.

Definition at line 548 of file charconv.hpp.

{
    // TODO: is there a better way?
    C4_STATIC_ASSERT(std::is_integral<T>::value);
    C4_ASSERT(v_ >= 0);
    using U = typename std::conditional<sizeof(T) <= sizeof(unsigned),
                                        unsigned,
                                        typename std::make_unsigned<T>::type>::type;
    U v = (U) v_;  // safe because we require v_ >= 0 // NOLINT
    uint32_t __n = 1;
    enum : U {
        __b2 = 64u,
        __b3 = 64u * 8u,
        __b4 = 64u * 8u * 8u,
    };
    while(true)
    {
        if(v < 8u)
            return __n;
        else if(v < __b2)
            return __n + 1;
        else if(v < __b3)
            return __n + 2;
        else if(v < __b4)
            return __n + 3;
        v /= (U) __b4;
        __n += 4;
    }
}