Loss of precision when serializing <double>

[matspetter]

It seems that precision is lost when serializing a double. I cannot say why since
std::numeric_limits::digits10 should provide enough digits !?
but if I change that to:
std::numeric_limits::digits10 then I'm not loosing anything.
I'm NOT using and "long double" types. Only "double".

[nlohmann]

Do you have an example to check?

[gregmarr]

digits10
number of decimal digits that can be represented without change
that is, any number with this many decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.

max_digits10
number of decimal digits necessary to differentiate all values of this type
that is, the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.

[matspetter]

Ok lets see. This code was run on a Mac.
g++ --version

Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.12.sdk/usr/include/c++/4.2.1
Apple LLVM version 8.0.0 (clang-800.0.42.1)
Target: x86_64-apple-darwin16.1.0

#include <string>
#include <sstream>
#include <iostream>
#include <limits>

int main(int argc,char** argv)
{
    double v = 100000000000.1236;

    int p1 = std::numeric_limits<double>::digits10;
    int p2 = std::numeric_limits<double>::max_digits10;

    // stream with precision == digits10
    std::stringstream ss;
    ss.precision(p1);
    ss << v;
    std::cout << "digits10     " << p1 << ": " << ss.str() << std::endl;

    // stream with precision == max_digits10
    std::stringstream ss2;
    ss2.precision(p2);
    ss2 << v;
    std::cout  << "max_digits10 " << p2 << ": " << ss2.str() << std::endl;

    // Read back and compare with original
    double v1,v2;
    ss >> v1;
    ss2 >> v2;

    std::cout << "v==v1 : " << ((v==v1)?"true":"false") << std::endl;
    std::cout << "v==v2 : " << ((v==v2)?"true":"false") << std::endl;
}

output:

digits10     15: 100000000000.124
max_digits10 17: 100000000000.1236
v==v1 : false
v==v2 : true

It is not easy with floating points and precision but this tells me that the streaming seems more correct when using "max_digits10"

[matspetter]

It also gives the same result/output on a Ubuntu system:
g++ --version
g++ (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609

uname -a
Linux mbergg12-ubuntu15 4.4.0-47-generic #68-Ubuntu SMP Wed Oct 26 19:39:52 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux

[TurpentineDistillery]

This is not a bug, but a reality of dealing with floating-point representation.
If one uses more than digits10 digits of precision, then string->value->string is not guaranteed to round-trip.

[gregmarr]

@TurpentineDistillery However using max_digits10 on output guarantees that value->string->value will not change. The difference being that not all strings of length max_digits10 can be generated by value->string with max_digits10 precision. So as long as string was generated by outputting a value, it's safe. The issue comes when the string was just an arbitrary string of digits.

[nlohmann]

This issue can be closed, right?

[matspetter]

Yes I guess so. /mb

…

Sent from my iPhone On 24 Nov 2016, at 20:46, Niels Lohmann <notifications@github.com<mailto:notifications@github.com>> wrote: This issue can be closed, right? - You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub<#360 (comment)>, or mute the thread<https://github.com/notifications/unsubscribe-auth/AAq6oDYqiPZd1bPmNpaTZ-AvNPG0bUaLks5rBemYgaJpZM4K1d9R>.

[nlohmann]

Thanks for the quick response!

[timueller]

I don't see how this is not a bug. The OP's example exactly illustrates the problem of value -> string -> value serialization/deserialization. We need to store double precision data in a json string form and read it back without loss of precision and have run into exactly the same problem.

[nlohmann]

What would you propose?

[timueller]

Is there a problem if you just switch to using max_digits10 for both dump() and operator<< ?

[nlohmann]

Then numbers like 2312.42 would be round-tripped to 2312.4200000000001.