xorshift.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_RANDOM_XORSHIFT_HPP
#define TETL_RANDOM_XORSHIFT_HPP
 
#include <etl/_concepts/unsigned_integral.hpp>
#include <etl/_cstdint/uint_t.hpp>
#include <etl/_limits/numeric_limits.hpp>
#include <etl/_type_traits/is_same.hpp>
 
namespace etl {

template <unsigned_integral UInt, UInt X, UInt Y, UInt Z>
struct xorshift {
    using result_type                  = UInt;
    static constexpr auto default_seed = result_type{5489U};
 
    constexpr xorshift() = default;
 
    explicit constexpr xorshift(result_type seed) noexcept
        : _state{seed}
    {
    }
 
    [[nodiscard]] static constexpr auto min() noexcept -> result_type { return numeric_limits<result_type>::min(); }
 
    [[nodiscard]] static constexpr auto max() noexcept -> result_type { return numeric_limits<result_type>::max() - 1; }
 
    constexpr auto seed(result_type value = default_seed) noexcept -> void { _state = value; }
 
    constexpr auto discard(unsigned long long z) noexcept -> void
    {
        for (auto i{0ULL}; i < z; ++i) {
            (void)(*this)();
        }
    }
 
    [[nodiscard]] constexpr auto operator()() noexcept -> result_type
    {
        auto s = _state;
        s ^= s << result_type(X);
        s ^= s >> result_type(Y);
        s ^= s << result_type(Z);
        return _state = s;
    }
 
    [[nodiscard]] friend constexpr auto operator==(xorshift const& lhs, xorshift const& rhs) noexcept -> bool
    {
        return lhs._state == rhs._state;
    }
 
private:
    result_type _state{default_seed};
};

using xorshift16 = xorshift<uint16_t, 7, 9, 8>;

using xorshift32 = xorshift<uint32_t, 13, 17, 5>;

using xorshift64 = xorshift<uint64_t, 13, 7, 17>;
 
} // namespace etl
 
#endif // TETL_RANDOM_XORSHIFT_HPP