fast_float Namespace Reference

Namespaces
namespace	detail

Classes
struct	adjusted_mantissa
struct	bigint
struct	binary_format
struct	from_chars_result
struct	parse_options
struct	parsed_number_string
struct	powers_template
struct	span
struct	stackvec
struct	value128

Typedefs
typedef span< const char >	byte_span
using	powers = powers_template<>
typedef uint32_t	limb
typedef span< limb >	limb_span

Enumerations
enum	chars_format { scientific = 1<<0 , fixed = 1<<2 , hex = 1<<3 , general = fixed | scientific }

Functions
template<typename T >
from_chars_result	from_chars (const char *first, const char *last, T &value, chars_format fmt=chars_format::general) noexcept
template<typename T >
from_chars_result	from_chars_advanced (const char *first, const char *last, T &value, parse_options options) noexcept
bool	fastfloat_strncasecmp (const char *input1, const char *input2, size_t length)
fastfloat_really_inline int	leading_zeroes (uint64_t input_num)
fastfloat_really_inline value128	full_multiplication (uint64_t a, uint64_t b)
template<typename T >
fastfloat_really_inline void	to_float (bool negative, adjusted_mantissa am, T &value)
fastfloat_really_inline bool	is_integer (char c) noexcept
fastfloat_really_inline uint64_t	byteswap (uint64_t val)
fastfloat_really_inline uint64_t	read_u64 (const char *chars)
fastfloat_really_inline void	write_u64 (uint8_t *chars, uint64_t val)
fastfloat_really_inline uint32_t	parse_eight_digits_unrolled (uint64_t val)
fastfloat_really_inline uint32_t	parse_eight_digits_unrolled (const char *chars) noexcept
fastfloat_really_inline bool	is_made_of_eight_digits_fast (uint64_t val) noexcept
fastfloat_really_inline bool	is_made_of_eight_digits_fast (const char *chars) noexcept
fastfloat_really_inline parsed_number_string	parse_number_string (const char *p, const char *pend, parse_options options) noexcept
template<int bit_precision>
fastfloat_really_inline value128	compute_product_approximation (int64_t q, uint64_t w)
template<typename binary >
fastfloat_really_inline adjusted_mantissa	compute_error_scaled (int64_t q, uint64_t w, int lz) noexcept
template<typename binary >
fastfloat_really_inline adjusted_mantissa	compute_error (int64_t q, uint64_t w) noexcept
template<typename binary >
fastfloat_really_inline adjusted_mantissa	compute_float (int64_t q, uint64_t w) noexcept
fastfloat_really_inline uint64_t	empty_hi64 (bool &truncated) noexcept
fastfloat_really_inline uint64_t	uint64_hi64 (uint64_t r0, bool &truncated) noexcept
fastfloat_really_inline uint64_t	uint64_hi64 (uint64_t r0, uint64_t r1, bool &truncated) noexcept
fastfloat_really_inline uint64_t	uint32_hi64 (uint32_t r0, bool &truncated) noexcept
fastfloat_really_inline uint64_t	uint32_hi64 (uint32_t r0, uint32_t r1, bool &truncated) noexcept
fastfloat_really_inline uint64_t	uint32_hi64 (uint32_t r0, uint32_t r1, uint32_t r2, bool &truncated) noexcept
fastfloat_really_inline limb	scalar_add (limb x, limb y, bool &overflow) noexcept
fastfloat_really_inline limb	scalar_mul (limb x, limb y, limb &carry) noexcept
template<uint16_t size>
bool	small_add_from (stackvec< size > &vec, limb y, size_t start) noexcept
template<uint16_t size>
fastfloat_really_inline bool	small_add (stackvec< size > &vec, limb y) noexcept
template<uint16_t size>
bool	small_mul (stackvec< size > &vec, limb y) noexcept
template<uint16_t size>
bool	large_add_from (stackvec< size > &x, limb_span y, size_t start) noexcept
template<uint16_t size>
fastfloat_really_inline bool	large_add_from (stackvec< size > &x, limb_span y) noexcept
template<uint16_t size>
bool	long_mul (stackvec< size > &x, limb_span y) noexcept
template<uint16_t size>
bool	large_mul (stackvec< size > &x, limb_span y) noexcept
fastfloat_really_inline int32_t	scientific_exponent (parsed_number_string &num) noexcept
template<typename T >
fastfloat_really_inline adjusted_mantissa	to_extended (T value) noexcept
template<typename T >
fastfloat_really_inline adjusted_mantissa	to_extended_halfway (T value) noexcept
template<typename T , typename callback >
fastfloat_really_inline void	round (adjusted_mantissa &am, callback cb) noexcept
template<typename callback >
fastfloat_really_inline void	round_nearest_tie_even (adjusted_mantissa &am, int32_t shift, callback cb) noexcept
fastfloat_really_inline void	round_down (adjusted_mantissa &am, int32_t shift) noexcept
fastfloat_really_inline void	skip_zeros (const char *&first, const char *last) noexcept
fastfloat_really_inline bool	is_truncated (const char *first, const char *last) noexcept
fastfloat_really_inline bool	is_truncated (byte_span s) noexcept
fastfloat_really_inline void	parse_eight_digits (const char *&p, limb &value, size_t &counter, size_t &count) noexcept
fastfloat_really_inline void	parse_one_digit (const char *&p, limb &value, size_t &counter, size_t &count) noexcept
fastfloat_really_inline void	add_native (bigint &big, limb power, limb value) noexcept
fastfloat_really_inline void	round_up_bigint (bigint &big, size_t &count) noexcept
void	parse_mantissa (bigint &result, parsed_number_string &num, size_t max_digits, size_t &digits) noexcept
template<typename T >
adjusted_mantissa	positive_digit_comp (bigint &bigmant, int32_t exponent) noexcept
template<typename T >
adjusted_mantissa	negative_digit_comp (bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept
template<typename T >
adjusted_mantissa	digit_comp (parsed_number_string &num, adjusted_mantissa am) noexcept

Variables
static constexpr int32_t	invalid_am_bias = -0x8000
static constexpr double	powers_of_ten_double []
static constexpr float	powers_of_ten_float []
constexpr size_t	limb_bits = 32
constexpr size_t	bigint_bits = 4000
constexpr size_t	bigint_limbs = bigint_bits / limb_bits
static constexpr uint64_t	powers_of_ten_uint64 []

Typedef Documentation

byte_span

typedef span<const char> fast_float::byte_span

Definition at line 535 of file fast_float.h.

limb

typedef uint32_t fast_float::limb

Definition at line 1616 of file fast_float.h.

limb_span

typedef span<limb> fast_float::limb_span

Definition at line 1620 of file fast_float.h.

powers

using fast_float::powers = typedef powers_template<>

Definition at line 1392 of file fast_float.h.

Enumeration Type Documentation

chars_format

enum fast_float::chars_format

Enumerator
scientific
fixed
hex
general

Definition at line 44 of file fast_float.h.

                  {
    scientific = 1<<0,
    fixed = 1<<2,
    hex = 1<<3,
    general = fixed | scientific
};

Function Documentation

add_native()

fastfloat_really_inline void fast_float::add_native ( bigint &  big, limb  power, limb  value  )

noexcept

Definition at line 2639 of file fast_float.h.

                                                              {
  big.mul(power);
  big.add(value);
}

References fast_float::detail::power().

Referenced by parse_mantissa(), and round_up_bigint().

Here is the call graph for this function:

Here is the caller graph for this function:

byteswap()

fastfloat_really_inline uint64_t fast_float::byteswap

(

uint64_t

val

)

Definition at line 481 of file fast_float.h.

                                                        {
  return (val & 0xFF00000000000000) >> 56
    | (val & 0x00FF000000000000) >> 40
    | (val & 0x0000FF0000000000) >> 24
    | (val & 0x000000FF00000000) >> 8
    | (val & 0x00000000FF000000) << 8
    | (val & 0x0000000000FF0000) << 24
    | (val & 0x000000000000FF00) << 40
    | (val & 0x00000000000000FF) << 56;
}

Referenced by read_u64(), and write_u64().

Here is the caller graph for this function:

compute_error()

template<typename binary >

fastfloat_really_inline adjusted_mantissa fast_float::compute_error ( int64_t  q, uint64_t  w  )

noexcept

Definition at line 1476 of file fast_float.h.

                                                                  {
  int lz = leading_zeroes(w);
  w <<= lz;
  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
  return compute_error_scaled<binary>(q, product.high, lz);
}

References fast_float::value128::high, and leading_zeroes().

Here is the call graph for this function:

compute_error_scaled()

template<typename binary >

fastfloat_really_inline adjusted_mantissa fast_float::compute_error_scaled ( int64_t  q, uint64_t  w, int  lz  )

noexcept

Definition at line 1463 of file fast_float.h.

                                                                                {
  int hilz = int(w >> 63) ^ 1;
  adjusted_mantissa answer;
  answer.mantissa = w << hilz;
  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + invalid_am_bias);
  return answer;
}

References invalid_am_bias, fast_float::adjusted_mantissa::mantissa, fast_float::detail::power(), and fast_float::adjusted_mantissa::power2.

Here is the call graph for this function:

compute_float()

template<typename binary >

fastfloat_really_inline adjusted_mantissa fast_float::compute_float ( int64_t  q, uint64_t  w  )

noexcept

Definition at line 1490 of file fast_float.h.

                                                                  {
  adjusted_mantissa answer;
  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
    answer.power2 = 0;
    answer.mantissa = 0;
    // result should be zero
    return answer;
  }
  if (q > binary::largest_power_of_ten()) {
    // we want to get infinity:
    answer.power2 = binary::infinite_power();
    answer.mantissa = 0;
    return answer;
  }
  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
 
  // We want the most significant bit of i to be 1. Shift if needed.
  int lz = leading_zeroes(w);
  w <<= lz;
 
  // The required precision is binary::mantissa_explicit_bits() + 3 because
  // 1. We need the implicit bit
  // 2. We need an extra bit for rounding purposes
  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
 
  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
    // In some very rare cases, this could happen, in which case we might need a more accurate
    // computation that what we can provide cheaply. This is very, very unlikely.
    //
    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
    if(!inside_safe_exponent) {
      return compute_error_scaled<binary>(q, product.high, lz);
    }
  }
  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
  // value128 product = compute_product(q, w);
  // but in practice, we can win big with the compute_product_approximation if its additional branch
  // is easily predicted. Which is best is data specific.
  int upperbit = int(product.high >> 63);
 
  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
 
  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
  if (answer.power2 <= 0) { // we have a subnormal?
    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
    if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
      answer.power2 = 0;
      answer.mantissa = 0;
      // result should be zero
      return answer;
    }
    // next line is safe because -answer.power2 + 1 < 64
    answer.mantissa >>= -answer.power2 + 1;
    // Thankfully, we can't have both "round-to-even" and subnormals because
    // "round-to-even" only occurs for powers close to 0.
    answer.mantissa += (answer.mantissa & 1); // round up
    answer.mantissa >>= 1;
    // There is a weird scenario where we don't have a subnormal but just.
    // Suppose we start with 2.2250738585072013e-308, we end up
    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
    // subnormal, but we can only know this after rounding.
    // So we only declare a subnormal if we are smaller than the threshold.
    answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
    return answer;
  }
 
  // usually, we round *up*, but if we fall right in between and and we have an
  // even basis, we need to round down
  // We are only concerned with the cases where 5**q fits in single 64-bit word.
  if ((product.low <= 1) &&  (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
      ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
    // To be in-between two floats we need that in doing
    //   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
    // ... we dropped out only zeroes. But if this happened, then we can go back!!!
    if((answer.mantissa  << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) ==  product.high) {
      answer.mantissa &= ~uint64_t(1);          // flip it so that we do not round up
    }
  }
 
  answer.mantissa += (answer.mantissa & 1); // round up
  answer.mantissa >>= 1;
  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
    answer.power2++; // undo previous addition
  }
 
  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
  if (answer.power2 >= binary::infinite_power()) { // infinity
    answer.power2 = binary::infinite_power();
    answer.mantissa = 0;
  }
  return answer;
}

References fast_float::value128::high, leading_zeroes(), fast_float::value128::low, fast_float::adjusted_mantissa::mantissa, fast_float::detail::power(), and fast_float::adjusted_mantissa::power2.

Referenced by from_chars_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_product_approximation()

template<int bit_precision>

fastfloat_really_inline value128 fast_float::compute_product_approximation	(	int64_t	q,
		uint64_t	w
	)

Definition at line 1417 of file fast_float.h.

                                                              {
  const int index = 2 * int(q - powers::smallest_power_of_five);
  // For small values of q, e.g., q in [0,27], the answer is always exact because
  // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
  // gives the exact answer.
  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
  static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
  constexpr uint64_t precision_mask = (bit_precision < 64) ?
               (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
               : uint64_t(0xFFFFFFFFFFFFFFFF);
  if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
    // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
    firstproduct.low += secondproduct.high;
    if(secondproduct.high > firstproduct.low) {
      firstproduct.high++;
    }
  }
  return firstproduct;
}

References full_multiplication(), fast_float::value128::high, fast_float::value128::low, fast_float::powers_template< unused >::power_of_five_128, and fast_float::powers_template< unused >::smallest_power_of_five.

Here is the call graph for this function:

digit_comp()

template<typename T >

adjusted_mantissa fast_float::digit_comp ( parsed_number_string &  num, adjusted_mantissa  am  )

inlinenoexcept

Definition at line 2815 of file fast_float.h.

                                                                                              {
  // remove the invalid exponent bias
  am.power2 -= invalid_am_bias;
 
  int32_t sci_exp = scientific_exponent(num);
  size_t max_digits = binary_format<T>::max_digits();
  size_t digits = 0;
  bigint bigmant;
  parse_mantissa(bigmant, num, max_digits, digits);
  // can't underflow, since digits is at most max_digits.
  int32_t exponent = sci_exp + 1 - int32_t(digits);
  if (exponent >= 0) {
    return positive_digit_comp<T>(bigmant, exponent);
  } else {
    return negative_digit_comp<T>(bigmant, am, exponent);
  }
}

References invalid_am_bias, fast_float::binary_format< T >::max_digits(), parse_mantissa(), fast_float::adjusted_mantissa::power2, and scientific_exponent().

Here is the call graph for this function:

empty_hi64()

fastfloat_really_inline uint64_t fast_float::empty_hi64 ( bool &  truncated )

noexcept

Definition at line 1749 of file fast_float.h.

                                              {
  truncated = false;
  return 0;
}

Referenced by fast_float::bigint::hi64().

Here is the caller graph for this function:

fastfloat_strncasecmp()

bool fast_float::fastfloat_strncasecmp ( const char *  input1, const char *  input2, size_t  length  )

inline

Definition at line 193 of file fast_float.h.

                                                 {
  char running_diff{0};
  for (size_t i = 0; i < length; i++) {
    running_diff |= (input1[i] ^ input2[i]);
  }
  return (running_diff == 0) || (running_diff == 32);
}

Referenced by fast_float::detail::parse_infnan().

Here is the caller graph for this function:

from_chars()

template<typename T >

from_chars_result fast_float::from_chars ( const char *  first, const char *  last, T &  value, chars_format  fmt = chars_format::general  )

noexcept

This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale. The resulting floating-point value is the closest floating-point values (using either float or double), using the "round to even" convention for values that would otherwise fall right in-between two values. That is, we provide exact parsing according to the IEEE standard.

Given a successful parse, the pointer (ptr) in the returned value is set to point right after the parsed number, and the value referenced is set to the parsed value. In case of error, the returned ec contains a representative error, otherwise the default (std::errc()) value is stored.

The implementation does not throw and does not allocate memory (e.g., with new or malloc).

Like the C++17 standard, the fast_float::from_chars functions take an optional last argument of the type fast_float::chars_format. It is a bitset value: we check whether fmt & fast_float::chars_format::fixed and fmt & fast_float::chars_format::scientific are set to determine whether we allowe the fixed point and scientific notation respectively. The default is fast_float::chars_format::general which allows both fixed and scientific.

Definition at line 2900 of file fast_float.h.

                                                                      {
  return from_chars_advanced(first, last, value, parse_options{fmt});
}

References from_chars_advanced().

Referenced by FromChars().

Here is the call graph for this function:

Here is the caller graph for this function:

from_chars_advanced()

template<typename T >

from_chars_result fast_float::from_chars_advanced ( const char *  first, const char *  last, T &  value, parse_options  options  )

noexcept

Like from_chars, but accepts an options argument to govern number parsing.

Definition at line 2906 of file fast_float.h.

                                                                                  {
 
  static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
 
 
  from_chars_result answer;
  if (first == last) {
    answer.ec = std::errc::invalid_argument;
    answer.ptr = first;
    return answer;
  }
  parsed_number_string pns = parse_number_string(first, last, options);
  if (!pns.valid) {
    return detail::parse_infnan(first, last, value);
  }
  answer.ec = std::errc(); // be optimistic
  answer.ptr = pns.lastmatch;
  // Next is Clinger's fast path.
  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && pns.mantissa <=binary_format<T>::max_mantissa_fast_path() && !pns.too_many_digits) {
    value = T(pns.mantissa);
    if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
    else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
    if (pns.negative) { value = -value; }
    return answer;
  }
  adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
  if(pns.too_many_digits && am.power2 >= 0) {
    if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
    }
  }
  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
  // then we need to go the long way around again. This is very uncommon.
  if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
  to_float(pns.negative, am, value);
  return answer;
}

References compute_float(), fast_float::from_chars_result::ec, fast_float::binary_format< T >::exact_power_of_ten(), fast_float::detail::parse_infnan(), parse_number_string(), fast_float::adjusted_mantissa::power2, fast_float::from_chars_result::ptr, and to_float().

Referenced by from_chars().

Here is the call graph for this function:

Here is the caller graph for this function:

full_multiplication()

fastfloat_really_inline value128 fast_float::full_multiplication	(	uint64_t	a,
		uint64_t	b
	)

Definition at line 282 of file fast_float.h.

                                                                 {
  value128 answer;
#ifdef _M_ARM64
  // ARM64 has native support for 64-bit multiplications, no need to emulate
  answer.high = __umulh(a, b);
  answer.low = a * b;
#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
#elif defined(FASTFLOAT_64BIT)
  __uint128_t r = ((__uint128_t)a) * b;
  answer.low = uint64_t(r);
  answer.high = uint64_t(r >> 64);
#else
  #error Not implemented
#endif
  return answer;
}

References fast_float::value128::high, and fast_float::value128::low.

Referenced by compute_product_approximation(), and scalar_mul().

Here is the caller graph for this function:

is_integer()

fastfloat_really_inline bool fast_float::is_integer ( char  c )

noexcept

Definition at line 479 of file fast_float.h.

{ return c >= '0' && c <= '9'; }

Referenced by parse_number_string().

Here is the caller graph for this function:

is_made_of_eight_digits_fast() [1/2]

fastfloat_really_inline bool fast_float::is_made_of_eight_digits_fast ( const char *  chars )

noexcept

Definition at line 531 of file fast_float.h.

                                                                                        {
  return is_made_of_eight_digits_fast(read_u64(chars));
}

References is_made_of_eight_digits_fast(), and read_u64().

Here is the call graph for this function:

is_made_of_eight_digits_fast() [2/2]

fastfloat_really_inline bool fast_float::is_made_of_eight_digits_fast ( uint64_t  val )

noexcept

Definition at line 526 of file fast_float.h.

                                                                                   {
  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
     0x8080808080808080));
}

Referenced by is_made_of_eight_digits_fast(), and parse_number_string().

Here is the caller graph for this function:

is_truncated() [1/2]

fastfloat_really_inline bool fast_float::is_truncated ( byte_span  s )

noexcept

Definition at line 2618 of file fast_float.h.

                                                                {
  return is_truncated(s.ptr, s.ptr + s.len());
}

References is_truncated().

Here is the call graph for this function:

is_truncated() [2/2]

fastfloat_really_inline bool fast_float::is_truncated ( const char *  first, const char *  last  )

noexcept

Definition at line 2599 of file fast_float.h.

                                                                                        {
  // do 8-bit optimizations, can just compare to 8 literal 0s.
  uint64_t val;
  while (std::distance(first, last) >= 8) {
    ::memcpy(&val, first, sizeof(uint64_t));
    if (val != 0x3030303030303030) {
      return true;
    }
    first += 8;
  }
  while (first != last) {
    if (*first != '0') {
      return true;
    }
    first++;
  }
  return false;
}

Referenced by is_truncated(), and parse_mantissa().

Here is the caller graph for this function:

large_add_from() [1/2]

template<uint16_t size>

fastfloat_really_inline bool fast_float::large_add_from ( stackvec< size > &  x, limb_span  y  )

noexcept

Definition at line 1912 of file fast_float.h.

                                                                                     {
  return large_add_from(x, y, 0);
}

References large_add_from().

Here is the call graph for this function:

large_add_from() [2/2]

template<uint16_t size>

bool fast_float::large_add_from ( stackvec< size > &  x, limb_span  y, size_t  start  )

noexcept

Definition at line 1882 of file fast_float.h.

                                                                           {
  // the effective x buffer is from `xstart..x.len()`, so exit early
  // if we can't get that current range.
  if (x.len() < start || y.len() > x.len() - start) {
      FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
  }
 
  bool carry = false;
  for (size_t index = 0; index < y.len(); index++) {
    limb xi = x[index + start];
    limb yi = y[index];
    bool c1 = false;
    bool c2 = false;
    xi = scalar_add(xi, yi, c1);
    if (carry) {
      xi = scalar_add(xi, 1, c2);
    }
    x[index + start] = xi;
    carry = c1 | c2;
  }
 
  // handle overflow
  if (carry) {
    FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
  }
  return true;
}

References FASTFLOAT_TRY, scalar_add(), and small_add_from().

Referenced by large_add_from(), and long_mul().

Here is the call graph for this function:

Here is the caller graph for this function:

large_mul()

template<uint16_t size>

bool fast_float::large_mul ( stackvec< size > &  x, limb_span  y  )

noexcept

Definition at line 1946 of file fast_float.h.

                                                        {
  if (y.len() == 1) {
    FASTFLOAT_TRY(small_mul(x, y[0]));
  } else {
    FASTFLOAT_TRY(long_mul(x, y));
  }
  return true;
}

References FASTFLOAT_TRY, long_mul(), and small_mul().

Referenced by fast_float::bigint::pow5().

Here is the call graph for this function:

Here is the caller graph for this function:

leading_zeroes()

fastfloat_really_inline int fast_float::leading_zeroes

(

uint64_t

input_num

)

Definition at line 232 of file fast_float.h.

                                                               {
  assert(input_num > 0);
#ifdef FASTFLOAT_VISUAL_STUDIO
  #if defined(_M_X64) || defined(_M_ARM64)
  unsigned long leading_zero = 0;
  // Search the mask data from most significant bit (MSB)
  // to least significant bit (LSB) for a set bit (1).
  _BitScanReverse64(&leading_zero, input_num);
  return (int)(63 - leading_zero);
  #else
  int last_bit = 0;
  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
  return 63 - last_bit;
  #endif
#else
  return __builtin_clzll(input_num);
#endif
}

Referenced by compute_error(), compute_float(), fast_float::bigint::ctlz(), and uint64_hi64().

Here is the caller graph for this function:

long_mul()

template<uint16_t size>

bool fast_float::long_mul ( stackvec< size > &  x, limb_span  y  )

noexcept

Definition at line 1918 of file fast_float.h.

                                                       {
  limb_span xs = limb_span(x.data, x.len());
  stackvec<size> z(xs);
  limb_span zs = limb_span(z.data, z.len());
 
  if (y.len() != 0) {
    limb y0 = y[0];
    FASTFLOAT_TRY(small_mul(x, y0));
    for (size_t index = 1; index < y.len(); index++) {
      limb yi = y[index];
      stackvec<size> zi;
      if (yi != 0) {
        // re-use the same buffer throughout
        zi.set_len(0);
        FASTFLOAT_TRY(zi.try_extend(zs));
        FASTFLOAT_TRY(small_mul(zi, yi));
        limb_span zis = limb_span(zi.data, zi.len());
        FASTFLOAT_TRY(large_add_from(x, zis, index));
      }
    }
  }
 
  x.normalize();
  return true;
}

References fast_float::stackvec< size >::data, FASTFLOAT_TRY, large_add_from(), fast_float::stackvec< size >::len(), fast_float::stackvec< size >::set_len(), small_mul(), and fast_float::stackvec< size >::try_extend().

Referenced by large_mul().

Here is the call graph for this function:

Here is the caller graph for this function:

negative_digit_comp()

template<typename T >

adjusted_mantissa fast_float::negative_digit_comp ( bigint &  bigmant, adjusted_mantissa  am, int32_t  exponent  )

inlinenoexcept

Definition at line 2755 of file fast_float.h.

                                                                                                               {
  bigint& real_digits = bigmant;
  int32_t real_exp = exponent;
 
  // get the value of `b`, rounded down, and get a bigint representation of b+h
  adjusted_mantissa am_b = am;
  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with -Wnoexcept-type.
  round<T>(am_b, [](adjusted_mantissa&a, int32_t shift) { round_down(a, shift); });
  T b;
  to_float(false, am_b, b);
  adjusted_mantissa theor = to_extended_halfway(b);
  bigint theor_digits(theor.mantissa);
  int32_t theor_exp = theor.power2;
 
  // scale real digits and theor digits to be same power.
  int32_t pow2_exp = theor_exp - real_exp;
  uint32_t pow5_exp = uint32_t(-real_exp);
  if (pow5_exp != 0) {
    FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
  }
  if (pow2_exp > 0) {
    FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
  } else if (pow2_exp < 0) {
    FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
  }
 
  // compare digits, and use it to director rounding
  int ord = real_digits.compare(theor_digits);
  adjusted_mantissa answer = am;
  round<T>(answer, [ord](adjusted_mantissa& a, int32_t shift) {
    round_nearest_tie_even(a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
      (void)_;  // not needed, since we've done our comparison
      (void)__; // not needed, since we've done our comparison
      if (ord > 0) {
        return true;
      } else if (ord < 0) {
        return false;
      } else {
        return is_odd;
      }
    });
  });
 
  return answer;
}

References _, fast_float::bigint::compare(), FASTFLOAT_ASSERT, fast_float::adjusted_mantissa::mantissa, fast_float::bigint::pow2(), fast_float::bigint::pow5(), fast_float::adjusted_mantissa::power2, round_down(), round_nearest_tie_even(), to_extended_halfway(), and to_float().

Here is the call graph for this function:

parse_eight_digits()

fastfloat_really_inline void fast_float::parse_eight_digits ( const char *&  p, limb &  value, size_t &  counter, size_t &  count  )

noexcept

Definition at line 2623 of file fast_float.h.

                                                                                              {
  value = value * 100000000 + parse_eight_digits_unrolled(p);
  p += 8;
  counter += 8;
  count += 8;
}

References parse_eight_digits_unrolled().

Referenced by parse_mantissa().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_eight_digits_unrolled() [1/2]

fastfloat_really_inline uint32_t fast_float::parse_eight_digits_unrolled ( const char *  chars )

noexcept

Definition at line 521 of file fast_float.h.

                                                                                           {
  return parse_eight_digits_unrolled(read_u64(chars));
}

References parse_eight_digits_unrolled(), and read_u64().

Here is the call graph for this function:

parse_eight_digits_unrolled() [2/2]

fastfloat_really_inline uint32_t fast_float::parse_eight_digits_unrolled

(

uint64_t

val

)

Definition at line 511 of file fast_float.h.

                                                                            {
  const uint64_t mask = 0x000000FF000000FF;
  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
  val -= 0x3030303030303030;
  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
  return uint32_t(val);
}

Referenced by parse_eight_digits(), parse_eight_digits_unrolled(), and parse_number_string().

Here is the caller graph for this function:

parse_mantissa()

void fast_float::parse_mantissa ( bigint &  result, parsed_number_string &  num, size_t  max_digits, size_t &  digits  )

inlinenoexcept

Definition at line 2652 of file fast_float.h.

                                                                                                                  {
  // try to minimize the number of big integer and scalar multiplication.
  // therefore, try to parse 8 digits at a time, and multiply by the largest
  // scalar value (9 or 19 digits) for each step.
  size_t counter = 0;
  digits = 0;
  limb value = 0;
#ifdef FASTFLOAT_64BIT_LIMB
  size_t step = 19;
#else
  size_t step = 9;
#endif
 
  // process all integer digits.
  const char* p = num.integer.ptr;
  const char* pend = p + num.integer.len();
  skip_zeros(p, pend);
  // process all digits, in increments of step per loop
  while (p != pend) {
    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
      parse_eight_digits(p, value, counter, digits);
    }
    while (counter < step && p != pend && digits < max_digits) {
      parse_one_digit(p, value, counter, digits);
    }
    if (digits == max_digits) {
      // add the temporary value, then check if we've truncated any digits
      add_native(result, limb(powers_of_ten_uint64[counter]), value);
      bool truncated = is_truncated(p, pend);
      if (num.fraction.ptr != nullptr) {
        truncated |= is_truncated(num.fraction);
      }
      if (truncated) {
        round_up_bigint(result, digits);
      }
      return;
    } else {
      add_native(result, limb(powers_of_ten_uint64[counter]), value);
      counter = 0;
      value = 0;
    }
  }
 
  // add our fraction digits, if they're available.
  if (num.fraction.ptr != nullptr) {
    p = num.fraction.ptr;
    pend = p + num.fraction.len();
    if (digits == 0) {
      skip_zeros(p, pend);
    }
    // process all digits, in increments of step per loop
    while (p != pend) {
      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
        parse_eight_digits(p, value, counter, digits);
      }
      while (counter < step && p != pend && digits < max_digits) {
        parse_one_digit(p, value, counter, digits);
      }
      if (digits == max_digits) {
        // add the temporary value, then check if we've truncated any digits
        add_native(result, limb(powers_of_ten_uint64[counter]), value);
        bool truncated = is_truncated(p, pend);
        if (truncated) {
          round_up_bigint(result, digits);
        }
        return;
      } else {
        add_native(result, limb(powers_of_ten_uint64[counter]), value);
        counter = 0;
        value = 0;
      }
    }
  }
 
  if (counter != 0) {
    add_native(result, limb(powers_of_ten_uint64[counter]), value);
  }
}

References add_native(), is_truncated(), parse_eight_digits(), parse_one_digit(), powers_of_ten_uint64, round_up_bigint(), and skip_zeros().

Referenced by digit_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_number_string()

fastfloat_really_inline parsed_number_string fast_float::parse_number_string ( const char *  p, const char *  pend, parse_options  options  )

noexcept

Definition at line 552 of file fast_float.h.

                                                                                                          {
  const chars_format fmt = options.format;
  const char decimal_point = options.decimal_point;
 
  parsed_number_string answer;
  answer.valid = false;
  answer.too_many_digits = false;
  answer.negative = (*p == '-');
  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
    ++p;
    if (p == pend) {
      return answer;
    }
    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
      return answer;
    }
  }
  const char *const start_digits = p;
 
  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
 
  while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
    p += 8;
  }
  while ((p != pend) && is_integer(*p)) {
    // a multiplication by 10 is cheaper than an arbitrary integer
    // multiplication
    i = 10 * i +
        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
    ++p;
  }
  const char *const end_of_integer_part = p;
  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
  answer.integer = byte_span(start_digits, size_t(digit_count));
  int64_t exponent = 0;
  if ((p != pend) && (*p == decimal_point)) {
    ++p;
    const char* before = p;
    // can occur at most twice without overflowing, but let it occur more, since
    // for integers with many digits, digit parsing is the primary bottleneck.
    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
      p += 8;
    }
    while ((p != pend) && is_integer(*p)) {
      uint8_t digit = uint8_t(*p - '0');
      ++p;
      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
    }
    exponent = before - p;
    answer.fraction = byte_span(before, size_t(p - before));
    digit_count -= exponent;
  }
  // we must have encountered at least one integer!
  if (digit_count == 0) {
    return answer;
  }
  int64_t exp_number = 0;            // explicit exponential part
  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
    const char * location_of_e = p;
    ++p;
    bool neg_exp = false;
    if ((p != pend) && ('-' == *p)) {
      neg_exp = true;
      ++p;
    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
      ++p;
    }
    if ((p == pend) || !is_integer(*p)) {
      if(!(fmt & chars_format::fixed)) {
        // We are in error.
        return answer;
      }
      // Otherwise, we will be ignoring the 'e'.
      p = location_of_e;
    } else {
      while ((p != pend) && is_integer(*p)) {
        uint8_t digit = uint8_t(*p - '0');
        if (exp_number < 0x10000000) {
          exp_number = 10 * exp_number + digit;
        }
        ++p;
      }
      if(neg_exp) { exp_number = - exp_number; }
      exponent += exp_number;
    }
  } else {
    // If it scientific and not fixed, we have to bail out.
    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
  }
  answer.lastmatch = p;
  answer.valid = true;
 
  // If we frequently had to deal with long strings of digits,
  // we could extend our code by using a 128-bit integer instead
  // of a 64-bit integer. However, this is uncommon.
  //
  // We can deal with up to 19 digits.
  if (digit_count > 19) { // this is uncommon
    // It is possible that the integer had an overflow.
    // We have to handle the case where we have 0.0000somenumber.
    // We need to be mindful of the case where we only have zeroes...
    // E.g., 0.000000000...000.
    const char *start = start_digits;
    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
      if(*start == '0') { digit_count --; }
      start++;
    }
    if (digit_count > 19) {
      answer.too_many_digits = true;
      // Let us start again, this time, avoiding overflows.
      // We don't need to check if is_integer, since we use the
      // pre-tokenized spans from above.
      i = 0;
      p = answer.integer.ptr;
      const char* int_end = p + answer.integer.len();
      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
        i = i * 10 + uint64_t(*p - '0');
        ++p;
      }
      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
        exponent = end_of_integer_part - p + exp_number;
      } else { // We have a value with a fractional component.
          p = answer.fraction.ptr;
          const char* frac_end = p + answer.fraction.len();
          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
            i = i * 10 + uint64_t(*p - '0');
            ++p;
          }
          exponent = answer.fraction.ptr - p + exp_number;
      }
      // We have now corrected both exponent and i, to a truncated value
    }
  }
  answer.exponent = exponent;
  answer.mantissa = i;
  return answer;
}

References fast_float::parsed_number_string::exponent, fixed, fast_float::parsed_number_string::fraction, fast_float::parsed_number_string::integer, is_integer(), is_made_of_eight_digits_fast(), fast_float::parsed_number_string::lastmatch, fast_float::span< T >::len(), fast_float::parsed_number_string::mantissa, fast_float::parsed_number_string::negative, parse_eight_digits_unrolled(), fast_float::span< T >::ptr, scientific, fast_float::parsed_number_string::too_many_digits, and fast_float::parsed_number_string::valid.

Referenced by from_chars_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_one_digit()

fastfloat_really_inline void fast_float::parse_one_digit ( const char *&  p, limb &  value, size_t &  counter, size_t &  count  )

noexcept

Definition at line 2631 of file fast_float.h.

                                                                                           {
  value = value * 10 + limb(*p - '0');
  p++;
  counter++;
  count++;
}

Referenced by parse_mantissa().

Here is the caller graph for this function:

positive_digit_comp()

template<typename T >

adjusted_mantissa fast_float::positive_digit_comp ( bigint &  bigmant, int32_t  exponent  )

inlinenoexcept

Definition at line 2732 of file fast_float.h.

                                                                                         {
  FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
  adjusted_mantissa answer;
  bool truncated;
  answer.mantissa = bigmant.hi64(truncated);
  int bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
  answer.power2 = bigmant.bit_length() - 64 + bias;
 
  round<T>(answer, [truncated](adjusted_mantissa& a, int32_t shift) {
    round_nearest_tie_even(a, shift, [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
      return is_above || (is_halfway && truncated) || (is_odd && is_halfway);
    });
  });
 
  return answer;
}

References FASTFLOAT_ASSERT, fast_float::adjusted_mantissa::mantissa, fast_float::binary_format< T >::mantissa_explicit_bits(), fast_float::binary_format< T >::minimum_exponent(), fast_float::adjusted_mantissa::power2, and round_nearest_tie_even().

Here is the call graph for this function:

read_u64()

fastfloat_really_inline uint64_t fast_float::read_u64

(

const char *

chars

)

Definition at line 492 of file fast_float.h.

                                                             {
  uint64_t val;
  ::memcpy(&val, chars, sizeof(uint64_t));
#if FASTFLOAT_IS_BIG_ENDIAN == 1
  // Need to read as-if the number was in little-endian order.
  val = byteswap(val);
#endif
  return val;
}

References byteswap().

Referenced by is_made_of_eight_digits_fast(), and parse_eight_digits_unrolled().

Here is the call graph for this function:

Here is the caller graph for this function:

round()

template<typename T , typename callback >

fastfloat_really_inline void fast_float::round ( adjusted_mantissa &  am, callback  cb  )

noexcept

Definition at line 2512 of file fast_float.h.

                                                                                {
  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
  if (-am.power2 >= mantissa_shift) {
    // have a denormal float
    int32_t shift = -am.power2 + 1;
    cb(am, std::min(shift, 64));
    // check for round-up: if rounding-nearest carried us to the hidden bit.
    am.power2 = (am.mantissa < (uint64_t(1) << binary_format<T>::mantissa_explicit_bits())) ? 0 : 1;
    return;
  }
 
  // have a normal float, use the default shift.
  cb(am, mantissa_shift);
 
  // check for carry
  if (am.mantissa >= (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
    am.power2++;
  }
 
  // check for infinite: we could have carried to an infinite power
  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
  if (am.power2 >= binary_format<T>::infinite_power()) {
    am.power2 = binary_format<T>::infinite_power();
    am.mantissa = 0;
  }
}

References fast_float::binary_format< T >::infinite_power(), fast_float::binary_format< T >::mantissa_explicit_bits(), and min().

Referenced by EBUR128::AddBlockToHistogram(), ProjectAudioManager::DoRecord(), BrushHandle::Drag(), anonymous_namespace{AudacityMirProject.cpp}::FormatTempo(), ProjectManager::GetEstimatedRecordingMinsLeftOnDisk(), anonymous_namespace{StaffPadTimeAndPitch.cpp}::GetFftSize(), MIR::anonymous_namespace{StftFrameProvider.cpp}::GetFrameSize(), MIR::anonymous_namespace{StftFrameProvider.cpp}::GetHopSize(), MIR::anonymous_namespace{MirDsp.cpp}::GetMovingAverage(), MIR::StftFrameProvider::GetNextFrame(), MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetOnsetLag(), anonymous_namespace{ClipPitchAndSpeedButtonHandle.cpp}::GetPlaybackSpeedText(), MIR::anonymous_namespace{GetMeterUsingTatumQuantizationFit.cpp}::GetPossibleDivHierarchies(), MIR::GetProjectSyncInfo(), anonymous_namespace{WaveChannelUtilities.cpp}::GetSampleAccessArgs(), EBUR128::IntegrativeLoudness(), LibImportExport::Test::LibsndfileTagger::LibsndfileTagger(), RegenerateLinearDBValues(), WaveChannelUtilities::SetFloatsWithinTimeRange(), BeatsFormat::SetLabelString(), WaveClip::SnapToTrackSample(), anonymous_namespace{SnapUtils.cpp}::SnapWithMultiplier(), and anonymous_namespace{ParsedNumericConverterFormatter.cpp}::ParsedNumericConverterFormatter::ValueToString().

Here is the call graph for this function:

Here is the caller graph for this function:

round_down()

fastfloat_really_inline void fast_float::round_down ( adjusted_mantissa &  am, int32_t  shift  )

noexcept

Definition at line 2571 of file fast_float.h.

                                                                                       {
  if (shift == 64) {
    am.mantissa = 0;
  } else {
    am.mantissa >>= shift;
  }
  am.power2 += shift;
}

Referenced by negative_digit_comp().

Here is the caller graph for this function:

round_nearest_tie_even()

template<typename callback >

fastfloat_really_inline void fast_float::round_nearest_tie_even ( adjusted_mantissa &  am, int32_t  shift, callback  cb  )

noexcept

Definition at line 2542 of file fast_float.h.

                                                                                        {
  uint64_t mask;
  uint64_t halfway;
  if (shift == 64) {
    mask = UINT64_MAX;
  } else {
    mask = (uint64_t(1) << shift) - 1;
  }
  if (shift == 0) {
    halfway = 0;
  } else {
    halfway = uint64_t(1) << (shift - 1);
  }
  uint64_t truncated_bits = am.mantissa & mask;
  uint64_t is_above = truncated_bits > halfway;
  uint64_t is_halfway = truncated_bits == halfway;
 
  // shift digits into position
  if (shift == 64) {
    am.mantissa = 0;
  } else {
    am.mantissa >>= shift;
  }
  am.power2 += shift;
 
  bool is_odd = (am.mantissa & 1) == 1;
  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
}

Referenced by negative_digit_comp(), and positive_digit_comp().

Here is the caller graph for this function:

round_up_bigint()

fastfloat_really_inline void fast_float::round_up_bigint ( bigint &  big, size_t &  count  )

noexcept

Definition at line 2644 of file fast_float.h.

                                                                                  {
  // need to round-up the digits, but need to avoid rounding
  // ....9999 to ...10000, which could cause a false halfway point.
  add_native(big, 10, 1);
  count++;
}

References add_native().

Referenced by parse_mantissa().

Here is the call graph for this function:

Here is the caller graph for this function:

scalar_add()

fastfloat_really_inline limb fast_float::scalar_add ( limb  x, limb  y, bool &  overflow  )

noexcept

Definition at line 1799 of file fast_float.h.

                                                         {
  limb z;
 
// gcc and clang
#if defined(__has_builtin)
  #if __has_builtin(__builtin_add_overflow)
    overflow = __builtin_add_overflow(x, y, &z);
    return z;
  #endif
#endif
 
  // generic, this still optimizes correctly on MSVC.
  z = x + y;
  overflow = z < x;
  return z;
}

Referenced by large_add_from(), scalar_mul(), and small_add_from().

Here is the caller graph for this function:

scalar_mul()

fastfloat_really_inline limb fast_float::scalar_mul ( limb  x, limb  y, limb &  carry  )

noexcept

Definition at line 1818 of file fast_float.h.

                                                      {
#ifdef FASTFLOAT_64BIT_LIMB
  #if defined(__SIZEOF_INT128__)
  // GCC and clang both define it as an extension.
  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
  carry = limb(z >> limb_bits);
  return limb(z);
  #else
  // fallback, no native 128-bit integer multiplication with carry.
  // on msvc, this optimizes identically, somehow.
  value128 z = full_multiplication(x, y);
  bool overflow;
  z.low = scalar_add(z.low, carry, overflow);
  z.high += uint64_t(overflow);  // cannot overflow
  carry = z.high;
  return z.low;
  #endif
#else
  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
  carry = limb(z >> limb_bits);
  return limb(z);
#endif
}

References full_multiplication(), limb_bits, and scalar_add().

Referenced by small_mul().

Here is the call graph for this function:

Here is the caller graph for this function:

scientific_exponent()

fastfloat_really_inline int32_t fast_float::scientific_exponent ( parsed_number_string &  num )

noexcept

Definition at line 2438 of file fast_float.h.

                                                                                        {
  uint64_t mantissa = num.mantissa;
  int32_t exponent = int32_t(num.exponent);
  while (mantissa >= 10000) {
    mantissa /= 10000;
    exponent += 4;
  }
  while (mantissa >= 100) {
    mantissa /= 100;
    exponent += 2;
  }
  while (mantissa >= 10) {
    mantissa /= 10;
    exponent += 1;
  }
  return exponent;
}

Referenced by digit_comp().

Here is the caller graph for this function:

skip_zeros()

fastfloat_really_inline void fast_float::skip_zeros ( const char *&  first, const char *  last  )

noexcept

Definition at line 2580 of file fast_float.h.

                                                                                       {
  uint64_t val;
  while (std::distance(first, last) >= 8) {
    ::memcpy(&val, first, sizeof(uint64_t));
    if (val != 0x3030303030303030) {
      break;
    }
    first += 8;
  }
  while (first != last) {
    if (*first != '0') {
      break;
    }
    first++;
  }
}

Referenced by parse_mantissa().

Here is the caller graph for this function:

small_add()

template<uint16_t size>

fastfloat_really_inline bool fast_float::small_add ( stackvec< size > &  vec, limb  y  )

noexcept

Definition at line 1862 of file fast_float.h.

                                                                             {
  return small_add_from(vec, y, 0);
}

References small_add_from().

Referenced by fast_float::bigint::add().

Here is the call graph for this function:

Here is the caller graph for this function:

small_add_from()

template<uint16_t size>

bool fast_float::small_add_from ( stackvec< size > &  vec, limb  y, size_t  start  )

inlinenoexcept

Definition at line 1845 of file fast_float.h.

                                                                               {
  size_t index = start;
  limb carry = y;
  bool overflow;
  while (carry != 0 && index < vec.len()) {
    vec[index] = scalar_add(vec[index], carry, overflow);
    carry = limb(overflow);
    index += 1;
  }
  if (carry != 0) {
    FASTFLOAT_TRY(vec.try_push(carry));
  }
  return true;
}

References FASTFLOAT_TRY, and scalar_add().

Referenced by large_add_from(), and small_add().

Here is the call graph for this function:

Here is the caller graph for this function:

small_mul()

template<uint16_t size>

bool fast_float::small_mul ( stackvec< size > &  vec, limb  y  )

inlinenoexcept

Definition at line 1868 of file fast_float.h.

                                                            {
  limb carry = 0;
  for (size_t index = 0; index < vec.len(); index++) {
    vec[index] = scalar_mul(vec[index], y, carry);
  }
  if (carry != 0) {
    FASTFLOAT_TRY(vec.try_push(carry));
  }
  return true;
}

References FASTFLOAT_TRY, and scalar_mul().

Referenced by large_mul(), long_mul(), fast_float::bigint::mul(), and fast_float::bigint::pow5().

Here is the call graph for this function:

Here is the caller graph for this function:

to_extended()

template<typename T >

fastfloat_really_inline adjusted_mantissa fast_float::to_extended ( T  value )

noexcept

Definition at line 2458 of file fast_float.h.

                                                                        {
  adjusted_mantissa am;
  int32_t bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
  if (std::is_same<T, float>::value) {
    constexpr uint32_t exponent_mask = 0x7F800000;
    constexpr uint32_t mantissa_mask = 0x007FFFFF;
    constexpr uint64_t hidden_bit_mask = 0x00800000;
    uint32_t bits;
    ::memcpy(&bits, &value, sizeof(T));
    if ((bits & exponent_mask) == 0) {
      // denormal
      am.power2 = 1 - bias;
      am.mantissa = bits & mantissa_mask;
    } else {
      // normal
      am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
      am.power2 -= bias;
      am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
    }
  } else {
    constexpr uint64_t exponent_mask = 0x7FF0000000000000;
    constexpr uint64_t mantissa_mask = 0x000FFFFFFFFFFFFF;
    constexpr uint64_t hidden_bit_mask = 0x0010000000000000;
    uint64_t bits;
    ::memcpy(&bits, &value, sizeof(T));
    if ((bits & exponent_mask) == 0) {
      // denormal
      am.power2 = 1 - bias;
      am.mantissa = bits & mantissa_mask;
    } else {
      // normal
      am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
      am.power2 -= bias;
      am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
    }
  }
 
  return am;
}

References fast_float::adjusted_mantissa::mantissa, fast_float::binary_format< T >::mantissa_explicit_bits(), fast_float::binary_format< T >::minimum_exponent(), and fast_float::adjusted_mantissa::power2.

Referenced by to_extended_halfway().

Here is the call graph for this function:

Here is the caller graph for this function:

to_extended_halfway()

template<typename T >

fastfloat_really_inline adjusted_mantissa fast_float::to_extended_halfway ( T  value )

noexcept

Definition at line 2502 of file fast_float.h.

                                                                                {
  adjusted_mantissa am = to_extended(value);
  am.mantissa <<= 1;
  am.mantissa += 1;
  am.power2 -= 1;
  return am;
}

References fast_float::adjusted_mantissa::mantissa, fast_float::adjusted_mantissa::power2, and to_extended().

Referenced by negative_digit_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

to_float()

template<typename T >

fastfloat_really_inline void fast_float::to_float	(	bool	negative,
		adjusted_mantissa	am,
		T &	value
	)

Definition at line 444 of file fast_float.h.

                                                                                     {
  uint64_t word = am.mantissa;
  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
  word = negative
  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
#if FASTFLOAT_IS_BIG_ENDIAN == 1
   if (std::is_same<T, float>::value) {
     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
   } else {
     ::memcpy(&value, &word, sizeof(T));
   }
#else
   // For little-endian systems:
   ::memcpy(&value, &word, sizeof(T));
#endif
}

References fast_float::adjusted_mantissa::mantissa, fast_float::binary_format< T >::mantissa_explicit_bits(), fast_float::adjusted_mantissa::power2, and fast_float::binary_format< T >::sign_index().

Referenced by from_chars_advanced(), and negative_digit_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_hi64() [1/3]

fastfloat_really_inline uint64_t fast_float::uint32_hi64 ( uint32_t  r0, bool &  truncated  )

noexcept

Definition at line 1775 of file fast_float.h.

                                                            {
  return uint64_hi64(r0, truncated);
}

References uint64_hi64().

Referenced by fast_float::bigint::hi64().

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_hi64() [2/3]

fastfloat_really_inline uint64_t fast_float::uint32_hi64 ( uint32_t  r0, uint32_t  r1, bool &  truncated  )

noexcept

Definition at line 1780 of file fast_float.h.

                                                                         {
  uint64_t x0 = r0;
  uint64_t x1 = r1;
  return uint64_hi64((x0 << 32) | x1, truncated);
}

References uint64_hi64().

Here is the call graph for this function:

uint32_hi64() [3/3]

fastfloat_really_inline uint64_t fast_float::uint32_hi64 ( uint32_t  r0, uint32_t  r1, uint32_t  r2, bool &  truncated  )

noexcept

Definition at line 1787 of file fast_float.h.

                                                                                      {
  uint64_t x0 = r0;
  uint64_t x1 = r1;
  uint64_t x2 = r2;
  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
}

References uint64_hi64().

Here is the call graph for this function:

uint64_hi64() [1/2]

fastfloat_really_inline uint64_t fast_float::uint64_hi64 ( uint64_t  r0, bool &  truncated  )

noexcept

Definition at line 1755 of file fast_float.h.

                                                            {
  truncated = false;
  int shl = leading_zeroes(r0);
  return r0 << shl;
}

References leading_zeroes().

Referenced by fast_float::bigint::hi64(), and uint32_hi64().

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_hi64() [2/2]

fastfloat_really_inline uint64_t fast_float::uint64_hi64 ( uint64_t  r0, uint64_t  r1, bool &  truncated  )

noexcept

Definition at line 1762 of file fast_float.h.

                                                                         {
  int shl = leading_zeroes(r0);
  if (shl == 0) {
    truncated = r1 != 0;
    return r0;
  } else {
    int shr = 64 - shl;
    truncated = (r1 << shl) != 0;
    return (r0 << shl) | (r1 >> shr);
  }
}

References leading_zeroes().

Here is the call graph for this function:

write_u64()

fastfloat_really_inline void fast_float::write_u64	(	uint8_t *	chars,
		uint64_t	val
	)

Definition at line 502 of file fast_float.h.

                                                                     {
#if FASTFLOAT_IS_BIG_ENDIAN == 1
  // Need to read as-if the number was in little-endian order.
  val = byteswap(val);
#endif
  ::memcpy(chars, &val, sizeof(uint64_t));
}

References byteswap().

Here is the call graph for this function:

Variable Documentation

bigint_bits

constexpr size_t fast_float::bigint_bits = 4000

constexpr

Definition at line 1626 of file fast_float.h.

bigint_limbs

constexpr size_t fast_float::bigint_limbs = bigint_bits / limb_bits

constexpr

Definition at line 1627 of file fast_float.h.

invalid_am_bias

constexpr int32_t fast_float::invalid_am_bias = -0x8000

staticconstexpr

Definition at line 314 of file fast_float.h.

Referenced by compute_error_scaled(), and digit_comp().

limb_bits

constexpr size_t fast_float::limb_bits = 32

constexpr

Definition at line 1617 of file fast_float.h.

Referenced by fast_float::bigint::bit_length(), scalar_mul(), fast_float::bigint::shl(), and fast_float::bigint::shl_bits().

powers_of_ten_double

constexpr double fast_float::powers_of_ten_double[]

staticconstexpr

Initial value:

= {
    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22}

Definition at line 316 of file fast_float.h.

Referenced by fast_float::binary_format< T >::exact_power_of_ten().

powers_of_ten_float

constexpr float fast_float::powers_of_ten_float[]

staticconstexpr

Initial value:

= {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
                                                1e6, 1e7, 1e8, 1e9, 1e10}

Definition at line 319 of file fast_float.h.

Referenced by fast_float::binary_format< T >::exact_power_of_ten().

powers_of_ten_uint64

constexpr uint64_t fast_float::powers_of_ten_uint64[]

staticconstexpr

Initial value:

= {
    1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
    1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
    100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
    1000000000000000000UL, 10000000000000000000UL}

Definition at line 2428 of file fast_float.h.

Referenced by parse_mantissa().