QPR-12140 updates from quantlib PR

Author: pcaspers

ql/math/randomnumbers/burley2020sobolrsg.cpp

@@ -74,12 +74,12 @@ namespace QuantLib {
             119u, 247u, 15u,  143u, 79u,  207u, 47u,  175u, 111u, 239u, 31u,  159u, 95u,  223u,
             63u,  191u, 127u, 255u};
 
-        std::uint32_t reverseBits(std::uint32_t x) {
+        inline std::uint32_t reverseBits(std::uint32_t x) {
             return (bitReverseTable[x & 0xff] << 24) | (bitReverseTable[(x >> 8) & 0xff] << 16) |
                    (bitReverseTable[(x >> 16) & 0xff] << 8) | (bitReverseTable[(x >> 24) & 0xff]);
         }
 
-        std::uint32_t laine_karras_permutation(std::uint32_t x, std::uint32_t seed) {
+        inline std::uint32_t laine_karras_permutation(std::uint32_t x, std::uint32_t seed) {
             x += seed;
             x ^= x * 0x6c50b47cu;
             x ^= x * 0xb82f1e52u;
@@ -88,26 +88,38 @@ namespace QuantLib {
             return x;
         }
 
-        std::uint32_t nested_uniform_scramble(std::uint32_t x, std::uint32_t seed) {
+        inline std::uint32_t nested_uniform_scramble(std::uint32_t x, std::uint32_t seed) {
             x = reverseBits(x);
             x = laine_karras_permutation(x, seed);
             x = reverseBits(x);
             return x;
         }
 
         // the results depend a lot on the details of the hash_combine() function that is used
-        // we use the 64bit version of hash_combine() as it is implemented here:
+        // we use hash_combine() calling hash(), hash_mix() as implemented here:
         // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/hash.hpp#L560
+        // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/hash.hpp#L115
         // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/detail/hash_mix.hpp#L67
 
-        void local_hash_combine(std::uint64_t& x, const uint64_t v) {
+        inline std::uint64_t local_hash_mix(std::uint64_t x) {
             const std::uint64_t m = 0xe9846af9b1a615d;
-            x += 0x9e3779b9 + std::hash<std::uint64_t>()(v);
             x ^= x >> 32;
             x *= m;
             x ^= x >> 32;
             x *= m;
             x ^= x >> 28;
+            return x;
+        }
+
+        inline std::uint64_t local_hash(const std::uint64_t v) {
+            std::uint64_t seed = 0;
+            seed = (v >> 32) + local_hash_mix(seed);
+            seed = (v & 0xFFFFFFFF) + local_hash_mix(seed);
+            return seed;
+        }
+
+        inline std::uint64_t local_hash_combine(std::uint64_t x, const uint64_t v) {
+            return local_hash_mix(x + 0x9e3779b9 + local_hash(v));
         }
     }
 
@@ -119,7 +131,7 @@ namespace QuantLib {
         do {
             std::uint64_t seed = group4Seeds_[group++];
             for (Size g = 0; g < 4 && i < dimensionality_; ++g, ++i) {
-                local_hash_combine(seed, g);
+                seed = local_hash_combine(seed, g);
                 integerSequence_[i] =
                     nested_uniform_scramble(integerSequence_[i], static_cast<std::uint32_t>(seed));
             }

ql/math/randomnumbers/burley2020sobolrsg.hpp

@@ -17,7 +17,7 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-/*! \file burley2020scrambling.hpp
+/*! \file burley2020sobolrsg.hpp
     \brief scrambled Sobol sequence following Burley, 2020
 */
 

ql/math/randomnumbers/sobolrsg.cpp

@@ -78793,7 +78793,7 @@ namespace QuantLib {
                 }
             }
         } else {
-            std::fill(integerSequence_.begin(), integerSequence_.end(), 0.0);
+            std::fill(integerSequence_.begin(), integerSequence_.end(), 0u);
             std::uint_least32_t mask = 1;
             for (Size index = 0; index < bits_; index++) {
                 if ((N & mask) != 0U) {

ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.hpp

@@ -91,11 +91,10 @@ namespace QuantLib {
 
     class SobolBrownianGeneratorFactory : public BrownianGeneratorFactory {
       public:
-        SobolBrownianGeneratorFactory(
-                           SobolBrownianGenerator::Ordering ordering,
-                           unsigned long seed = 0,
-                           SobolRsg::DirectionIntegers directionIntegers
-                                                         = SobolRsg::Jaeckel);
+        explicit SobolBrownianGeneratorFactory(
+            SobolBrownianGenerator::Ordering ordering,
+            unsigned long seed = 0,
+            SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel);
         ext::shared_ptr<BrownianGenerator> create(Size factors, Size steps) const override;
 
       private:
@@ -121,7 +120,7 @@ namespace QuantLib {
 
     class Burley2020SobolBrownianGeneratorFactory : public BrownianGeneratorFactory {
       public:
-        Burley2020SobolBrownianGeneratorFactory(
+        explicit Burley2020SobolBrownianGeneratorFactory(
             SobolBrownianGenerator::Ordering ordering,
             unsigned long seed = 42,
             SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel,