From 59fb676e401fc67b72b92aa8f232e996e5f65664 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 03:34:17 +0200
Subject: [PATCH 01/12] Remove detail/reverse.hpp

---
 include/boost/hash2/detail/reverse.hpp | 105 -------------------------
 test/Jamfile                           |   1 -
 test/detail_reverse.cpp                |  40 ----------
 3 files changed, 146 deletions(-)
 delete mode 100644 include/boost/hash2/detail/reverse.hpp
 delete mode 100644 test/detail_reverse.cpp

diff --git a/include/boost/hash2/detail/reverse.hpp b/include/boost/hash2/detail/reverse.hpp
deleted file mode 100644
index bfab480..0000000
--- a/include/boost/hash2/detail/reverse.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef BOOST_HASH2_DETAIL_REVERSE_HPP_INCLUDED
-#define BOOST_HASH2_DETAIL_REVERSE_HPP_INCLUDED
-
-// Copyright 2024 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <cstdint>
-#include <cstring>
-#include <cstdlib>
-
-namespace boost
-{
-namespace hash2
-{
-namespace detail
-{
-
-template<std::size_t N> void reverse( unsigned char (&d)[ N ], void const* s )
-{
-    unsigned char const* s2 = static_cast<unsigned char const*>( s );
-
-    for( std::size_t i = 0; i < N; ++i )
-    {
-        d[ i ] = s2[ N-1-i ];
-    }
-}
-
-#if defined(__GNUC__) || defined(__clang__)
-
-inline void reverse( unsigned char (&d)[ 2 ], void const* s )
-{
-    std::uint16_t tmp;
-    std::memcpy( &tmp, s, 2 );
-    tmp = __builtin_bswap16( tmp );
-    std::memcpy( d, &tmp, 2 );
-}
-
-inline void reverse( unsigned char (&d)[ 4 ], void const* s )
-{
-    std::uint32_t tmp;
-    std::memcpy( &tmp, s, 4 );
-    tmp = __builtin_bswap32( tmp );
-    std::memcpy( d, &tmp, 4 );
-}
-
-inline void reverse( unsigned char (&d)[ 8 ], void const* s )
-{
-    std::uint64_t tmp;
-    std::memcpy( &tmp, s, 8 );
-    tmp = __builtin_bswap64( tmp );
-    std::memcpy( d, &tmp, 8 );
-}
-
-inline void reverse( unsigned char (&d)[ 16 ], void const* s )
-{
-    std::uint64_t tmp[ 2 ];
-    std::memcpy( tmp, s, 16 );
-
-    std::uint64_t tmp2[ 2 ] = { __builtin_bswap64( tmp[1] ), __builtin_bswap64( tmp[0] ) };
-    std::memcpy( d, tmp2, 16 );
-}
-
-#elif defined(_MSC_VER)
-
-inline void reverse( unsigned char (&d)[ 2 ], void const* s )
-{
-    unsigned short tmp;
-    std::memcpy( &tmp, s, 2 );
-    tmp = _byteswap_ushort( tmp );
-    std::memcpy( d, &tmp, 2 );
-}
-
-inline void reverse( unsigned char (&d)[ 4 ], void const* s )
-{
-    unsigned long tmp;
-    std::memcpy( &tmp, s, 4 );
-    tmp = _byteswap_ulong( tmp );
-    std::memcpy( d, &tmp, 4 );
-}
-
-inline void reverse( unsigned char (&d)[ 8 ], void const* s )
-{
-    unsigned long long tmp;
-    std::memcpy( &tmp, s, 8 );
-    tmp = _byteswap_uint64( tmp );
-    std::memcpy( d, &tmp, 8 );
-}
-
-inline void reverse( unsigned char (&d)[ 16 ], void const* s )
-{
-    unsigned long long tmp[ 2 ];
-    std::memcpy( tmp, s, 16 );
-
-    unsigned long long tmp2[ 2 ] = { _byteswap_uint64( tmp[1] ), _byteswap_uint64( tmp[0] ) };
-    std::memcpy( d, tmp2, 16 );
-}
-
-#endif
-
-} // namespace detail
-} // namespace hash2
-} // namespace boost
-
-#endif // #ifndef BOOST_HASH2_DETAIL_REVERSE_HPP_INCLUDED
diff --git a/test/Jamfile b/test/Jamfile
index 166a3b3..b7036d1 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -41,7 +41,6 @@ run detail_read.cpp ;
 run detail_write.cpp ;
 run detail_write_2.cpp ;
 run detail_rot.cpp ;
-run detail_reverse.cpp ;
 run detail_has_tag_invoke.cpp ;
 
 # hash_append
diff --git a/test/detail_reverse.cpp b/test/detail_reverse.cpp
deleted file mode 100644
index 93f252e..0000000
--- a/test/detail_reverse.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2024 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/hash2/detail/reverse.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<std::size_t N> void test()
-{
-    unsigned char v[ N ] = {};
-    for( std::size_t i = 0; i < N; ++i ) v[ i ] = static_cast<unsigned char>( i + 1 );
-
-    unsigned char w[ N ] = {};
-    boost::hash2::detail::reverse( w, v );
-
-    for( std::size_t i = 0; i < N; ++i ) BOOST_TEST_EQ( w[ i ], v[ N - 1 - i ] );
-}
-
-int main()
-{
-    test<1>();
-    test<2>();
-    test<3>();
-    test<4>();
-    test<5>();
-    test<6>();
-    test<7>();
-    test<8>();
-    test<9>();
-    test<10>();
-    test<11>();
-    test<12>();
-    test<13>();
-    test<14>();
-    test<15>();
-    test<16>();
-    test<17>();
-
-    return boost::report_errors();
-}

From 8b3d1a8e05d8fad714c0fecd9a43dae3fcd49cb6 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 18:42:35 +0200
Subject: [PATCH 02/12] Add static assertions to get_integral_result

---
 include/boost/hash2/get_integral_result.hpp | 30 +++++++++++++--------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/include/boost/hash2/get_integral_result.hpp b/include/boost/hash2/get_integral_result.hpp
index 7ccef06..d56e411 100644
--- a/include/boost/hash2/get_integral_result.hpp
+++ b/include/boost/hash2/get_integral_result.hpp
@@ -5,9 +5,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/hash2/digest.hpp>
 #include <boost/hash2/detail/read.hpp>
-#include <array>
 #include <type_traits>
 #include <cstddef>
 
@@ -20,7 +18,13 @@ template<class T, class R>
     typename std::enable_if<std::is_integral<R>::value && (sizeof(R) >= sizeof(T)), T>::type
     get_integral_result( R const & r )
 {
+    static_assert( std::is_integral<T>::value, "T must be integral" );
+    static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );
+
+    static_assert( std::is_unsigned<R>::value, "R must be unsigned" );
+
     typedef typename std::make_unsigned<T>::type U;
+
     return static_cast<T>( static_cast<U>( r ) );
 }
 
@@ -28,21 +32,25 @@ template<class T, class R>
     typename std::enable_if<std::is_integral<R>::value && sizeof(R) == 4 && sizeof(T) == 8, T>::type
     get_integral_result( R const & r )
 {
+    static_assert( std::is_integral<T>::value, "T must be integral" );
+    static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );
+
+    static_assert( std::is_unsigned<R>::value, "R must be unsigned" );
+
     typedef typename std::make_unsigned<T>::type U;
+
     return static_cast<T>( ( static_cast<U>( r ) << 32 ) + r );
 }
 
-template<class T, std::size_t N>
-    T get_integral_result( std::array<unsigned char, N> const & r )
+template<class T, class R>
+    typename std::enable_if< !std::is_integral<R>::value, T >::type
+    get_integral_result( R const & r )
 {
-    static_assert( N >= 8, "Array result type is too short" );
-    return static_cast<T>( detail::read64le( r.data() ) );
-}
+    static_assert( std::is_integral<T>::value, "T must be integral" );
+    static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );
+
+    static_assert( R().size() >= 8, "Array-like result type is too short" );
 
-template<class T, std::size_t N>
-    T get_integral_result( digest<N> const & r )
-{
-    static_assert( N >= 8, "Digest result type is too short" );
     return static_cast<T>( detail::read64le( r.data() ) );
 }
 

From a7c172b0ac5762a67fa0c780ea59b0e366d99559 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 18:48:22 +0200
Subject: [PATCH 03/12] Generalize the expansion case of get_integral_result

---
 include/boost/hash2/get_integral_result.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/include/boost/hash2/get_integral_result.hpp b/include/boost/hash2/get_integral_result.hpp
index d56e411..8bf9ac1 100644
--- a/include/boost/hash2/get_integral_result.hpp
+++ b/include/boost/hash2/get_integral_result.hpp
@@ -7,6 +7,7 @@
 
 #include <boost/hash2/detail/read.hpp>
 #include <type_traits>
+#include <limits>
 #include <cstddef>
 
 namespace boost
@@ -29,7 +30,7 @@ template<class T, class R>
 }
 
 template<class T, class R>
-    typename std::enable_if<std::is_integral<R>::value && sizeof(R) == 4 && sizeof(T) == 8, T>::type
+    typename std::enable_if<std::is_integral<R>::value && (sizeof(R) < sizeof(T)), T>::type
     get_integral_result( R const & r )
 {
     static_assert( std::is_integral<T>::value, "T must be integral" );
@@ -39,7 +40,9 @@ template<class T, class R>
 
     typedef typename std::make_unsigned<T>::type U;
 
-    return static_cast<T>( ( static_cast<U>( r ) << 32 ) + r );
+    constexpr U m = std::numeric_limits<U>::max() / std::numeric_limits<R>::max();
+
+    return static_cast<T>( r * m );
 }
 
 template<class T, class R>

From 275890b7d0550f568a447ac28545417224b26744 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 19:20:29 +0200
Subject: [PATCH 04/12] Change test/get_integral_result.cpp to only test
 whether invocations compile, and not the exact output values

---
 test/get_integral_result.cpp | 131 ++++++++++++++---------------------
 1 file changed, 51 insertions(+), 80 deletions(-)

diff --git a/test/get_integral_result.cpp b/test/get_integral_result.cpp
index c844979..58f2495 100644
--- a/test/get_integral_result.cpp
+++ b/test/get_integral_result.cpp
@@ -1,94 +1,65 @@
-// Copyright 2017, 2018 Peter Dimov.
+// Copyright 2017, 2018, 2024 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/hash2/get_integral_result.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cstdint>
+#include <boost/hash2/digest.hpp>
+#include <boost/array.hpp>
 #include <array>
-#include <cstddef>
+
+template<class R> void test()
+{
+    using boost::hash2::get_integral_result;
+
+    R r = {};
+
+    get_integral_result<signed char>( r );
+    get_integral_result<unsigned char>( r );
+    get_integral_result<short>( r );
+    get_integral_result<unsigned short>( r );
+    get_integral_result<int>( r );
+    get_integral_result<unsigned int>( r );
+    get_integral_result<long>( r );
+    get_integral_result<unsigned long>( r );
+    get_integral_result<long long>( r );
+    get_integral_result<unsigned long long>( r );
+
+    get_integral_result<char>( r );
+    get_integral_result<char16_t>( r );
+    get_integral_result<char32_t>( r );
+}
 
 int main()
 {
     using boost::hash2::get_integral_result;
 
-    {
-        std::uint32_t u32 = 0x12345678;
+    test<unsigned char>();
+    test<unsigned short>();
+    test<unsigned int>();
+    test<unsigned long>();
+    test<unsigned long long>();
 
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( u32 ), 0x78 );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( u32 ), 0x78 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( u32 ), 0x5678 );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( u32 ), 0x5678 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( u32 ), 0x12345678 );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( u32 ), 0x12345678 );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( u32 ), 0x1234567812345678ull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( u32 ), 0x1234567812345678ull );
-    }
+    test< std::array<unsigned char, 8> >();
+    test< std::array<unsigned char, 16> >();
+    test< std::array<unsigned char, 20> >();
+    test< std::array<unsigned char, 28> >();
+    test< std::array<unsigned char, 32> >();
+    test< std::array<unsigned char, 48> >();
+    test< std::array<unsigned char, 64> >();
 
-    {
-        std::uint32_t s32 = 0xFFFFFFFFu;
+    test< boost::array<unsigned char, 8> >();
+    test< boost::array<unsigned char, 16> >();
+    test< boost::array<unsigned char, 20> >();
+    test< boost::array<unsigned char, 28> >();
+    test< boost::array<unsigned char, 32> >();
+    test< boost::array<unsigned char, 48> >();
+    test< boost::array<unsigned char, 64> >();
 
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( s32 ), 0xFF );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( s32 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( s32 ), 0xFFFF );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( s32 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( s32 ), 0xFFFFFFFFu );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( s32 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( s32 ), 0xFFFFFFFFFFFFFFFFull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( s32 ), -1 );
-    }
-
-    {
-        std::uint64_t u64 = 0x0123456789ABCDEFull;
-
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( u64 ), 0xEF );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( u64 ), -0x11 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( u64 ), 0xCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( u64 ), -0x3211 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( u64 ), 0x89ABCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( u64 ), 0x89ABCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( u64 ), 0x0123456789ABCDEFull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( u64 ), 0x0123456789ABCDEFull );
-    }
-
-    {
-        std::uint64_t s64 = 0xFFFFFFFFFFFFFFFFull;
-
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( s64 ), 0xFF );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( s64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( s64 ), 0xFFFF );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( s64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( s64 ), 0xFFFFFFFFu );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( s64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( s64 ), 0xFFFFFFFFFFFFFFFFull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( s64 ), -1 );
-    }
-
-    {
-        std::array<unsigned char, 8> a64 = {{ 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01 }};
-
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( a64 ), 0xEF );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( a64 ), -0x11 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( a64 ), 0xCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( a64 ), -0x3211 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( a64 ), 0x89ABCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( a64 ), 0x89ABCDEF );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( a64 ), 0x0123456789ABCDEFull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( a64 ), 0x0123456789ABCDEFull );
-    }
-
-    {
-        std::array<unsigned char, 8> b64 = {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }};
-
-        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( b64 ), 0xFF );
-        BOOST_TEST_EQ( get_integral_result<std::int8_t>( b64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( b64 ), 0xFFFF );
-        BOOST_TEST_EQ( get_integral_result<std::int16_t>( b64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( b64 ), 0xFFFFFFFFu );
-        BOOST_TEST_EQ( get_integral_result<std::int32_t>( b64 ), -1 );
-        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( b64 ), 0xFFFFFFFFFFFFFFFFull );
-        BOOST_TEST_EQ( get_integral_result<std::int64_t>( b64 ), -1 );
-    }
-
-    return boost::report_errors();
+    test< boost::hash2::digest<8> >();
+    test< boost::hash2::digest<16> >();
+    test< boost::hash2::digest<20> >();
+    test< boost::hash2::digest<28> >();
+    test< boost::hash2::digest<32> >();
+    test< boost::hash2::digest<48> >();
+    test< boost::hash2::digest<64> >();
 }

From d4a36acb7e605bb0105131777a9d962d77a886f3 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 19:34:01 +0200
Subject: [PATCH 05/12] Add test/get_integral_result_2.cpp

---
 test/Jamfile                   |  6 ++-
 test/get_integral_result_2.cpp | 78 ++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 test/get_integral_result_2.cpp

diff --git a/test/Jamfile b/test/Jamfile
index b7036d1..470c2b7 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -30,9 +30,13 @@ run is_trivially_equality_comparable.cpp ;
 run is_endian_independent.cpp ;
 run has_constant_size.cpp ;
 
-# helpers
+# get_integral_result
 
 run get_integral_result.cpp ;
+run get_integral_result_2.cpp ;
+
+# digest
+
 run digest.cpp ;
 
 # detail
diff --git a/test/get_integral_result_2.cpp b/test/get_integral_result_2.cpp
new file mode 100644
index 0000000..0697d9f
--- /dev/null
+++ b/test/get_integral_result_2.cpp
@@ -0,0 +1,78 @@
+// Copyright 2017, 2018, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/hash2/get_integral_result.hpp>
+#include <boost/hash2/digest.hpp>
+#include <boost/array.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <array>
+#include <cstdint>
+
+template<class R> void test( R const& r )
+{
+    using boost::hash2::get_integral_result;
+
+    {
+        auto t1 = get_integral_result<signed char>( r );
+        auto t2 = get_integral_result<unsigned char>( r );
+
+        BOOST_TEST_EQ( static_cast<unsigned char>( t1 ), t2 );
+    }
+
+    {
+        auto t1 = get_integral_result<signed short>( r );
+        auto t2 = get_integral_result<unsigned short>( r );
+
+        BOOST_TEST_EQ( static_cast<unsigned short>( t1 ), t2 );
+    }
+
+    {
+        auto t1 = get_integral_result<signed int>( r );
+        auto t2 = get_integral_result<unsigned int>( r );
+
+        BOOST_TEST_EQ( static_cast<unsigned int>( t1 ), t2 );
+    }
+
+    {
+        auto t1 = get_integral_result<signed long>( r );
+        auto t2 = get_integral_result<unsigned long>( r );
+
+        BOOST_TEST_EQ( static_cast<unsigned long>( t1 ), t2 );
+    }
+
+    {
+        auto t1 = get_integral_result<signed long long>( r );
+        auto t2 = get_integral_result<unsigned long long>( r );
+
+        BOOST_TEST_EQ( static_cast<unsigned long long>( t1 ), t2 );
+    }
+}
+
+int main()
+{
+    using boost::hash2::get_integral_result;
+
+    test<std::uint8_t>( 0x1E );
+    test<std::uint8_t>( 0xE1 );
+
+    test<std::uint16_t>( 0x1E1E );
+    test<std::uint16_t>( 0xE1E1 );
+
+    test<std::uint32_t>( 0x1E1E1E1Eu );
+    test<std::uint32_t>( 0xE1E1E1E1u );
+
+    test<std::uint64_t>( 0x1E1E1E1E1E1E1E1Eull );
+    test<std::uint64_t>( 0xE1E1E1E1E1E1E1E1ull );
+
+    test< std::array<unsigned char, 8> >( {{ 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E }} );
+    test< std::array<unsigned char, 8> >( {{ 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1 }} );
+
+    test< boost::array<unsigned char, 8> >( {{ 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E }} );
+    test< boost::array<unsigned char, 8> >( {{ 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1 }} );
+
+    test< boost::hash2::digest<8> >( {{ 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E }} );
+    test< boost::hash2::digest<8> >( {{ 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1 }} );
+
+    return boost::report_errors();
+}

From 1a00a202967c9542344cac4836fffe16be875bb5 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 19:39:28 +0200
Subject: [PATCH 06/12] Add test/get_integral_result_3.cpp

---
 test/Jamfile                   |  1 +
 test/get_integral_result_3.cpp | 50 ++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 test/get_integral_result_3.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 470c2b7..9be1e18 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -34,6 +34,7 @@ run has_constant_size.cpp ;
 
 run get_integral_result.cpp ;
 run get_integral_result_2.cpp ;
+run get_integral_result_3.cpp ;
 
 # digest
 
diff --git a/test/get_integral_result_3.cpp b/test/get_integral_result_3.cpp
new file mode 100644
index 0000000..0e561eb
--- /dev/null
+++ b/test/get_integral_result_3.cpp
@@ -0,0 +1,50 @@
+// Copyright 2017, 2018, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/hash2/get_integral_result.hpp>
+#include <boost/hash2/digest.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/array.hpp>
+#include <cstdint>
+#include <array>
+
+template<class R> void test()
+{
+    using boost::hash2::get_integral_result;
+
+    {
+        R a64 = {{ 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01 }};
+
+        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( a64 ), 0xEF );
+        BOOST_TEST_EQ( get_integral_result<std::int8_t>( a64 ), -0x11 );
+        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( a64 ), 0xCDEF );
+        BOOST_TEST_EQ( get_integral_result<std::int16_t>( a64 ), -0x3211 );
+        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( a64 ), 0x89ABCDEF );
+        BOOST_TEST_EQ( get_integral_result<std::int32_t>( a64 ), 0x89ABCDEF );
+        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( a64 ), 0x0123456789ABCDEFull );
+        BOOST_TEST_EQ( get_integral_result<std::int64_t>( a64 ), 0x0123456789ABCDEFull );
+    }
+
+    {
+        R b64 = {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }};
+
+        BOOST_TEST_EQ( get_integral_result<std::uint8_t>( b64 ), 0xFF );
+        BOOST_TEST_EQ( get_integral_result<std::int8_t>( b64 ), -1 );
+        BOOST_TEST_EQ( get_integral_result<std::uint16_t>( b64 ), 0xFFFF );
+        BOOST_TEST_EQ( get_integral_result<std::int16_t>( b64 ), -1 );
+        BOOST_TEST_EQ( get_integral_result<std::uint32_t>( b64 ), 0xFFFFFFFFu );
+        BOOST_TEST_EQ( get_integral_result<std::int32_t>( b64 ), -1 );
+        BOOST_TEST_EQ( get_integral_result<std::uint64_t>( b64 ), 0xFFFFFFFFFFFFFFFFull );
+        BOOST_TEST_EQ( get_integral_result<std::int64_t>( b64 ), -1 );
+    }
+}
+
+int main()
+{
+    test< std::array<unsigned char, 8> >();
+    test< boost::array<unsigned char, 8> >();
+    test< boost::hash2::digest<8> >();
+
+    return boost::report_errors();
+}

From 97c52f533c91b5f239cfb6d8003dbe1892f34cb4 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 19:59:02 +0200
Subject: [PATCH 07/12] Add test/get_integral_result_4.cpp

---
 test/Jamfile                   |  1 +
 test/get_integral_result_4.cpp | 86 ++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+)
 create mode 100644 test/get_integral_result_4.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 9be1e18..df6197b 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -35,6 +35,7 @@ run has_constant_size.cpp ;
 run get_integral_result.cpp ;
 run get_integral_result_2.cpp ;
 run get_integral_result_3.cpp ;
+run get_integral_result_4.cpp ;
 
 # digest
 
diff --git a/test/get_integral_result_4.cpp b/test/get_integral_result_4.cpp
new file mode 100644
index 0000000..caa46c8
--- /dev/null
+++ b/test/get_integral_result_4.cpp
@@ -0,0 +1,86 @@
+// Copyright 2017, 2018, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/hash2/get_integral_result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <set>
+#include <limits>
+#include <cstdint>
+
+template<class T> void test_identity()
+{
+    using boost::hash2::get_integral_result;
+
+    using R = T;
+
+    for( unsigned i = 0; i <= std::numeric_limits<T>::max(); ++i )
+    {
+        R r = static_cast<R>( i );
+        T t = get_integral_result<T>( r );
+
+        BOOST_TEST_EQ( t, r );
+    }
+}
+
+template<class T, class R> void test_permutation( R offset = 0, R scale = 1 )
+{
+    using boost::hash2::get_integral_result;
+
+    std::set<T> dist;
+
+    for( unsigned i = 0; i <= std::numeric_limits<T>::max(); ++i )
+    {
+        R r = static_cast<R>( i * scale + offset );
+        T t = get_integral_result<T>( r );
+
+        dist.insert( t );
+    }
+
+    BOOST_TEST_EQ( dist.size(), std::numeric_limits<T>::max() + 1u );
+}
+
+template<class T, class R> void test_roundtrip()
+{
+    using boost::hash2::get_integral_result;
+
+    std::set<T> dist;
+
+    for( unsigned i = 0; i <= std::numeric_limits<T>::max(); ++i )
+    {
+        T t1 = static_cast<T>( i );
+        R r = get_integral_result<R>( t1 );
+        T t2 = get_integral_result<T>( r );
+
+        dist.insert( t2 );
+    }
+
+    BOOST_TEST_EQ( dist.size(), std::numeric_limits<T>::max() + 1u );
+}
+
+int main()
+{
+    test_identity<std::uint8_t>();
+
+    test_permutation<std::uint8_t, std::uint8_t>();
+    test_permutation<std::uint8_t, std::uint16_t>();
+    test_permutation<std::uint8_t, std::uint32_t>();
+    test_permutation<std::uint8_t, std::uint64_t>();
+
+    test_roundtrip<std::uint8_t, std::uint8_t>();
+    test_roundtrip<std::uint8_t, std::uint16_t>();
+    test_roundtrip<std::uint8_t, std::uint32_t>();
+    test_roundtrip<std::uint8_t, std::uint64_t>();
+
+    test_identity<std::uint16_t>();
+
+    test_permutation<std::uint16_t, std::uint16_t>();
+    test_permutation<std::uint16_t, std::uint32_t>();
+    test_permutation<std::uint16_t, std::uint64_t>();
+
+    test_roundtrip<std::uint16_t, std::uint16_t>();
+    test_roundtrip<std::uint16_t, std::uint32_t>();
+    test_roundtrip<std::uint16_t, std::uint64_t>();
+
+    return boost::report_errors();
+}

From 37dc776e69c9d9b2cfee93fd2f5109706a70efa0 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 20:12:13 +0200
Subject: [PATCH 08/12] Avoid GCC 4.8 warning

---
 test/get_integral_result.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/get_integral_result.cpp b/test/get_integral_result.cpp
index 58f2495..c910b55 100644
--- a/test/get_integral_result.cpp
+++ b/test/get_integral_result.cpp
@@ -11,7 +11,7 @@ template<class R> void test()
 {
     using boost::hash2::get_integral_result;
 
-    R r = {};
+    R r = R();
 
     get_integral_result<signed char>( r );
     get_integral_result<unsigned char>( r );

From 7981f63b61b4306b3624e79619b580419472e864 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sat, 16 Nov 2024 20:16:37 +0200
Subject: [PATCH 09/12] Add test/get_integral_result_5.cpp

---
 test/Jamfile                   |  1 +
 test/get_integral_result_5.cpp | 74 ++++++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 test/get_integral_result_5.cpp

diff --git a/test/Jamfile b/test/Jamfile
index df6197b..037da97 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -36,6 +36,7 @@ run get_integral_result.cpp ;
 run get_integral_result_2.cpp ;
 run get_integral_result_3.cpp ;
 run get_integral_result_4.cpp ;
+run get_integral_result_5.cpp ;
 
 # digest
 
diff --git a/test/get_integral_result_5.cpp b/test/get_integral_result_5.cpp
new file mode 100644
index 0000000..20e2226
--- /dev/null
+++ b/test/get_integral_result_5.cpp
@@ -0,0 +1,74 @@
+// Copyright 2017, 2018, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/hash2/get_integral_result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <set>
+#include <limits>
+#include <cstdint>
+
+using T = std::uint32_t;
+
+void test_identity()
+{
+    using boost::hash2::get_integral_result;
+
+    using R = T;
+
+    for( unsigned i = 0; i < 65536; ++i )
+    {
+        R r = static_cast<R>( i * 0x9E3779B9u );
+        T t = get_integral_result<T>( r );
+
+        BOOST_TEST_EQ( t, r );
+    }
+}
+
+template<class R> void test_permutation( R offset = 0, R scale = 1 )
+{
+    using boost::hash2::get_integral_result;
+
+    std::set<T> dist;
+
+    for( unsigned i = 0; i < 65536; ++i )
+    {
+        R r = static_cast<R>( i * 0x9E3779B9u * scale + offset );
+        T t = get_integral_result<T>( r );
+
+        dist.insert( t );
+    }
+
+    BOOST_TEST_EQ( dist.size(), 65536u );
+}
+
+template<class R> void test_roundtrip()
+{
+    using boost::hash2::get_integral_result;
+
+    std::set<T> dist;
+
+    for( unsigned i = 0; i < 65536; ++i )
+    {
+        T t1 = static_cast<T>( i * 0x9E3779B9u );
+        R r = get_integral_result<R>( t1 );
+        T t2 = get_integral_result<T>( r );
+
+        dist.insert( t2 );
+    }
+
+    BOOST_TEST_EQ( dist.size(), 65536u );
+}
+
+int main()
+{
+    test_identity();
+
+    test_permutation<std::uint32_t>();
+    test_permutation<std::uint64_t>();
+
+    test_roundtrip<std::uint32_t>();
+    test_roundtrip<std::uint64_t>();
+
+    return boost::report_errors();
+}

From 6699f2c36d62216227cce97ac9a32c24d801b93a Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Nov 2024 21:31:52 +0200
Subject: [PATCH 10/12] Update implementation of get_integral_result

---
 include/boost/hash2/get_integral_result.hpp | 132 +++++++++++++++++++-
 test/get_integral_result_4.cpp              |  71 ++++++++---
 2 files changed, 179 insertions(+), 24 deletions(-)

diff --git a/include/boost/hash2/get_integral_result.hpp b/include/boost/hash2/get_integral_result.hpp
index 8bf9ac1..c6742f4 100644
--- a/include/boost/hash2/get_integral_result.hpp
+++ b/include/boost/hash2/get_integral_result.hpp
@@ -15,8 +15,124 @@ namespace boost
 namespace hash2
 {
 
+namespace detail
+{
+
+// identity
+
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == sizeof(U), U>::type
+    get_result_multiplier()
+{
+    return 1;
+}
+
+// contraction
+
+// 2 -> 1
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 1, R>::type
+    get_result_multiplier()
+{
+    return 0xBF01;
+}
+
+// 4 -> 1
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 1, R>::type
+    get_result_multiplier()
+{
+    return 0x7F7F7F7Fu;
+}
+
+// 8 -> 1
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 1, R>::type
+    get_result_multiplier()
+{
+    return 0x7F7F7F7F7F7F7F7Full;
+}
+
+// 4 -> 2
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 2, R>::type
+    get_result_multiplier()
+{
+    return 0xBFFF0001u;
+}
+
+// 8 -> 2
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 2, R>::type
+    get_result_multiplier()
+{
+    return 0xBFFFBFFFBFFFBFFFull;
+}
+
+// 8 -> 4
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 4, R>::type
+    get_result_multiplier()
+{
+    return 0xBFFFFFFF00000001ull;
+}
+
+// expansion
+
+// 1 -> 2
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 2, U>::type
+    get_result_multiplier()
+{
+    return 0x7F7F;
+}
+
+// 1 -> 4
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 4, U>::type
+    get_result_multiplier()
+{
+    return 0xBFBFBFBFu;
+}
+
+// 1 -> 8
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 8, U>::type
+    get_result_multiplier()
+{
+    return 0xDFDFDFDFDFDFDFDFull;
+}
+
+// 2 -> 4
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 4, U>::type
+    get_result_multiplier()
+{
+    return 0x7FFF7FFFu;
+}
+
+// 2 -> 8
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 8, U>::type
+    get_result_multiplier()
+{
+    return 0x7FFF7FFF7FFF7FFFull;
+}
+
+// 4 -> 8
+template<class U, class R>
+    constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 8, U>::type
+    get_result_multiplier()
+{
+    return 0x7FFFFFFF7FFFFFFFull;
+}
+
+} // namespace detail
+
+// contraction
+
 template<class T, class R>
-    typename std::enable_if<std::is_integral<R>::value && (sizeof(R) >= sizeof(T)), T>::type
+    typename std::enable_if<std::is_integral<R>::value && (sizeof(R) > sizeof(T)), T>::type
     get_integral_result( R const & r )
 {
     static_assert( std::is_integral<T>::value, "T must be integral" );
@@ -26,11 +142,15 @@ template<class T, class R>
 
     typedef typename std::make_unsigned<T>::type U;
 
-    return static_cast<T>( static_cast<U>( r ) );
+    constexpr auto m = detail::get_result_multiplier<U, R>();
+
+    return static_cast<T>( static_cast<U>( ( r * m ) >> ( std::numeric_limits<R>::digits - std::numeric_limits<U>::digits ) ) );
 }
 
+// identity or expansion
+
 template<class T, class R>
-    typename std::enable_if<std::is_integral<R>::value && (sizeof(R) < sizeof(T)), T>::type
+    typename std::enable_if<std::is_integral<R>::value && (sizeof(R) <= sizeof(T)), T>::type
     get_integral_result( R const & r )
 {
     static_assert( std::is_integral<T>::value, "T must be integral" );
@@ -40,11 +160,13 @@ template<class T, class R>
 
     typedef typename std::make_unsigned<T>::type U;
 
-    constexpr U m = std::numeric_limits<U>::max() / std::numeric_limits<R>::max();
+    constexpr auto m = detail::get_result_multiplier<U, R>();
 
-    return static_cast<T>( r * m );
+    return static_cast<T>( static_cast<U>( r * m ) );
 }
 
+// array-like R
+
 template<class T, class R>
     typename std::enable_if< !std::is_integral<R>::value, T >::type
     get_integral_result( R const & r )
diff --git a/test/get_integral_result_4.cpp b/test/get_integral_result_4.cpp
index caa46c8..b7c4a46 100644
--- a/test/get_integral_result_4.cpp
+++ b/test/get_integral_result_4.cpp
@@ -23,7 +23,7 @@ template<class T> void test_identity()
     }
 }
 
-template<class T, class R> void test_permutation( R offset = 0, R scale = 1 )
+template<class T, class R> std::size_t test_permutation( int shift )
 {
     using boost::hash2::get_integral_result;
 
@@ -31,16 +31,16 @@ template<class T, class R> void test_permutation( R offset = 0, R scale = 1 )
 
     for( unsigned i = 0; i <= std::numeric_limits<T>::max(); ++i )
     {
-        R r = static_cast<R>( i * scale + offset );
+        R r = static_cast<R>( i << shift );
         T t = get_integral_result<T>( r );
 
         dist.insert( t );
     }
 
-    BOOST_TEST_EQ( dist.size(), std::numeric_limits<T>::max() + 1u );
+    return dist.size();
 }
 
-template<class T, class R> void test_roundtrip()
+template<class T, class R> std::size_t test_roundtrip()
 {
     using boost::hash2::get_integral_result;
 
@@ -55,32 +55,65 @@ template<class T, class R> void test_roundtrip()
         dist.insert( t2 );
     }
 
-    BOOST_TEST_EQ( dist.size(), std::numeric_limits<T>::max() + 1u );
+    return dist.size();
 }
 
 int main()
 {
+    // 1 -> 1
+
     test_identity<std::uint8_t>();
 
-    test_permutation<std::uint8_t, std::uint8_t>();
-    test_permutation<std::uint8_t, std::uint16_t>();
-    test_permutation<std::uint8_t, std::uint32_t>();
-    test_permutation<std::uint8_t, std::uint64_t>();
+    // 1 -> 2
 
-    test_roundtrip<std::uint8_t, std::uint8_t>();
-    test_roundtrip<std::uint8_t, std::uint16_t>();
-    test_roundtrip<std::uint8_t, std::uint32_t>();
-    test_roundtrip<std::uint8_t, std::uint64_t>();
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint16_t>( 0 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint16_t>( 8 )), 256u );
+
+    BOOST_TEST_GE( (test_roundtrip<std::uint8_t, std::uint16_t>()), 255u ); // !
+
+    // 1 -> 4
+
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint32_t>(  0 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint32_t>(  8 )), 256u );
+    BOOST_TEST_GE( (test_permutation<std::uint8_t, std::uint32_t>( 16 )), 255u ); // !
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint32_t>( 24 )), 256u );
+
+    BOOST_TEST_EQ( (test_roundtrip<std::uint8_t, std::uint32_t>()), 256u );
+
+    // 1 -> 8
+
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>(  0 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>(  8 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 16 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 24 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 32 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 40 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 48 )), 256u );
+    BOOST_TEST_EQ( (test_permutation<std::uint8_t, std::uint64_t>( 56 )), 256u );
+
+    BOOST_TEST_EQ( (test_roundtrip<std::uint8_t, std::uint64_t>()), 256u );
+
+    // 2 -> 2
 
     test_identity<std::uint16_t>();
 
-    test_permutation<std::uint16_t, std::uint16_t>();
-    test_permutation<std::uint16_t, std::uint32_t>();
-    test_permutation<std::uint16_t, std::uint64_t>();
+    // 2 -> 4
 
-    test_roundtrip<std::uint16_t, std::uint16_t>();
-    test_roundtrip<std::uint16_t, std::uint32_t>();
-    test_roundtrip<std::uint16_t, std::uint64_t>();
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint32_t>(  0 )), 65536u );
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint32_t>( 16 )), 65536u );
+
+    BOOST_TEST_GE( (test_roundtrip<std::uint16_t, std::uint32_t>()), 65535u ); // !
+
+    // 2 -> 8
+
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint64_t>(  0 )), 65536u );
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint64_t>( 16 )), 65536u );
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint64_t>( 32 )), 65536u );
+    BOOST_TEST_EQ( (test_permutation<std::uint16_t, std::uint64_t>( 48 )), 65536u );
+
+    BOOST_TEST_EQ( (test_roundtrip<std::uint16_t, std::uint64_t>()), 65536u );
+
+    //
 
     return boost::report_errors();
 }

From 75c33fd4b374ac08c52640092b65371436ff0c02 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Sun, 17 Nov 2024 21:36:37 +0200
Subject: [PATCH 11/12] Update test/append_set.cpp, append_map.cpp;
 hash_append_unordered_range is sensitive to
 get_integral_result<std::uint64_t>( h.result() )

---
 test/append_map.cpp | 4 ++--
 test/append_set.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/append_map.cpp b/test/append_map.cpp
index 59e6aca..c4b57cb 100644
--- a/test/append_map.cpp
+++ b/test/append_map.cpp
@@ -71,10 +71,10 @@ int main()
     test< fnv1a_32, little_endian_flavor, std::multimap<int, int> >( 1082144933ul );
     test< fnv1a_64, little_endian_flavor, std::multimap<int, int> >( 12051529320333828229ull );
 
-    test< fnv1a_32, little_endian_flavor, std::unordered_map<int, int> >( 1094735330ul );
+    test< fnv1a_32, little_endian_flavor, std::unordered_map<int, int> >( 2445282413ul );
     test< fnv1a_64, little_endian_flavor, std::unordered_map<int, int> >( 2617313294186790738ull );
 
-    test< fnv1a_32, little_endian_flavor, std::unordered_multimap<int, int> >( 1094735330ul );
+    test< fnv1a_32, little_endian_flavor, std::unordered_multimap<int, int> >( 2445282413ul );
     test< fnv1a_64, little_endian_flavor, std::unordered_multimap<int, int> >( 2617313294186790738ull );
 
     return boost::report_errors();
diff --git a/test/append_set.cpp b/test/append_set.cpp
index d5296a2..9c1f3a4 100644
--- a/test/append_set.cpp
+++ b/test/append_set.cpp
@@ -69,10 +69,10 @@ int main()
     test< fnv1a_32, little_endian_flavor, std::multiset<int> >( 3576652581ul );
     test< fnv1a_64, little_endian_flavor, std::multiset<int> >( 17046016161958689285ull );
 
-    test< fnv1a_32, little_endian_flavor, std::unordered_set<int> >( 3782055292ul );
+    test< fnv1a_32, little_endian_flavor, std::unordered_set<int> >( 776982489ul );
     test< fnv1a_64, little_endian_flavor, std::unordered_set<int> >( 3232503781718511241ull );
 
-    test< fnv1a_32, little_endian_flavor, std::unordered_multiset<int> >( 3782055292ul );
+    test< fnv1a_32, little_endian_flavor, std::unordered_multiset<int> >( 776982489ul );
     test< fnv1a_64, little_endian_flavor, std::unordered_multiset<int> >( 3232503781718511241ull );
 
     return boost::report_errors();

From 393e6c967ce5cf94c59cfdb12e5ae0de11625892 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 18 Nov 2024 19:43:58 +0200
Subject: [PATCH 12/12] Update hash_append_fwd.adoc

---
 doc/hash2/reference/hash_append_fwd.adoc | 52 ++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/doc/hash2/reference/hash_append_fwd.adoc b/doc/hash2/reference/hash_append_fwd.adoc
index 8b7c5c7..45849b8 100644
--- a/doc/hash2/reference/hash_append_fwd.adoc
+++ b/doc/hash2/reference/hash_append_fwd.adoc
@@ -35,3 +35,55 @@ struct hash_append_tag;
 } // namespace boost
 ```
 
+The header `boost/hash2/hash_append_fwd.hpp` declares the functions implemented in `boost/hash2/hash_append.hpp`.
+
+It can be used when code wishes to implement `hash_append` support for a user-defined type without physically depending on the implementation of `hash_append`.
+
+## Example
+
+.X.hpp
+[source]
+----
+#include <boost/hash2/hash_append_fwd.hpp>
+#include <vector>
+
+class X
+{
+private:
+
+    int a = -1;
+    std::vector<int> b{ 1, 2, 3 };
+
+    template<class Hash, class Flavor>
+    friend void tag_invoke(
+        boost::hash2::hash_append_tag const&, Hash& h, Flavor const& f, X const& v )
+    {
+        boost::hash2::hash_append( h, f, v.a );
+        boost::hash2::hash_append( h, f, v.b );
+    }
+
+public:
+
+    X() = default;
+};
+----
+
+.main.cpp
+[source]
+----
+#include "X.hpp"
+#include <boost/hash2/hash_append.hpp>
+#include <boost/hash2/md5.hpp>
+#include <iostream>
+
+int main()
+{
+    X x;
+
+    boost::hash2::md5_128 hash;
+    boost::hash2::hash_append( hash, {}, x );
+
+    std::cout << "MD5 digest of x: " << hash.result() << std::endl;
+}
+----
+