ilds.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cmath>
 
namespace ilds {
 
    using std::array;
 
    // Constants for magic numbers
    constexpr unsigned int DEFAULT_SCALE = 10;
    constexpr unsigned int MAX_REVERSE_BITS = 64;
 
    template <unsigned long Base = 2> class VdCorput {
        unsigned long _count;  
        std::array<unsigned long, MAX_REVERSE_BITS>
            factor_lst;  
        static_assert(MAX_REVERSE_BITS >= sizeof(unsigned long) * 8,
                      "MAX_REVERSE_BITS must be at least the number of bits in unsigned long");
 
      public:
        constexpr explicit VdCorput(unsigned int scale = DEFAULT_SCALE) : _count{0}, factor_lst{} {
            unsigned long factor = static_cast<unsigned long>(std::pow(Base, scale));
            for (unsigned int i = 0; i < MAX_REVERSE_BITS; ++i) {
                factor /= Base;
                this->factor_lst[i] = factor;
            }
        }
 
        [[nodiscard]] constexpr auto pop() -> unsigned long {
            unsigned long count = ++this->_count;
            unsigned long reslt = 0;
            unsigned int idx = 0;
            while (count != 0) {
                const unsigned long remainder = count % Base;
                count /= Base;
                reslt += remainder * this->factor_lst[idx];
                ++idx;
            }
            return reslt;
        }
 
        constexpr auto reseed(const unsigned long& seed) -> void { this->_count = seed; }
 
        VdCorput(VdCorput&&) noexcept = delete;
        VdCorput& operator=(VdCorput&&) noexcept = delete;
    };
 
    template <unsigned long Base1, unsigned long Base2> class Halton {
        VdCorput<Base1> vdc0;
        VdCorput<Base2> vdc1;
 
      public:
        constexpr explicit Halton(const std::array<unsigned int, 2>& scale)
            : vdc0(scale[0]), vdc1(scale[1]) {}
 
        constexpr auto pop() -> array<unsigned long, 2> {  //
            return {this->vdc0.pop(), this->vdc1.pop()};
        }
 
        constexpr auto reseed(const unsigned long& seed) -> void {
            this->vdc0.reseed(seed);
            this->vdc1.reseed(seed);
        }
    };
 
}  // namespace ilds