fast_float::bigint Struct Reference

#include <fast_float.h>

Collaboration diagram for fast_float::bigint:

Public Member Functions
	bigint ()
	bigint (const bigint &)=delete
bigint &	operator= (const bigint &)=delete
	bigint (bigint &&)=delete
bigint &	operator= (bigint &&other)=delete
	bigint (uint64_t value)
uint64_t	hi64 (bool &truncated) const noexcept
int	compare (const bigint &other) const noexcept
bool	shl_bits (size_t n) noexcept
bool	shl_limbs (size_t n) noexcept
bool	shl (size_t n) noexcept
int	ctlz () const noexcept
int	bit_length () const noexcept
bool	mul (limb y) noexcept
bool	add (limb y) noexcept
bool	pow2 (uint32_t exp) noexcept
bool	pow5 (uint32_t exp) noexcept
bool	pow10 (uint32_t exp) noexcept

Public Attributes
stackvec< bigint_limbs >	vec

Detailed Description

Definition at line 1959 of file fast_float.h.

Constructor & Destructor Documentation

bigint() [1/4]

fast_float::bigint::bigint ( )

inline

Definition at line 1963 of file fast_float.h.

: vec() {}

bigint() [2/4]

fast_float::bigint::bigint ( const bigint &  )

delete

bigint() [3/4]

fast_float::bigint::bigint ( bigint &&  )

delete

bigint() [4/4]

fast_float::bigint::bigint ( uint64_t  value )

inline

Definition at line 1969 of file fast_float.h.

                        : vec() {
#ifdef FASTFLOAT_64BIT_LIMB
    vec.push_unchecked(value);
#else
    vec.push_unchecked(uint32_t(value));
    vec.push_unchecked(uint32_t(value >> 32));
#endif
    vec.normalize();
  }

References fast_float::stackvec< size >::normalize(), fast_float::stackvec< size >::push_unchecked(), and vec.

Here is the call graph for this function:

Member Function Documentation

add()

bool fast_float::bigint::add ( limb  y )

inlinenoexcept

Definition at line 2118 of file fast_float.h.

                            {
    return small_add(vec, y);
  }

References fast_float::small_add(), and vec.

Here is the call graph for this function:

bit_length()

int fast_float::bigint::bit_length ( ) const

inlinenoexcept

Definition at line 2109 of file fast_float.h.

                                  {
    int lz = ctlz();
    return int(limb_bits * vec.len()) - lz;
  }

References ctlz(), fast_float::stackvec< size >::len(), fast_float::limb_bits, and vec.

Here is the call graph for this function:

compare()

int fast_float::bigint::compare ( const bigint &  other ) const

inlinenoexcept

Definition at line 2013 of file fast_float.h.

                                                  {
    if (vec.len() > other.vec.len()) {
      return 1;
    } else if (vec.len() < other.vec.len()) {
      return -1;
    } else {
      for (size_t index = vec.len(); index > 0; index--) {
        limb xi = vec[index - 1];
        limb yi = other.vec[index - 1];
        if (xi > yi) {
          return 1;
        } else if (xi < yi) {
          return -1;
        }
      }
      return 0;
    }
  }

References fast_float::stackvec< size >::len(), and vec.

Referenced by fast_float::negative_digit_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

ctlz()

int fast_float::bigint::ctlz ( ) const

inlinenoexcept

Definition at line 2094 of file fast_float.h.

                            {
    if (vec.is_empty()) {
      return 0;
    } else {
#ifdef FASTFLOAT_64BIT_LIMB
      return leading_zeroes(vec.rindex(0));
#else
      // no use defining a specialized leading_zeroes for a 32-bit type.
      uint64_t r0 = vec.rindex(0);
      return leading_zeroes(r0 << 32);
#endif
    }
  }

References fast_float::stackvec< size >::is_empty(), fast_float::leading_zeroes(), fast_float::stackvec< size >::rindex(), and vec.

Referenced by bit_length().

Here is the call graph for this function:

Here is the caller graph for this function:

hi64()

uint64_t fast_float::bigint::hi64 ( bool &  truncated ) const

inlinenoexcept

Definition at line 1981 of file fast_float.h.

                                                {
#ifdef FASTFLOAT_64BIT_LIMB
    if (vec.len() == 0) {
      return empty_hi64(truncated);
    } else if (vec.len() == 1) {
      return uint64_hi64(vec.rindex(0), truncated);
    } else {
      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
      truncated |= vec.nonzero(2);
      return result;
    }
#else
    if (vec.len() == 0) {
      return empty_hi64(truncated);
    } else if (vec.len() == 1) {
      return uint32_hi64(vec.rindex(0), truncated);
    } else if (vec.len() == 2) {
      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
    } else {
      uint64_t result = uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
      truncated |= vec.nonzero(3);
      return result;
    }
#endif
  }

References fast_float::empty_hi64(), fast_float::stackvec< size >::len(), fast_float::stackvec< size >::nonzero(), fast_float::stackvec< size >::rindex(), fast_float::uint32_hi64(), fast_float::uint64_hi64(), and vec.

Here is the call graph for this function:

mul()

bool fast_float::bigint::mul ( limb  y )

inlinenoexcept

Definition at line 2114 of file fast_float.h.

                            {
    return small_mul(vec, y);
  }

References fast_float::small_mul(), and vec.

Here is the call graph for this function:

operator=() [1/2]

bigint & fast_float::bigint::operator= ( bigint &&  other )

delete

operator=() [2/2]

bigint & fast_float::bigint::operator= ( const bigint &  )

delete

pow10()

bool fast_float::bigint::pow10 ( uint32_t  exp )

inlinenoexcept

Definition at line 2173 of file fast_float.h.

                                    {
    FASTFLOAT_TRY(pow5(exp));
    return pow2(exp);
  }

References FASTFLOAT_TRY, pow2(), and pow5().

Here is the call graph for this function:

pow2()

bool fast_float::bigint::pow2 ( uint32_t  exp )

inlinenoexcept

Definition at line 2123 of file fast_float.h.

                                   {
    return shl(exp);
  }

References shl().

Referenced by fast_float::negative_digit_comp(), and pow10().

Here is the call graph for this function:

Here is the caller graph for this function:

pow5()

bool fast_float::bigint::pow5 ( uint32_t  exp )

inlinenoexcept

Definition at line 2128 of file fast_float.h.

                                   {
    // multiply by a power of 5
    static constexpr uint32_t large_step = 135;
    static constexpr uint64_t small_power_of_5[] = {
      1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
      1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
      6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
      3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
      2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
      298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
    };
#ifdef FASTFLOAT_64BIT_LIMB
    constexpr static limb large_power_of_5[] = {
      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
      10482974169319127550UL, 198276706040285095UL};
#else
    constexpr static limb large_power_of_5[] = {
      4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
      1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
#endif
    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
    limb_span large = limb_span(large_power_of_5, large_length);
    while (exp >= large_step) {
      FASTFLOAT_TRY(large_mul(vec, large));
      exp -= large_step;
    }
#ifdef FASTFLOAT_64BIT_LIMB
    uint32_t small_step = 27;
    limb max_native = 7450580596923828125UL;
#else
    uint32_t small_step = 13;
    limb max_native = 1220703125U;
#endif
    while (exp >= small_step) {
      FASTFLOAT_TRY(small_mul(vec, max_native));
      exp -= small_step;
    }
    if (exp != 0) {
      FASTFLOAT_TRY(small_mul(vec, limb(small_power_of_5[exp])));
    }
 
    return true;
  }

References FASTFLOAT_TRY, fast_float::large_mul(), fast_float::small_mul(), and vec.

Referenced by fast_float::negative_digit_comp(), and pow10().

Here is the call graph for this function:

Here is the caller graph for this function:

shl()

bool fast_float::bigint::shl ( size_t  n )

inlinenoexcept

Definition at line 2081 of file fast_float.h.

                              {
    size_t rem = n % limb_bits;
    size_t div = n / limb_bits;
    if (rem != 0) {
      FASTFLOAT_TRY(shl_bits(rem));
    }
    if (div != 0) {
      FASTFLOAT_TRY(shl_limbs(div));
    }
    return true;
  }

References FASTFLOAT_TRY, fast_float::limb_bits, shl_bits(), and shl_limbs().

Referenced by pow2(), and shl_bits().

Here is the call graph for this function:

Here is the caller graph for this function:

shl_bits()

bool fast_float::bigint::shl_bits ( size_t  n )

inlinenoexcept

Definition at line 2034 of file fast_float.h.

                                   {
    // Internally, for each item, we shift left by n, and add the previous
    // right shifted limb-bits.
    // For example, we transform (for u8) shifted left 2, to:
    //      b10100100 b01000010
    //      b10 b10010001 b00001000
    FASTFLOAT_DEBUG_ASSERT(n != 0);
    FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
 
    size_t shl = n;
    size_t shr = limb_bits - shl;
    limb prev = 0;
    for (size_t index = 0; index < vec.len(); index++) {
      limb xi = vec[index];
      vec[index] = (xi << shl) | (prev >> shr);
      prev = xi;
    }
 
    limb carry = prev >> shr;
    if (carry != 0) {
      return vec.try_push(carry);
    }
    return true;
  }

References FASTFLOAT_DEBUG_ASSERT, fast_float::stackvec< size >::len(), fast_float::limb_bits, shl(), fast_float::stackvec< size >::try_push(), and vec.

Referenced by shl().

Here is the call graph for this function:

Here is the caller graph for this function:

shl_limbs()

bool fast_float::bigint::shl_limbs ( size_t  n )

inlinenoexcept

Definition at line 2060 of file fast_float.h.

                                    {
    FASTFLOAT_DEBUG_ASSERT(n != 0);
    if (n + vec.len() > vec.capacity()) {
      return false;
    } else if (!vec.is_empty()) {
      // move limbs
      limb* dst = vec.data + n;
      const limb* src = vec.data;
      ::memmove(dst, src, sizeof(limb) * vec.len());
      // fill in empty limbs
      limb* first = vec.data;
      limb* last = first + n;
      ::std::fill(first, last, 0);
      vec.set_len(n + vec.len());
      return true;
    } else {
      return true;
    }
  }

References fast_float::stackvec< size >::capacity(), fast_float::stackvec< size >::data, FASTFLOAT_DEBUG_ASSERT, fast_float::stackvec< size >::is_empty(), fast_float::stackvec< size >::len(), fast_float::stackvec< size >::set_len(), and vec.

Referenced by shl().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

vec

stackvec<bigint_limbs> fast_float::bigint::vec

Definition at line 1961 of file fast_float.h.

Referenced by add(), bigint(), bit_length(), compare(), ctlz(), hi64(), mul(), pow5(), shl_bits(), and shl_limbs().

---

The documentation for this struct was generated from the following file:

• fast_float.h