floats.hpp

Go to the documentation of this file.

#ifndef MTCORE_FLOATS_H
#define MTCORE_FLOATS_H
 
#include "mtcore/io/writer.hpp"
#include <array>
#include <cmath>
#include <limits>
 
namespace mtcore::io::floats {
  namespace dragonbox {
    template<WriterImpl WI>
    Result<size_t, typename Writer<WI>::ErrType> format_float(Writer<WI> &writer, f64 f,
                                                              Slice<const char> opts = {nullptr, 0});
 
    namespace impl {
      template<typename From, typename To = u64>
      To bit_cast(From f) {
        static_assert(sizeof(From) == sizeof(To));
        return std::bit_cast<To>(f);
      }
 
      struct DoubleExtraction {
        // make sure we're working with what we think we are
        static_assert(std::numeric_limits<f64>::is_iec559 && std::numeric_limits<f64>::digits == 53 &&
                      std::numeric_limits<f64>::max_exponent == 1024);
 
        static constexpr auto sigSize    = std::numeric_limits<f64>::digits;
        static constexpr auto expBias    = std::numeric_limits<f64>::max_exponent - 1 + (sigSize - 1);
        static constexpr auto maxIeeeExp = static_cast<u64>(2 * std::numeric_limits<f64>::max_exponent - 1);
        static constexpr auto hiddenBit  = static_cast<u64>(1) << (sigSize - 1);
        static constexpr auto sigMask    = hiddenBit - 1;
        static constexpr auto expMask    = maxIeeeExp << (sigSize - 1);
        static constexpr auto signMask   = ~((~static_cast<u64>(0)) >> 1);
 
        u64 bits;
 
        static auto from_bits(u64 bits) -> DoubleExtraction;
 
        static auto from_float(f64 f) -> DoubleExtraction;
 
        [[nodiscard]] auto phys_significand() const -> u64;
 
        [[nodiscard]] auto phys_exp() const -> u64;
 
        [[nodiscard]] auto is_finite() const -> bool;
 
        [[nodiscard]] auto is_inf() const -> bool;
 
        [[nodiscard]] auto is_nan() const -> bool;
 
        [[nodiscard]] auto is_zero() const -> bool;
 
        [[nodiscard]] auto sign_bit() const -> bool;
      };
 
      auto int_floor_div_pow_2(i32 x, i32 p) -> i32;
 
      auto int_floor_log2_pow10(i32 x) -> i32;
 
      auto int_floor_log10_pow2(i32 x) -> i32;
 
      auto int_floor_log7p5_pow2(i32 x) -> i32;
 
      struct U128 {
        u64 high;
        u64 low;
 
#ifdef __SIZEOF_INT128__
        [[nodiscard]] static U128 mul(u64 l, u64 remainder) {
          __extension__ using u128 = unsigned __int128;
          const auto f             = u128{l} * u128{remainder};
          const auto high          = static_cast<u64>((f >> 64) & 0xFFFFFFFFFFFFFFFF);
          const auto low           = static_cast<u64>((f >> 0) & 0xFFFFFFFFFFFFFFFF);
          return {high, low};
        }
#elif defined(_MSC_VER) && defined(_M_X64)
        [[nodiscard]] static U128 mul(u64 l, u64 remainder) {
          u64 high = 0;
          u64 low  = _umul128(l, remainder, &high);
          return {high, low};
        }
#else
        [[nodiscard]] static auto low32(u64 x) -> u32 { return static_cast<u32>((x >> 0) & 0xFFFFFFFF); }
        [[nodiscard]] static auto high32(u64 x) -> u32 { return static_cast<u32>((x >> 32) & 0xFFFFFFFF); }
 
        [[nodiscard]] static U128 mul(u64 l, u64 remainder) {
          const auto mult_ll = static_cast<u64>(low32(l)) * static_cast<u64>(low32(remainder));
          const auto mult_lh = static_cast<u64>(low32(l)) * static_cast<u64>(high32(remainder));
          const auto mult_hl = static_cast<u64>(high32(l)) * static_cast<u64>(low32(remainder));
          const auto mult_hh = static_cast<u64>(high32(l)) * static_cast<u64>(high32(remainder));
 
          const auto mid1 = mult_hl + high32(mult_ll);
          const auto mid2 = mult_lh + low32(mid1);
 
          const auto high = mult_hh + high32(mid1) + high32(mid2);
          const auto low  = low32(mult_ll) | (static_cast<u64>(low32(mid2)) << 32);
          return {high, low};
        }
#endif
 
        [[nodiscard]] auto mul_shift(u64 x) const -> u64;
 
        [[nodiscard]] auto mul_parity(u64 twoF, u32 betaM1) const -> bool;
      };
    }  // namespace impl
 
    auto compute_pow10(i32 p) -> impl::U128;
 
    auto multiple_of_pow2(u64 val, i32 exp);
 
    auto multiple_of_pow5(u64 val, i32 exp) -> bool;
 
    struct FloatDec64 {
      u64 sig;
      i32 exp;
 
      static auto from_asymmetric_interval(const i32 exp) -> FloatDec64;
 
      static auto compute_delta(impl::U128 p10, i32 betaM1) -> u32;
 
      static auto is_integral_endpoint(u64 twoF, i32 exp, i32 minusK) -> bool;
 
      static auto is_integral_midpoint(u64 twoF, i32 exp, i32 minusK) -> bool;
 
      static auto from_parts(u64 ieeeSig, u64 ieeeExp) -> FloatDec64;
    };
 
    void unsigned_to_ascii_2digs(Slice<char> buff, u32 digits);
 
    auto trailing_zeros_2digs(u32 digits) -> i8;
 
    auto unsigned_to_ascii_8digits_skip_trailing_zeros(Slice<char> buff, u32 digits) -> i32;
 
    auto print_dec_digs_reversed(Slice<char> buff, u64 out) -> i32;
 
    auto round_compute_pow10_double(size_t d) -> double;
 
    struct DragonboxFormatOptions {
      size_t precision                                 = 0;
      bool capitalE                                    = false;
      bool forceScientific                             = false;
      bool plusE                                       = false;
      enum { NEG_ONLY, PLUS, NEG_PAREN } signIndicator = NEG_ONLY;
      i32 minDecPlaces                                 = 0;
      i32 maxDecPlaces                                 = std::numeric_limits<i32>::max();
    };
 
    auto format_digits(Slice<char> buff, u64 digits, i32 decExp, DragonboxFormatOptions = {}) -> Slice<char>;
 
    auto to_chars(Slice<char> buff, double val, DragonboxFormatOptions = {}) -> Result<Slice<char>, SliceWriteError>;
 
    template<WriterImpl WI>
    Result<size_t, typename Writer<WI>::ErrType> format_float(Writer<WI> &writer, f64 f, Slice<const char> fmtStr) {
      auto opts = DragonboxFormatOptions{};
 
      if (slices::starts_with('+', fmtStr)) {
        opts.signIndicator = DragonboxFormatOptions::PLUS;
        fmtStr             = fmtStr.sub(1);
      }
      else if (slices::starts_with(slice_from("()"), fmtStr)) {
        opts.signIndicator = DragonboxFormatOptions::NEG_PAREN;
        fmtStr             = fmtStr.sub(2);
      }
 
      if (slices::starts_with('F', fmtStr)) {
        opts.capitalE = true;
        fmtStr        = fmtStr.sub(1);
      }
      else if (slices::starts_with('f', fmtStr)) {
        opts.capitalE = false;
        fmtStr        = fmtStr.sub(1);
      }
 
      if (slices::starts_with('E', fmtStr)) {
        opts.capitalE        = true;
        opts.forceScientific = true;
        fmtStr               = fmtStr.sub(1);
      }
      else if (slices::starts_with('e', fmtStr)) {
        opts.forceScientific = true;
        fmtStr               = fmtStr.sub(1);
      }
 
      if (slices::starts_with('+', fmtStr)) {
        opts.plusE = true;
        fmtStr     = fmtStr.sub(1);
      }
 
      if (slices::contains('.', fmtStr)) {
        const auto pivot        = slices::first_index('.', fmtStr).value();
        const auto decSpecifier = fmtStr.sub(pivot + 1);
        ensure(!decSpecifier.empty(), "Invalid format string");
 
        const auto sepIndex  = slices::first_index('-', decSpecifier).value_or(decSpecifier.size());
        const auto minDigits = decSpecifier.sub(0, sepIndex);
        ensure(!minDigits.empty(), "Invalid format string");
 
        opts.minDecPlaces = ascii::base10_to_int<i32>(minDigits).value();
        ensure(opts.minDecPlaces >= 0);
 
        opts.maxDecPlaces = opts.minDecPlaces;
        if (const auto maxDigits = decSpecifier.sub(sepIndex + 1); !maxDigits.empty()) {
          opts.maxDecPlaces = ascii::base10_to_int<i32>(maxDigits).value();
          ensure(opts.maxDecPlaces >= opts.minDecPlaces);
          ensure(opts.maxDecPlaces <= 16);
        }
 
        fmtStr = fmtStr.sub(0, pivot);
 
        if (opts.maxDecPlaces <= 16) {
          auto b = round_compute_pow10_double(opts.maxDecPlaces);
          f *= b;
          f = std::round(f);
          f /= b;
        }
      }
 
      if (ascii::is_pos_int_str(fmtStr)) {
        opts.precision = ascii::base10_to_int(fmtStr).value();
        fmtStr         = fmtStr.sub(fmtStr.size());
      }
 
      // check that there isn't excess stuff we didn't understand
      ensure(fmtStr.empty(), "Invalid format string");
      ensure(opts.precision <= 16);
      auto b        = std::array<char, 100>{};
      auto buff     = mut_slice_from(b);
      auto printRes = to_chars(buff, f, opts);
      if (printRes.is_error()) {
        using Err = typename Writer<WI>::ErrType;
        return error(Err::OUT_OF_ROOM);
      }
 
      if (opts.minDecPlaces == 0 && static_cast<size_t>(opts.maxDecPlaces) >= printRes.value().size()) {
        return writer.write_all(printRes.value()).with_success_val(printRes.value().size());
      }
      else {
        auto raw = printRes.value().to_const();
        if (slices::contains(slice_from("NaN"), raw) || slices::contains(slice_from("Infinity"), raw)) {
          return writer.write_all(printRes.value()).with_success_val(printRes.value().size());
        }
 
        auto decPointIndex = slices::first_index('.', raw);
        if (decPointIndex.empty()) {
          if (opts.minDecPlaces == 0) {
            return writer.write_all(printRes.value()).with_success_val(printRes.value().size());
          }
 
          size_t written = 0;
 
          auto sciNoteLowerE = slices::first_index('e', raw);
          auto sciNoteUpperE = slices::first_index('E', raw);
 
          auto end = raw.size();
 
          if (sciNoteLowerE.has_value()) {
            end = sciNoteLowerE.value();
          }
          else if (sciNoteUpperE.has_value()) {
            end = sciNoteUpperE.value();
          }
 
          auto toPrint = raw.sub(0, end);
 
          if (auto r = writer.write_all(toPrint); r.is_error()) {
            return r.error();
          }
          written += toPrint.size();
 
          if (auto r = writer.write('.'); r.is_error()) {
            return r.error();
          }
          ++written;
 
          if (auto r = writer.write_n_times('0', static_cast<size_t>(opts.minDecPlaces)); r.is_error()) {
            return r.error();
          }
          written += opts.minDecPlaces;
          auto rest = raw.sub(end);
          if (!rest.empty()) {
            if (auto r = writer.write_all(rest); r.is_error()) {
              return r.error();
            }
            written += rest.size();
          }
 
          return success(written);
        }
        else {
          auto end           = raw.size();
          auto sciNoteLowerE = slices::first_index('e', raw);
          auto sciNoteUpperE = slices::first_index('E', raw);
 
          if (sciNoteLowerE.has_value()) {
            end = sciNoteLowerE.value();
          }
          else if (sciNoteUpperE.has_value()) {
            end = sciNoteUpperE.value();
          }
 
          auto decs      = raw.sub(0, end).sub(decPointIndex.value() + 1);
          auto numDigits = decs.size();
          if (static_cast<i32>(numDigits) >= opts.minDecPlaces && static_cast<i32>(numDigits) <= opts.maxDecPlaces) {
            return writer.write_all(printRes.value()).with_success_val(printRes.value().size());
          }
 
          auto start     = raw.sub(0, decPointIndex.value() + 1);
          size_t written = 0;
 
          if (auto r = writer.write_all(start); r.is_error()) {
            return r.error();
          }
          written += start.size();
 
          if (static_cast<i32>(numDigits) < opts.minDecPlaces) {
            if (auto r = writer.write_all(decs); r.is_error()) {
              return r.error();
            }
            written += decs.size();
 
            auto toWrite = opts.minDecPlaces - decs.size();
            if (auto r = writer.write_n_times('0', toWrite); r.is_error()) {
              return r.error();
            }
            written += toWrite;
          }
          else {
            auto decsToWrite = decs.sub(0, opts.maxDecPlaces);
            if (auto r = writer.write_all(decsToWrite); r.is_error()) {
              return r.error();
            }
            written += decsToWrite.size();
          }
          auto finish = raw.sub(end);
          if (!finish.empty()) {
            if (auto r = writer.write_all(finish); r.is_error()) {
              return r.error();
            }
            written += finish.size();
          }
 
          return success(written);
        }
      }
    }
  }  // namespace dragonbox
}  // namespace mtcore::floats
 
#endif  // MTCORE_FLOATS_H