[strings] Start from_floating_point

Author: tobiashienzsch

include/etl/_strings/from_floating_point.hpp

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef TETL_STRINGS_FROM_FLOATING_POINT_HPP
+#define TETL_STRINGS_FROM_FLOATING_POINT_HPP
+
+#include <etl/_algorithm/reverse.hpp>
+#include <etl/_concepts/floating_point.hpp>
+#include <etl/_math/ipow.hpp>
+#include <etl/_span/span.hpp>
+#include <etl/_type_traits/conditional.hpp>
+
+namespace etl::strings {
+
+struct from_floating_point_options {
+    bool terminate_with_null = true;
+};
+
+enum struct from_floating_point_error : unsigned char {
+    none,
+    overflow,
+};
+
+struct from_floating_point_result {
+    char* end{nullptr};
+    from_floating_point_error error{from_floating_point_error::none};
+};
+
+template <floating_point Float, from_floating_point_options Options = from_floating_point_options{}>
+[[nodiscard]] constexpr auto from_floating_point(Float val, span<char> out, int precision) -> from_floating_point_result
+{
+    using int_type = conditional_t<(sizeof(Float) > 4), long long, long>;
+
+    constexpr auto toString = [](int_type x, char* str, int numDigits) -> int {
+        int i = 0;
+        while (x) {
+            str[i++] = (x % 10) + '0';
+            x        = x / 10;
+        }
+
+        // If number of digits required is more, then
+        // add 0s at the beginning
+        while (i < numDigits) {
+            str[i++] = '0';
+        }
+
+        etl::reverse(str, str + i);
+        str[i] = '\0';
+        return i;
+    };
+
+    auto* res = out.data();
+
+    auto const whole = static_cast<int_type>(val);
+    auto const frac  = val - static_cast<Float>(whole);
+    auto const pos   = toString(whole, res, 0);
+
+    if (precision == 0) {
+        return {};
+    }
+
+    // Get the value of fraction part upto given no.
+    // of points after dot. The third parameter
+    // is needed to handle cases like 233.007
+    auto part = static_cast<int_type>(frac * static_cast<Float>(etl::ipow<10>(precision)));
+    res[pos]  = '.';
+    toString(part, res + pos + 1, precision);
+
+    return {.end = res + pos};
+}
+
+} // namespace etl::strings
+
+#endif // TETL_STRINGS_FROM_FLOATING_POINT_HPP

include/etl/strings.hpp

@@ -15,6 +15,7 @@
 
 /// Non-standard extensions
 #include <etl/_strings/find.hpp>
+#include <etl/_strings/from_floating_point.hpp>
 #include <etl/_strings/from_integer.hpp>
 #include <etl/_strings/rfind.hpp>
 #include <etl/_strings/to_floating_point.hpp>

tests/strings/CMakeLists.txt

@@ -1,5 +1,6 @@
 project("strings")
 
+tetl_add_test(${PROJECT_NAME} from_floating_point)
 tetl_add_test(${PROJECT_NAME} from_integer)
 tetl_add_test(${PROJECT_NAME} to_floating_point)
 tetl_add_test(${PROJECT_NAME} to_integer)

tests/strings/from_floating_point.t.cpp

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: BSL-1.0
+
+#include <etl/strings.hpp>
+
+#include <etl/array.hpp>
+#include <etl/iterator.hpp>
+#include <etl/string_view.hpp>
+
+#include "testing/approx.hpp"
+#include "testing/testing.hpp"
+
+template <typename Float>
+constexpr auto test() -> bool
+{
+    using namespace etl::strings;
+    using namespace etl::string_view_literals;
+
+    auto test = [](Float in, auto precision, auto out) -> bool {
+        auto buf = etl::array<char, 12>{};
+        auto res = from_floating_point(in, buf, precision);
+        CHECK(res.error == from_floating_point_error::none);
+        CHECK(etl::string_view{buf.data()} == out);
+        return true;
+    };
+
+    CHECK(test(Float(233.007), 0, "233"_sv));
+    CHECK(test(Float(233.007), 1, "233.0"_sv));
+    CHECK(test(Float(233.007), 2, "233.00"_sv));
+    CHECK(test(Float(233.007), 3, "233.007"_sv));
+    CHECK(test(Float(233.007), 4, "233.0070"_sv));
+
+    return true;
+}
+
+auto main() -> int
+{
+    STATIC_CHECK(test<float>());
+    STATIC_CHECK(test<double>());
+    STATIC_CHECK(test<long double>());
+    return 0;
+}