Re: [Boost-users] [serialization]Nans and infinity in wide xml archive

4 Jul 2017

...
-----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