From 27c3969e69f5525ccb0bc462a615a14142b5f178 Mon Sep 17 00:00:00 2001 From: Steven Le Rouzic Date: Thu, 28 Nov 2024 23:53:55 +0100 Subject: Add float utilities, & float formatting with dragonbox --- asl/BUILD.bazel | 5 +++ asl/float.hpp | 17 ++++++++ asl/format.cpp | 19 +++++--- asl/format.hpp | 2 + asl/format_float.cpp | 97 ++++++++++++++++++++++++++++++++++++----- asl/meta.hpp | 6 +++ asl/string_view.hpp | 10 +++++ asl/tests/float_tests.cpp | 23 ++++++++++ asl/tests/format_tests.cpp | 27 ++++++++++-- asl/tests/meta_tests.cpp | 6 +++ asl/tests/string_view_tests.cpp | 32 ++++++++++++++ 11 files changed, 224 insertions(+), 20 deletions(-) create mode 100644 asl/float.hpp create mode 100644 asl/tests/float_tests.cpp (limited to 'asl') diff --git a/asl/BUILD.bazel b/asl/BUILD.bazel index b9875ab..391ae9d 100644 --- a/asl/BUILD.bazel +++ b/asl/BUILD.bazel @@ -6,6 +6,7 @@ cc_library( "assert.hpp", "box.hpp", "config.hpp", + "float.hpp", "format.hpp", "functional.hpp", "integers.hpp", @@ -26,6 +27,9 @@ cc_library( "format_float.cpp", "print.cpp", ], + deps = [ + "//vendor/dragonbox", + ], visibility = ["//visibility:public"], ) @@ -41,6 +45,7 @@ cc_library( ], ) for name in [ "box", + "float", "format", "functional", "integers", diff --git a/asl/float.hpp b/asl/float.hpp new file mode 100644 index 0000000..8ecf5fa --- /dev/null +++ b/asl/float.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include "asl/meta.hpp" + +namespace asl +{ + +template constexpr T infinity() { return __builtin_inf(); } + +template constexpr T nan() { return static_cast(__builtin_nanf("")); } + +template constexpr bool is_infinity(T f) { return __builtin_isinf(f); } + +template constexpr bool is_nan(T f) { return __builtin_isnan(f); } + +} // namespace asl + diff --git a/asl/format.cpp b/asl/format.cpp index 6a3e5de..1371431 100644 --- a/asl/format.cpp +++ b/asl/format.cpp @@ -106,7 +106,9 @@ void asl::AslFormat(Formatter& f, uint32_t v) AslFormat(f, static_cast(v)); } -void asl::AslFormat(Formatter& f, uint64_t v) +static constexpr int32_t kMaxUint64Digits = 20; + +asl::string_view asl::format_uint64(uint64_t v, asl::span buffer) { static constexpr char s_pairs_storage[] = { '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', @@ -132,10 +134,7 @@ void asl::AslFormat(Formatter& f, uint64_t v) }; static constexpr span s_pairs = s_pairs_storage; - - static constexpr int32_t kMaxDigits = 20; - char buffer[kMaxDigits]; - int32_t cursor = kMaxDigits; + int32_t cursor = kMaxUint64Digits; auto write_two = [&buffer, &cursor](span str) { @@ -161,13 +160,19 @@ void asl::AslFormat(Formatter& f, uint64_t v) { write_two(s_pairs.subspan(static_cast(v * 2)).first<2>()); } - else if (v > 0 || cursor == kMaxDigits) + else if (v > 0 || cursor == kMaxUint64Digits) { ASL_ASSERT(v < 10); write_one(static_cast('0' + v)); } - f.write(string_view(buffer, kMaxDigits).substr(cursor)); + return string_view(buffer.data(), kMaxUint64Digits).substr(cursor); +} + +void asl::AslFormat(Formatter& f, uint64_t v) +{ + char buffer[kMaxUint64Digits]; + f.write(format_uint64(v, buffer)); } void asl::AslFormat(Formatter& f, int8_t v) diff --git a/asl/format.hpp b/asl/format.hpp index 9504701..ac51693 100644 --- a/asl/format.hpp +++ b/asl/format.hpp @@ -102,4 +102,6 @@ void AslFormat(Formatter& f, int16_t); void AslFormat(Formatter& f, int32_t); void AslFormat(Formatter& f, int64_t); +string_view format_uint64(uint64_t value, span buffer); + } // namespace asl diff --git a/asl/format_float.cpp b/asl/format_float.cpp index 425586f..0a081d5 100644 --- a/asl/format_float.cpp +++ b/asl/format_float.cpp @@ -1,21 +1,98 @@ #include "asl/format.hpp" +#include "asl/float.hpp" -#include +#define JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED 0 +#define JKJ_STATIC_DATA_SECTION_DEFINED 0 +#include -// @Todo Use something like ryu or dragonbox +static constexpr isize_t kZeroCount = 100; +static constexpr char kZeros[kZeroCount] = { + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', +}; + +template +static void format_float(asl::Formatter& f, T value) +{ + if (asl::is_infinity(value)) + { + if (value > 0) + { + f.write("Infinity"_sv); + } + else + { + f.write("-Infinity"_sv); + } + return; + } + + if (value == static_cast(0)) + { + f.write("0"_sv); + return; + } + + if (asl::is_nan(value)) + { + f.write("NaN"_sv); + return; + } + + auto decimal = jkj::dragonbox::to_decimal(value); + + if (decimal.is_negative) { f.write("-"); } + + char buffer[20]; + asl::string_view digits = asl::format_uint64(decimal.significand, buffer); + + if (decimal.exponent >= 0) + { + f.write(digits); + while (decimal.exponent > 0) + { + isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); + f.write(asl::string_view(kZeros, to_write)); + decimal.exponent -= to_write; + } + } + else + { + if (digits.size() <= -decimal.exponent) + { + f.write("0."); + decimal.exponent = -decimal.exponent - static_cast(digits.size()); + while (decimal.exponent > 0) + { + isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); + f.write(asl::string_view(kZeros, to_write)); + decimal.exponent -= to_write; + } + f.write(digits); + } + else + { + f.write(digits.first(digits.size() + decimal.exponent)); + f.write("."); + f.write(digits.last(-decimal.exponent)); + } + } +} void asl::AslFormat(Formatter& f, float value) { - static constexpr isize_t kBufferLength = 64; - char buffer[kBufferLength]; - int output_length = snprintf(buffer, kBufferLength, "%f", (double)value); - f.write(string_view(buffer, output_length)); + format_float(f, value); } void asl::AslFormat(Formatter& f, double value) { - static constexpr isize_t kBufferLength = 64; - char buffer[kBufferLength]; - int output_length = snprintf(buffer, kBufferLength, "%f", value); - f.write(string_view(buffer, output_length)); + format_float(f, value); } diff --git a/asl/meta.hpp b/asl/meta.hpp index ab25a88..35e238b 100644 --- a/asl/meta.hpp +++ b/asl/meta.hpp @@ -160,6 +160,12 @@ template struct _is_array_helper : true_type {}; template concept is_array = _is_array_helper::value; +template struct _is_floating_point_helper : false_type {}; +template<> struct _is_floating_point_helper : true_type {}; +template<> struct _is_floating_point_helper : true_type {}; + +template concept is_floating_point = _is_floating_point_helper>::value; + struct niche {}; template diff --git a/asl/string_view.hpp b/asl/string_view.hpp index 51d4234..c75695c 100644 --- a/asl/string_view.hpp +++ b/asl/string_view.hpp @@ -70,6 +70,16 @@ public: return string_view{m_data + offset, m_size - offset}; // NOLINT(*-pointer-arithmetic) } + constexpr string_view first(isize_t size) const + { + return substr(0, size); + } + + constexpr string_view last(isize_t size) const + { + return substr(m_size - size); + } + constexpr bool operator==(string_view other) const { if (m_size != other.m_size) { return false; } diff --git a/asl/tests/float_tests.cpp b/asl/tests/float_tests.cpp new file mode 100644 index 0000000..981279f --- /dev/null +++ b/asl/tests/float_tests.cpp @@ -0,0 +1,23 @@ +#include + +#include + +ASL_TEST(is_infinity) +{ + ASL_TEST_EXPECT(!asl::is_infinity(0.0F)); + ASL_TEST_EXPECT(!asl::is_infinity(-25.0F)); + ASL_TEST_EXPECT(asl::is_infinity(45.0F / 0.0F)); + ASL_TEST_EXPECT(asl::is_infinity(-45.0F / 0.0F)); + ASL_TEST_EXPECT(asl::is_infinity(asl::infinity())); + ASL_TEST_EXPECT(asl::is_infinity(-asl::infinity())); +} + +ASL_TEST(is_nan) +{ + ASL_TEST_EXPECT(!asl::is_nan(0.0F)); + ASL_TEST_EXPECT(!asl::is_nan(-25.0F)); + ASL_TEST_EXPECT(!asl::is_nan(45.0F / 0.0F)); + ASL_TEST_EXPECT(asl::is_nan(asl::nan())); + ASL_TEST_EXPECT(asl::is_nan(asl::nan())); +} + diff --git a/asl/tests/format_tests.cpp b/asl/tests/format_tests.cpp index dd3db1c..906fce6 100644 --- a/asl/tests/format_tests.cpp +++ b/asl/tests/format_tests.cpp @@ -1,6 +1,7 @@ #include "asl/format.hpp" #include "asl/testing/testing.hpp" #include "asl/allocator.hpp" +#include "asl/float.hpp" static_assert(asl::formattable); @@ -110,11 +111,31 @@ ASL_TEST(format_floats) sink.reset(); asl::format(&sink, "{} {} {}", 0.0F, 1.0, 2.0F); - ASL_TEST_EXPECT(sink.str() == "0.000000 1.000000 2.000000"_sv); + ASL_TEST_EXPECT(sink.str() == "0 1 2"_sv); + + sink.reset(); + asl::format(&sink, "{} {} {}", 0.1F, 0.001F, 0.123F); + ASL_TEST_EXPECT(sink.str() == "0.1 0.001 0.123"_sv); + + sink.reset(); + asl::format(&sink, "{} {}", 1.25F, -22.3); + ASL_TEST_EXPECT(sink.str() == "1.25 -22.3"_sv); + + sink.reset(); + asl::format(&sink, "{}", 1e32); + ASL_TEST_EXPECT(sink.str() == "100000000000000000000000000000000"_sv); + + sink.reset(); + asl::format(&sink, "{}", 123e-8); + ASL_TEST_EXPECT(sink.str() == "0.00000123"_sv); + + sink.reset(); + asl::format(&sink, "{} {}", asl::infinity(), -asl::infinity()); + ASL_TEST_EXPECT(sink.str() == "Infinity -Infinity"_sv); sink.reset(); - asl::format(&sink, "{} {}", 10.25F, -22.3); - ASL_TEST_EXPECT(sink.str() == "10.250000 -22.300000"_sv); + asl::format(&sink, "{}", asl::nan()); + ASL_TEST_EXPECT(sink.str() == "NaN"_sv); } ASL_TEST(format_boolean) diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp index 354cea6..fcafe1c 100644 --- a/asl/tests/meta_tests.cpp +++ b/asl/tests/meta_tests.cpp @@ -203,3 +203,9 @@ static_assert(asl::is_const); static_assert(!asl::is_const); static_assert(asl::is_const); +static_assert(asl::is_floating_point); +static_assert(asl::is_floating_point); +static_assert(asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); +static_assert(!asl::is_floating_point); diff --git a/asl/tests/string_view_tests.cpp b/asl/tests/string_view_tests.cpp index 1340247..708877d 100644 --- a/asl/tests/string_view_tests.cpp +++ b/asl/tests/string_view_tests.cpp @@ -58,6 +58,38 @@ ASL_TEST(substr2) ASL_TEST_ASSERT(s2.size() == 0); } +ASL_TEST(first) +{ + asl::string_view s1 = "abcd"; + + asl::string_view s2 = s1.first(0); + ASL_TEST_ASSERT(s2.size() == 0); + + s2 = s1.first(2); + ASL_TEST_ASSERT(s2.size() == 2); + ASL_TEST_EXPECT(asl::memcmp(s2.data(), "ab", 2) == 0); + + s2 = s1.first(4); + ASL_TEST_ASSERT(s2.size() == 4); + ASL_TEST_EXPECT(asl::memcmp(s2.data(), "abcd", 4) == 0); +} + +ASL_TEST(last) +{ + asl::string_view s1 = "abcd"; + + asl::string_view s2 = s1.last(0); + ASL_TEST_ASSERT(s2.size() == 0); + + s2 = s1.last(2); + ASL_TEST_ASSERT(s2.size() == 2); + ASL_TEST_EXPECT(asl::memcmp(s2.data(), "cd", 2) == 0); + + s2 = s1.last(4); + ASL_TEST_ASSERT(s2.size() == 4); + ASL_TEST_EXPECT(asl::memcmp(s2.data(), "abcd", 4) == 0); +} + ASL_TEST(equal) { ASL_TEST_EXPECT("abc"_sv == "abc"_sv); -- cgit