Merge new changes to unordered & hash.

- Unordered tests can run lightweight test or Boost.Test (at least
   theoretically).
 - Workaround Open BSD's incorrect numeric_limits.
 - Move the hash extensions in their own file.
 - Various small improvements to the unordered docs.
 - Fix some unordered examples.

Merged revisions 43117-43837 via svnmerge from 
https://svn.boost.org/svn/boost/branches/unordered/trunk


[SVN r43838]

include/boost/functional/detail/hash_float.hpp

@@ -54,10 +54,43 @@
 
 #endif
 
+// On OpenBSD, numeric_limits is not reliable for long doubles, but
+// the macros defined in <float.h> are.
+
+#if defined(__OpenBSD__)
+#include <float.h>
+#endif
+
 namespace boost
 {
     namespace hash_detail
     {
+        template <class T>
+        struct limits : std::numeric_limits<T> {};
+
+#if defined(__OpenBSD__)
+        template <>
+        struct limits<long double>
+             : std::numeric_limits<long double>
+        {
+            static long double epsilon() {
+                return LDBL_EPSILON;
+            }
+
+            static long double (max)() {
+                return LDBL_MAX;
+            }
+
+            static long double (min)() {
+                return LDBL_MIN;
+            }
+
+            BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG);
+            BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP);
+            BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP);
+        };
+#endif // __OpenBSD__
+
         inline void hash_float_combine(std::size_t& seed, std::size_t value)
         {
             seed ^= value + (seed<<6) + (seed>>2);
@@ -102,29 +135,28 @@ namespace boost
             // sign with the exponent.
             if(v < 0) {
                 v = -v;
-                exp += std::numeric_limits<T>::max_exponent -
-                    std::numeric_limits<T>::min_exponent;
+                exp += limits<T>::max_exponent -
+                    limits<T>::min_exponent;
             }
 
             // The result of frexp is always between 0.5 and 1, so its
             // top bit will always be 1. Subtract by 0.5 to remove that.
             v -= T(0.5);
             v = boost::hash_detail::call_ldexp(v,
-                    std::numeric_limits<std::size_t>::digits + 1);
+                    limits<std::size_t>::digits + 1);
             std::size_t seed = static_cast<std::size_t>(v);
             v -= seed;
 
             // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
             std::size_t const length
-                = (std::numeric_limits<T>::digits *
-                        boost::static_log2<std::numeric_limits<T>::radix>::value
-                        - 1)
-                / std::numeric_limits<std::size_t>::digits;
+                = (limits<T>::digits *
+                        boost::static_log2<limits<T>::radix>::value - 1)
+                / limits<std::size_t>::digits;
 
             for(std::size_t i = 0; i != length; ++i)
             {
                 v = boost::hash_detail::call_ldexp(v,
-                        std::numeric_limits<std::size_t>::digits);
+                        limits<std::size_t>::digits);
                 std::size_t part = static_cast<std::size_t>(v);
                 v -= part;
                 hash_float_combine(seed, part);