fix #444: Fix precision when converting double to string

Author: adazem009

include/scratchcpp/value.h

@@ -7,6 +7,7 @@
 #include <limits>
 #include <ctgmath>
 #include <cassert>
+#include <iomanip>
 #include <utf8.h>
 
 #include "global.h"
@@ -40,7 +41,7 @@ class LIBSCRATCHCPP_EXPORT Value
         Value(float numberValue) :
             m_type(Type::Double)
         {
-            m_doubleValue = numberValue;
+            m_doubleValue = floatToDouble(numberValue);
         }
 
         /*! Constructs a number Value. */
@@ -376,7 +377,7 @@ class LIBSCRATCHCPP_EXPORT Value
                 m_stringValue.~basic_string();
 
             m_type = Type::Double;
-            m_doubleValue = v;
+            m_doubleValue = floatToDouble(v);
             return *this;
         }
 
@@ -943,7 +944,7 @@ class LIBSCRATCHCPP_EXPORT Value
         static std::string doubleToString(double v)
         {
             std::stringstream stream;
-            stream << v;
+            stream << std::setprecision(std::max(16u, digitCount(v))) << v;
             std::string s = stream.str();
             std::size_t index;
 
@@ -961,6 +962,33 @@ class LIBSCRATCHCPP_EXPORT Value
 
             return s;
         }
+
+        static double floatToDouble(float v)
+        {
+            unsigned int digits = digitCount(v);
+            double f = std::pow(10, digits);
+            return std::round(v * f) / f;
+        }
+
+        template<typename T>
+        static unsigned int digitCount(T v)
+        {
+            const T epsilon = 0.0000001;
+            T intpart;
+            unsigned int i = 1, j = 0;
+
+            if (std::abs(std::modf(v, &intpart)) >= epsilon) {
+                T tmp_intpart;
+
+                while (std::abs(std::modf(v * std::pow(10, i), &tmp_intpart)) >= epsilon)
+                    i++;
+            }
+
+            while (std::abs(intpart / pow(10, j)) >= 1.0)
+                j++;
+
+            return i + j;
+        }
 };
 
 } // namespace libscratchcpp

test/scratch_classes/value_test.cpp

@@ -20,7 +20,7 @@ TEST(ValueTest, DefaultConstructor)
 TEST(ValueTest, FloatConstructor)
 {
     Value v(3.14f);
-    ASSERT_EQ(v.toDouble(), 3.14f);
+    ASSERT_EQ(v.toDouble(), 3.14);
     ASSERT_EQ(v.type(), Value::Type::Double);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
@@ -385,7 +385,7 @@ TEST(ValueTest, FloatAssignment)
 {
     Value v;
     v = 3.14f;
-    ASSERT_EQ(v.toDouble(), 3.14f);
+    ASSERT_EQ(v.toDouble(), 3.14);
     ASSERT_EQ(v.type(), Value::Type::Double);
     ASSERT_FALSE(v.isInfinity());
     ASSERT_FALSE(v.isNegativeInfinity());
@@ -930,12 +930,12 @@ TEST(ValueTest, ToDouble)
     v = 2.54;
     ASSERT_EQ(v.toDouble(), 2.54);
     v = 2.54f;
-    ASSERT_EQ(v.toDouble(), 2.54f);
+    ASSERT_EQ(v.toDouble(), 2.54);
 
     v = -2.54;
     ASSERT_EQ(v.toDouble(), -2.54);
     v = -2.54f;
-    ASSERT_EQ(v.toDouble(), -2.54f);
+    ASSERT_EQ(v.toDouble(), -2.54);
 
     v = false;
     ASSERT_EQ(v.toDouble(), 0.0);
@@ -1164,6 +1164,20 @@ TEST(ValueTest, ToString)
     ASSERT_EQ(v.toString(), "-999999999999999999");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
 
+    v = 2.0;
+    ASSERT_EQ(v.toString(), "2");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+    v = 2.0f;
+    ASSERT_EQ(v.toString(), "2");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
+    v = -2.0;
+    ASSERT_EQ(v.toString(), "-2");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+    v = -2.0f;
+    ASSERT_EQ(v.toString(), "-2");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
     v = 2.54;
     ASSERT_EQ(v.toString(), "2.54");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
@@ -1178,6 +1192,29 @@ TEST(ValueTest, ToString)
     ASSERT_EQ(v.toString(), "-2.54");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
 
+    v = 2550.625021000115;
+    ASSERT_EQ(v.toString(), "2550.625021000115");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
+    v = 2550.625021000115f;
+    ASSERT_EQ(v.toString(), "2550.625");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
+    v = -2550.625021000115;
+    ASSERT_EQ(v.toString(), "-2550.625021000115");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
+    v = -2550.625021000115f;
+    ASSERT_EQ(v.toString(), "-2550.625");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
+    v = 0.001;
+    ASSERT_EQ(v.toString(), "0.001");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+    v = -0.001;
+    ASSERT_EQ(v.toString(), "-0.001");
+    ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
+
     v = false;
     ASSERT_EQ(v.toString(), "false");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
@@ -1214,10 +1251,10 @@ TEST(ValueTest, ToString)
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
 
     v = "9432.4e+6";
-    ASSERT_EQ(v.toString(), "9.4324e+9");
+    ASSERT_EQ(v.toString(), "9432400000");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
     v = "-9432.4e+6";
-    ASSERT_EQ(v.toString(), "-9.4324e+9");
+    ASSERT_EQ(v.toString(), "-9432400000");
     ASSERT_EQ(utf8::utf16to8(v.toUtf16()), v.toString());
 
     v = "false";