Hi Robert I did template specialization of basic_text_iprimitive::load for double, and it works with visual studio 2010 compiler. Do you see something problematic with this code namespace boost { namespace archive { template<> template<> void basic_text_iprimitive< std::basic_istream> >::load<double>(double& t) { if (!is.fail()) { std::wstring s; getline(is, s, L'<'); is.putback(L'<'); int index = s.find(L"IND"); if (index != -1) { t = std::numeric_limits<double>::quiet_NaN(); return; } index = s.find(L"NAN"); if (index != -1) { t = std::numeric_limits<double>::quiet_NaN(); return; } index = s.find(L"INF"); if (index != -1) { t = std::numeric_limits<double>::infinity(); return; } t = std::stod(s); return; } boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); } } } -- View this message in context: http://boost.2283326.n4.nabble.com/serialization-Nans-and-infinity-in-wide-x... Sent from the Boost - Users mailing list archive at Nabble.com.

-----Original Message----- From: Boost-users [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Robert Ramey via Boost-users Sent: 04 July 2017 16:05 To: Elizabeta via Boost-users Cc: Robert Ramey Subject: Re: [Boost-users] [serialization]Nans and infinity in wide xml archive

On 7/4/17 2:48 AM, Elizabeta via Boost-users wrote:

...

Hi Robert I did template specialization of basic_text_iprimitive::load for double, and it works with visual studio 2010 compiler. Do you see something problematic with this code

namespace boost { namespace archive { template<> template<> void basic_text_iprimitive< std::basic_istream> >::load<double>(double& t) { if (!is.fail()) { std::wstring s; getline(is, s, L'<'); is.putback(L'<');

int index = s.find(L"IND"); if (index != -1) { t = std::numeric_limits<double>::quiet_NaN(); return; }

index = s.find(L"NAN"); if (index != -1) { t = std::numeric_limits<double>::quiet_NaN(); return; }

index = s.find(L"INF"); if (index != -1) { t = std::numeric_limits<double>::infinity(); return; }

t = std::stod(s); return; }

boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); } } }

Hmmm - very clever. I have to say the specialization of just one member function is something that would never have occurred to me.

I would wonder though. I'm not sure that the Nan literals are standard. I also don't trust them to be portable. Also to me it's a problem with stream i/o rather than serialization itself. So my instinct would have been to maybe make a custom manipulator or something like that. But still, you've got a solution which looks like it will work well for your needs so good luck with this.

http://www.boost.org/doc/libs/1_64_0/libs/math/doc/html/math_toolkit/fp_face... has some info on this: "C99 standard for output of infinity and NaN The C99 standard does specify how infinity and NaN are formatted by printf and similar output functions, and parsed by scanf and similar input functions. The following string representations are used: Table 2.1. C99 Representation of Infinity and NaN number string Positive infinity "inf" or "infinity" Positive NaN "nan" or "nan(...)" Negative infinity "-inf" or "-infinity" Negative NaN "-nan" or "-nan(...)" So following C99 provides a sensible 'standard' way of handling input and output of nonfinites in C++, and this implementation follows most of these formats." And Elizabeta's solution is close to this. Using lower case might become more 'Standard'. I don't know of any progress in a 'Standard' representation in C++14, 17 .... HTH Paul --- Paul A. Bristow Prizet Farmhouse Kendal UK LA8 8AB +44 (0) 1539 561830