Changed the format dlib uses when it serializes a floating point value.

Previously, we used an ASCII based format.  It now uses a much more efficient
binary format.  The deserialization routines have been made backwards
compatible with the previous format.  So dlib can still deserialize older data
but older software won't be able to read the new format.

dlib/float_details.h

+// Copyright (C) 2013  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_FLOAT_DEtAILS_H__
+#define DLIB_FLOAT_DEtAILS_H__
+
+#include <math.h>
+#include "algs.h"
+#include <limits> 
+
+namespace dlib
+{
+    struct float_details
+    {
+        /*!
+            WHAT THIS OBJECT REPRESENTS
+        !*/
+
+        float_details() :
+            exponent(0), mantissa(0)
+        {}
+
+        const static int16 is_inf  = 32000;
+        const static int16 is_ninf = 32001;
+        const static int16 is_nan  = 32002;
+
+        float_details ( const double&      val) { *this = val; }
+        float_details ( const float&       val) { *this = val; }
+        float_details ( const long double& val) { *this = val; }
+
+        float_details& operator= ( const double&      val) { convert_from_T(val); return *this; }
+        float_details& operator= ( const float&       val) { convert_from_T(val); return *this; }
+        float_details& operator= ( const long double& val) { convert_from_T(val); return *this; }
+
+        operator double      () const { return convert_to_T<double>(); }
+        operator float       () const { return convert_to_T<float>(); }
+        operator long double () const { return convert_to_T<long double>(); }
+
+        int16 exponent;
+        int64 mantissa;
+
+    private:
+
+        double      _frexp(double      v, int* e) const { return frexp(v,e); }
+        float       _frexp(float       v, int* e) const { return frexpf(v,e); }
+        long double _frexp(long double v, int* e) const { return frexpl(v,e); }
+
+        double      _ldexp(double      v, int e) const { return ldexp(v,e); }
+        float       _ldexp(float       v, int e) const { return ldexpf(v,e); }
+        long double _ldexp(long double v, int e) const { return ldexpl(v,e); }
+
+        template <typename T>
+        void convert_from_T (
+            const T& val
+        )
+        {
+            mantissa = 0;
+
+            const int digits = dlib::tmin<std::numeric_limits<T>::digits, 63>::value;
+
+            if (val == std::numeric_limits<T>::infinity())
+            {
+                exponent = is_inf;
+            }
+            else if (val == -std::numeric_limits<T>::infinity())
+            {
+                exponent = is_ninf;
+            }
+            else if (val < std::numeric_limits<T>::infinity())
+            {
+                int exp;
+                mantissa = _frexp(val, &exp)*(((uint64)1)<<digits);
+                exponent = exp - digits;
+
+                // Compact the representation a bit by shifting off any low order bytes 
+                // which are zero in the mantissa.  This makes the numbers in mantissa and
+                // exponent generally smaller which can make serialization and other things
+                // more efficient in some cases.
+                for (int i = 0; i < 8 && ((mantissa&0xFF)==0); ++i)
+                {
+                    mantissa >>= 8;
+                    exponent += 8;
+                }
+            }
+            else
+            {
+                exponent = is_nan;
+            }
+        }
+
+        template <typename T>
+        T convert_to_T (
+        ) const
+        {
+            if (exponent < is_inf)
+                return _ldexp((T)mantissa, exponent);
+            else if (exponent == is_inf)
+                return std::numeric_limits<T>::infinity();
+            else if (exponent == is_ninf)
+                return -std::numeric_limits<T>::infinity();
+            else
+                return std::numeric_limits<T>::quiet_NaN();
+        }
+
+    };
+
+}
+
+#endif // DLIB_FLOAT_DEtAILS_H__
+

dlib/serialize.h

@@ -112,7 +112,11 @@
             and tells you how many of the following bytes are part of the encoded
             number.
 
-
+    FLOATING POINT SERIALIZATION FORMAT
+        To serialize a floating point value we convert it into a float_details object and
+        then serialize the exponent and mantissa values using dlib's integral serialization
+        format.  Therefore, the output is first the exponent and then the mantissa.  Note that
+        the mantissa is a signed integer (i.e. there is not a separate sign bit).
 !*/
 
 
@@ -134,6 +138,7 @@
 #include "unicode.h"
 #include "unicode.h"
 #include "byte_orderer.h"
+#include "float_details.h"
 
 namespace dlib
 {
@@ -453,32 +458,45 @@ namespace dlib
     USE_DEFAULT_INT_SERIALIZATION_FOR(wchar_t)
 #endif
 
+// ----------------------------------------------------------------------------------------
+
+    inline void serialize(
+        const float_details& item,
+        std::ostream& out
+    )
+    {
+        serialize(item.exponent, out);
+        serialize(item.mantissa, out);
+    }
+
+    inline void deserialize(
+        float_details& item,
+        std::istream& in 
+    )
+    {
+        deserialize(item.exponent, in);
+        deserialize(item.mantissa, in);
+    }
+
 // ----------------------------------------------------------------------------------------
 
     template <typename T>
-    inline bool serialize_floating_point (
+    inline void serialize_floating_point (
         const T& item,
         std::ostream& out
     )
     { 
-        std::ios::fmtflags oldflags = out.flags();  
-        out.flags(); 
-        std::streamsize ss = out.precision(35); 
-        if (item == std::numeric_limits<T>::infinity())
-            out << "inf ";
-        else if (item == -std::numeric_limits<T>::infinity())
-            out << "ninf ";
-        else if (item < std::numeric_limits<T>::infinity())
-            out << item << ' '; 
-        else
-            out << "NaN ";
-        out.flags(oldflags); 
-        out.precision(ss); 
-        return (!out);
+        try
+        {
+            float_details temp = item;
+            serialize(temp, out);
+        }
+        catch (serialization_error& e)
+        { throw serialization_error(e.info + "\n   while serializing a floating point number."); }
     }
 
     template <typename T>
-    inline bool deserialize_floating_point (
+    inline bool old_deserialize_floating_point (
         T& item,
         std::istream& in 
     )
@@ -517,40 +535,66 @@ namespace dlib
         return (in.get() != ' ');
     }
 
+    template <typename T>
+    inline void deserialize_floating_point (
+        T& item,
+        std::istream& in 
+    )
+    {
+        // check if the serialized data uses the older ASCII based format.  We can check
+        // this easily because the new format starts with the integer control byte which
+        // always has 0 bits in the positions corresponding to the bitmask 0x70.  Moreover,
+        // since the previous format used ASCII numbers we know that no valid bytes can
+        // have bit values of one in the positions indicated 0x70.  So this test looks at
+        // the first byte and checks if the serialized data uses the old format or the new
+        // format.
+        if ((in.rdbuf()->sgetc()&0x70) == 0)
+        {
+            try
+            {
+                // Use the fast and compact binary serialization format.
+                float_details temp;
+                deserialize(temp, in);
+                item = temp;
+            }
+            catch (serialization_error& e)
+            { throw serialization_error(e.info + "\n   while deserializing a floating point number."); }
+        }
+        else
+        {
+            if (old_deserialize_floating_point(item, in))
+                throw serialization_error("Error deserializing a floating point number.");
+        }
+    }
+
     inline void serialize ( const float& item, std::ostream& out) 
     { 
-        if (serialize_floating_point(item,out))
-            throw serialization_error("Error serializing object of type float"); 
+        serialize_floating_point(item,out);
     }
 
     inline void deserialize (float& item, std::istream& in) 
     { 
-        if (deserialize_floating_point(item,in))
-            throw serialization_error("Error deserializing object of type float");
+        deserialize_floating_point(item,in);
     }
 
     inline void serialize ( const double& item, std::ostream& out) 
     { 
-        if (serialize_floating_point(item,out))
-            throw serialization_error("Error serializing object of type double"); 
+        serialize_floating_point(item,out);
     }
 
     inline void deserialize (double& item, std::istream& in) 
     { 
-        if (deserialize_floating_point(item,in))
-            throw serialization_error("Error deserializing object of type double");
+        deserialize_floating_point(item,in);
     }
 
     inline void serialize ( const long double& item, std::ostream& out) 
     { 
-        if (serialize_floating_point(item,out))
-            throw serialization_error("Error serializing object of type long double"); 
+        serialize_floating_point(item,out);
     }
 
     inline void deserialize ( long double& item, std::istream& in) 
     { 
-        if (deserialize_floating_point(item,in))
-            throw serialization_error("Error deserializing object of type long double");
+        deserialize_floating_point(item,in);
     }
 
 // ----------------------------------------------------------------------------------------