[Boost-commit] svn:boost r53160 - trunk/boost/functional/hash/detail

Subject: [Boost-commit] svn:boost r53160 - trunk/boost/functional/hash/detail
From: daniel_james_at_[hidden]
Date: 2009-05-21 17:21:46

Author: danieljames
Date: 2009-05-21 17:21:44 EDT (Thu, 21 May 2009)
New Revision: 53160
URL: http://svn.boost.org/trac/boost/changeset/53160

Log:
Move the two different hash float implementation into their own header.
Added:
   trunk/boost/functional/hash/detail/hash_float_generic.hpp   (contents, props changed)
   trunk/boost/functional/hash/detail/hash_float_x86.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/functional/hash/detail/hash_float.hpp |   129 +++++++++++---------------------------- 
   1 files changed, 37 insertions(+), 92 deletions(-)

Modified: trunk/boost/functional/hash/detail/hash_float.hpp
==============================================================================
--- trunk/boost/functional/hash/detail/hash_float.hpp	(original)
+++ trunk/boost/functional/hash/detail/hash_float.hpp	2009-05-21 17:21:44 EDT (Thu, 21 May 2009)
@@ -18,123 +18,57 @@
 #endif
 #endif
 
+#include <boost/config.hpp>
 #include <boost/functional/hash/detail/float_functions.hpp>
 #include <boost/functional/hash/detail/limits.hpp>
 #include <boost/integer/static_log2.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/assert.hpp>
 
-// Select implementation for the current platform.
+// Include hash implementation for the current platform.
 
 // Cygwn
 #if defined(__CYGWIN__)
 #  if defined(__i386__) || defined(_M_IX86)
-#    define BOOST_HASH_USE_x86_BINARY_HASH
+#    include <boost/functional/hash/detail/hash_float_x86.hpp>
+#  else
+#    include <boost/functional/hash/detail/hash_float_generic.hpp>
 #  endif
+#else
+#  include <boost/functional/hash/detail/hash_float_generic.hpp>
+#endif
+
+// Can we use fpclassify?
 
 // STLport
-#elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-// fpclassify aren't good enough on STLport.
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#defined BOOST_HASH_USE_FPCLASSIFY 0
 
 // GNU libstdc++ 3
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 #  if (defined(__USE_ISOC99) || defined(_GLIBCXX_USE_C99_MATH)) && \
       !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
-#    define BOOST_HASH_USE_FPCLASSIFY
+#    define BOOST_HASH_USE_FPCLASSIFY 1
+#  else
+#    define BOOST_HASH_USE_FPCLASSIFY 0
 #  endif
 
-// Dinkumware Library, on Visual C++ 
-#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+// Everything else
+#else
+#  define BOOST_HASH_USE_FPCLASSIFY 0
+#endif
 
-// Not using _fpclass because it is only available for double.
+#if BOOST_HASH_USE_FPCLASSIFY
 
-#endif
+#include <boost/config/no_tr1/cmath.hpp>
 
 namespace boost
 {
     namespace hash_detail
     {
-        inline void hash_float_combine(std::size_t& seed, std::size_t value)
-        {
-            seed ^= value + (seed<<6) + (seed>>2);
-        }
-
-// A simple, non-portable hash algorithm for x86.
-#if defined(BOOST_HASH_USE_x86_BINARY_HASH)
-        inline std::size_t float_hash_impl(float v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr;
-            return seed;
-        }
-
-        inline std::size_t float_hash_impl(double v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr++;
-            hash_float_combine(seed, *ptr);
-            return seed;
-        }
-
-        inline std::size_t float_hash_impl(long double v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr++;
-            hash_float_combine(seed, *ptr++);
-            hash_float_combine(seed, *(boost::uint16_t*)ptr);
-            return seed;
-        }
-
-#else
-
-        template <class T>
-        inline std::size_t float_hash_impl(T v)
-        {
-            int exp = 0;
-
-            v = boost::hash_detail::call_frexp(v, &exp);
-
-            // A postive value is easier to hash, so combine the
-            // sign with the exponent.
-            if(v < 0) {
-                v = -v;
-                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,
-                    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
-                = (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,
-                        limits<std::size_t>::digits);
-                std::size_t part = static_cast<std::size_t>(v);
-                v -= part;
-                hash_float_combine(seed, part);
-            }
-
-            hash_float_combine(seed, exp);
-
-            return seed;
-        }
-#endif
-
         template <class T>
         inline std::size_t float_hash_value(T v)
         {
-#if defined(BOOST_HASH_USE_FPCLASSIFY)
             using namespace std;
             switch (fpclassify(v)) {
             case FP_ZERO:
@@ -150,15 +84,26 @@
                 BOOST_ASSERT(0);
                 return 0;
             }
-#else
+        }
+    }
+}
+
+#else // !BOOST_HASH_USE_FPCLASSIFY
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t float_hash_value(T v)
+        {
             return v == 0 ? 0 : float_hash_impl(v);
-#endif
         }
     }
 }
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+#endif // BOOST_HASH_USE_FPCLASSIFY
+
+#undef BOOST_HASH_USE_FPCLASSIFY
 
 #endif

Added: trunk/boost/functional/hash/detail/hash_float_generic.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/functional/hash/detail/hash_float_generic.hpp	2009-05-21 17:21:44 EDT (Thu, 21 May 2009)
@@ -0,0 +1,85 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A general purpose hash function for non-zero floating point values.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER
+
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/integer/static_log2.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
+                              // not satisfy test. Loop body not executed 
+#endif
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        template <class T>
+        inline std::size_t float_hash_impl(T v)
+        {
+            int exp = 0;
+
+            v = boost::hash_detail::call_frexp(v, &exp);
+
+            // A postive value is easier to hash, so combine the
+            // sign with the exponent.
+            if(v < 0) {
+                v = -v;
+                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,
+                    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
+                = (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,
+                        limits<std::size_t>::digits);
+                std::size_t part = static_cast<std::size_t>(v);
+                v -= part;
+                hash_float_combine(seed, part);
+            }
+
+            hash_float_combine(seed, exp);
+
+            return seed;
+        }
+    }
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif
\ No newline at end of file

Added: trunk/boost/functional/hash/detail/hash_float_x86.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/functional/hash/detail/hash_float_x86.hpp	2009-05-21 17:21:44 EDT (Thu, 21 May 2009)
@@ -0,0 +1,56 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A non-portable hash function form non-zero floats on x86.
+//
+// Even if you're on an x86 platform, this might not work if their floating
+// point isn't set up as this expects. So this should only be used if it's
+// absolutely certain that it will work.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER
+
+#include <boost/cstdint.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        inline std::size_t float_hash_impl(float v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr;
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr);
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(long double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr++);
+            hash_float_combine(seed, *(boost::uint16_t*)ptr);
+            return seed;
+        }
+    }
+}
+
+#endif