fast_float::detail Namespace Reference

Functions
constexpr fastfloat_really_inline int32_t	power (int32_t q) noexcept
template<typename T >
from_chars_result	parse_infnan (const char *first, const char *last, T &value) noexcept

Function Documentation

parse_infnan()

template<typename T >

from_chars_result fast_float::detail::parse_infnan ( const char *  first, const char *  last, T &  value  )

noexcept

Special case +inf, -inf, nan, infinity, -infinity. The case comparisons could be made much faster given that we know that the strings a null-free and fixed.

Definition at line 2857 of file fast_float.h.

                                                                                         {
  from_chars_result answer;
  answer.ptr = first;
  answer.ec = std::errc(); // be optimistic
  bool minusSign = false;
  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
      minusSign = true;
      ++first;
  }
  if (last - first >= 3) {
    if (fastfloat_strncasecmp(first, "nan", 3)) {
      answer.ptr = (first += 3);
      value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
      if(first != last && *first == '(') {
        for(const char* ptr = first + 1; ptr != last; ++ptr) {
          if (*ptr == ')') {
            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
            break;
          }
          else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
            break; // forbidden char, not nan(n-char-seq-opt)
        }
      }
      return answer;
    }
    if (fastfloat_strncasecmp(first, "inf", 3)) {
      if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
        answer.ptr = first + 8;
      } else {
        answer.ptr = first + 3;
      }
      value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
      return answer;
    }
  }
  answer.ec = std::errc::invalid_argument;
  return answer;
}

References fast_float::from_chars_result::ec, fast_float::fastfloat_strncasecmp(), and fast_float::from_chars_result::ptr.

Referenced by fast_float::from_chars_advanced().

Here is the call graph for this function:

Here is the caller graph for this function:

power()

constexpr fastfloat_really_inline int32_t fast_float::detail::power ( int32_t  q )

constexprnoexcept

For q in (0,350), we have that f = (((152170 + 65536) * q ) >> 16); is equal to floor(p) + q where p = log(5**q)/log(2) = q * log(5)/log(2)

For negative values of q in (-400,0), we have that f = (((152170 + 65536) * q ) >> 16); is equal to -ceil(p) + q where p = log(5**-q)/log(2) = -q * log(5)/log(2)

Definition at line 1454 of file fast_float.h.

                                                                        {
    return (((152170 + 65536) * q) >> 16) + 63;
  }

Referenced by fast_float::add_native(), SpectrumAnalyst::Calculate(), SpecCache::CalculateOneSpectrum(), EffectNoiseReduction::Worker::Classify(), fast_float::compute_error_scaled(), fast_float::compute_float(), anonymous_namespace{SpectrumCache.cpp}::ComputeSpectrumUsingRealFFTf(), fast_float::binary_format< T >::exact_power_of_ten(), SpecCache::Populate(), and FormantShifter::Process().

Here is the caller graph for this function: