Add float utilities, & float formatting with dragonbox

11 files changed, 224 insertions, 20 deletions

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<is_floating_point T> constexpr T infinity() { return __builtin_inf(); }

+

+template<is_floating_point T> constexpr T nan() { return static_cast<T>(__builtin_nanf("")); }

+

+template<is_floating_point T> constexpr bool is_infinity(T f) { return __builtin_isinf(f); }

+

+template<is_floating_point T> 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<uint64_t>(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<char, kMaxUint64Digits> 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<const char, 2> str)

     {

@@ -161,13 +160,19 @@ void asl::AslFormat(Formatter& f, uint64_t v)
     {

         write_two(s_pairs.subspan(static_cast<isize_t>(v * 2)).first<2>());

     }

-    else if (v > 0 || cursor == kMaxDigits)

+    else if (v > 0 || cursor == kMaxUint64Digits)

     {

         ASL_ASSERT(v < 10);

         write_one(static_cast<char>('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<char, 20> 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 <cstdio>

+#define JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED 0

+#define JKJ_STATIC_DATA_SECTION_DEFINED 0

+#include <dragonbox.h>

 

-// @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<asl::is_floating_point T>

+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<T>(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<isize_t>(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<int>(digits.size());

+            while (decimal.exponent > 0)

+            {

+                isize_t to_write = asl::min(static_cast<isize_t>(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<typename T, int N> struct _is_array_helper<T[N]> : true_type  {};
 

 template<typename T> concept is_array = _is_array_helper<T>::value;

 

+template<typename T> struct _is_floating_point_helper         : false_type {};

+template<>           struct _is_floating_point_helper<float>  : true_type  {};

+template<>           struct _is_floating_point_helper<double> : true_type  {};

+

+template<typename T> concept is_floating_point = _is_floating_point_helper<un_cv_t<T>>::value;

+

 struct niche {};

 

 template<typename T>

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 <asl/float.hpp>

+

+#include <asl/testing/testing.hpp>

+

+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<float>()));

+    ASL_TEST_EXPECT(asl::is_infinity(-asl::infinity<double>()));

+}

+

+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<float>()));

+    ASL_TEST_EXPECT(asl::is_nan(asl::nan<double>()));

+}

+

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<decltype("Hello")>);

 

@@ -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<float>(), -asl::infinity<double>());

+    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<float>());

+    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<const int>);
 static_assert(!asl::is_const<const int*>);

 static_assert(asl::is_const<int* const>);

 

+static_assert(asl::is_floating_point<float>);

+static_assert(asl::is_floating_point<const float>);

+static_assert(asl::is_floating_point<volatile double>);

+static_assert(!asl::is_floating_point<const float&>);

+static_assert(!asl::is_floating_point<int>);

+static_assert(!asl::is_floating_point<C>);

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