ilds.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <atomic>
 
#include "lds.hpp"
 
namespace ildsgen {
 
    using std::array;
 
    // Constants for magic numbers
    constexpr unsigned int DEFAULT_SCALE = 10;
    constexpr unsigned int MAX_REVERSE_BITS = 64;
 
    class VdCorput : public ldsgen::GeneratorBase<VdCorput, unsigned long> {
        unsigned long _base;  
        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:
        explicit VdCorput(unsigned long base = 2, unsigned int scale = DEFAULT_SCALE)
            : _base{base} {
            unsigned long factor = 1;
            unsigned int n = scale < MAX_REVERSE_BITS ? scale : MAX_REVERSE_BITS;
            for (unsigned int i = 0; i < n; ++i) {
                factor_lst[n - 1 - i] = factor;
                factor *= _base;
            }
        }
 
        [[nodiscard]] auto value_at(unsigned long n) const -> unsigned long {
            return ldsgen::detail::vdc_digit_sum<unsigned long>(n, this->_base, this->factor_lst);
        }
    };
 
    class Halton : public ldsgen::GeneratorBase<Halton, array<unsigned long, 2>> {
        VdCorput vdc0;
        VdCorput vdc1;
 
      public:
        explicit Halton(const std::array<unsigned long, 2>& base,
                        const std::array<unsigned int, 2>& scale)
            : vdc0(base[0], scale[0]), vdc1(base[1], scale[1]) {}
 
        [[nodiscard]] auto value_at(unsigned long n) const -> array<unsigned long, 2> {
            return {this->vdc0.value_at(n), this->vdc1.value_at(n)};
        }
    };
 
    // Compile-time contract checks: the integer generators satisfy the protocol concept.
    static_assert(ldsgen::SequenceGenerator<VdCorput, unsigned long>);
    static_assert(ldsgen::SequenceGenerator<Halton, array<unsigned long, 2>>);
 
}  // namespace ildsgen