mtcore::io::floats::dragonbox Namespace Reference

Implementation of the dragonbox algorithm to convert floats to strings Uses slices and writers rather than raw char pointers Also, allows for more control over formatting Don't use this namespace directly. More...

Classes
struct	DragonboxFormatOptions
struct	FloatDec64

Functions
template<WriterImpl WI>
Result< size_t, typename Writer< WI >::ErrType >	format_float (Writer< WI > &writer, f64 f, Slice< const char > opts={nullptr, 0})
auto	compute_pow10 (i32 p) -> impl::U128
auto	multiple_of_pow2 (u64 val, i32 exp)
auto	multiple_of_pow5 (u64 val, i32 exp) -> bool
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
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 >

Detailed Description

Implementation of the dragonbox algorithm to convert floats to strings Uses slices and writers rather than raw char pointers Also, allows for more control over formatting Don't use this namespace directly.

Instead, use the Formatter<> class

Function Documentation

compute_pow10()

auto mtcore::io::floats::dragonbox::compute_pow10

(

i32

p

)

-> impl::U128

format_digits()

auto mtcore::io::floats::dragonbox::format_digits	(	Slice< char >	buff,
		u64	digits,
		i32	decExp,
		DragonboxFormatOptions	= {} ) -> Slice< char >

format_float()

template<WriterImpl WI>

Result< size_t, typename Writer< WI >::ErrType > mtcore::io::floats::dragonbox::format_float	(	Writer< WI > &	writer,
		f64	f,
		Slice< const char >	opts = {nullptr, 0} )

Definition at line 159 of file floats.hpp.

                                                                                                                 {
      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);
        }
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

multiple_of_pow2()

auto mtcore::io::floats::dragonbox::multiple_of_pow2	(	u64	val,
		i32	exp )

multiple_of_pow5()

auto mtcore::io::floats::dragonbox::multiple_of_pow5	(	u64	val,
		i32	exp ) -> bool

print_dec_digs_reversed()

auto mtcore::io::floats::dragonbox::print_dec_digs_reversed	(	Slice< char >	buff,
		u64	out ) -> i32

round_compute_pow10_double()

auto mtcore::io::floats::dragonbox::round_compute_pow10_double

(

size_t

d

)

-> double

Here is the caller graph for this function:

to_chars()

auto mtcore::io::floats::dragonbox::to_chars	(	Slice< char >	buff,
		double	val,
		DragonboxFormatOptions	= {} ) -> Result< Slice< char >, SliceWriteError >

Here is the caller graph for this function:

trailing_zeros_2digs()

auto mtcore::io::floats::dragonbox::trailing_zeros_2digs

(

u32

digits

)

-> i8

unsigned_to_ascii_2digs()

void mtcore::io::floats::dragonbox::unsigned_to_ascii_2digs	(	Slice< char >	buff,
		u32	digits )

unsigned_to_ascii_8digits_skip_trailing_zeros()

auto mtcore::io::floats::dragonbox::unsigned_to_ascii_8digits_skip_trailing_zeros	(	Slice< char >	buff,
		u32	digits ) -> i32