zhipuzi_pos_windows/include/boost/random/xoshiro.hpp

/*
 * Copyright Matt Borland 2022 - 2025.
 * Distributed under the Boost Software License, Version 1.0. (See
        * accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See http://www.boost.org for most recent version including documentation.
 *
 * $Id$
 */

#ifndef BOOST_RANDOM_XOSHIRO_HPP
#define BOOST_RANDOM_XOSHIRO_HPP

#include <boost/random/detail/config.hpp>
#include <boost/random/detail/xoshiro_base.hpp>
#include <boost/core/bit.hpp>
#include <array>
#include <cstdint>

namespace boost {
namespace random {

/**
 * This is xoshiro256++ 1.0, one of our all-purpose, rock-solid generators.
 * It has excellent (sub-ns) speed, a state (256 bits) that is large
 * enough for any parallel application, and it passes all tests we are
 * aware of.
 *
 * For generating just floating-point numbers, xoshiro256+ is even faster.
 */
class xoshiro256pp final : public detail::xoshiro_base<xoshiro256pp, 4>
{
private:

    using Base = detail::xoshiro_base<xoshiro256pp, 4>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint64_t result = boost::core::rotl(state_[0] + state_[3], 23) + state_[0];
        const std::uint64_t t = state_[1] << 17;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 45);

        return result;
    }
};

/**
 * This is xoshiro256+ 1.0, our best and fastest generator for floating-point
 * numbers. We suggest to use its upper bits for floating-point
 * generation, as it is slightly faster than xoshiro256++/xoshiro256**. It
 * passes all tests we are aware of except for the lowest three bits,
 * which might fail linearity tests (and just those), so if low linear
 * complexity is not considered an issue (as it is usually the case) it
 * can be used to generate 64-bit outputs, too.
 */

class xoshiro256d final : public detail::xoshiro_base<xoshiro256d, 4, double>
{
private:

    using Base = detail::xoshiro_base<xoshiro256d, 4, double>;

public:

    using Base::Base;

    inline std::uint64_t next_int() noexcept
    {
        const std::uint64_t result = state_[0] + state_[3];
        const std::uint64_t t = state_[1] << 17;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 45);

        return result;
    }

    inline result_type next() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((next_int() >> 11)) * 0x1.0p-53;
        #else
        return static_cast<double>((next_int() >> 11)) * 1.11022302462515654e-16;
        #endif
    }

    static constexpr result_type (min)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 0x1.0p-53;
        #else
        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 1.11022302462515654e-16;
        #endif
    }

    static constexpr result_type (max)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)()) * 0x1.0p-53;
        #else
        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)()) * 1.11022302462515654e-16;
        #endif
    }
};

/**
 * This is xoshiro256** 1.0, one of our all-purpose, rock-solid
 * generators. It has excellent (sub-ns) speed, a state (256 bits) that is
 * large enough for any parallel application, and it passes all tests we
 * are aware of.
 *
 * For generating just floating-point numbers, xoshiro256+ is even faster.
 */

class xoshiro256mm final : public detail::xoshiro_base<xoshiro256mm, 4>
{
private:

    using Base = detail::xoshiro_base<xoshiro256mm, 4>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint64_t result = boost::core::rotl(state_[1] * 5, 7) * 9U;
        const std::uint64_t t = state_[1] << 17;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 45);

        return result;
    }
};

/**
 * This is xoshiro512++ 1.0, one of our all-purpose, rock-solid
 * generators. It has excellent (about 1ns) speed, a state (512 bits) that
 * is large enough for any parallel application, and it passes all tests
 * we are aware of.
 *
 * For generating just floating-point numbers, xoshiro512+ is even faster.
 *
 * The state must be seeded so that it is not everywhere zero. If you have
 * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
 * output to fill s.
 */

class xoshiro512pp final : public detail::xoshiro_base<xoshiro512pp, 8>
{
private:

    using Base = detail::xoshiro_base<xoshiro512pp, 8>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint64_t result = boost::core::rotl(state_[0] + state_[2], 17) + state_[2];

        const std::uint64_t t = state_[1] << 11;

        state_[2] ^= state_[0];
        state_[5] ^= state_[1];
        state_[1] ^= state_[2];
        state_[7] ^= state_[3];
        state_[3] ^= state_[4];
        state_[4] ^= state_[5];
        state_[0] ^= state_[6];
        state_[6] ^= state_[7];

        state_[6] ^= t;

        state_[7] = boost::core::rotl(state_[7], 21);

        return result;
    }
};

/**
 * This is xoshiro512** 1.0, one of our all-purpose, rock-solid generators
 * with increased state size. It has excellent (about 1ns) speed, a state
 * (512 bits) that is large enough for any parallel application, and it
 * passes all tests we are aware of.
 *
 * For generating just floating-point numbers, xoshiro512+ is even faster.
 *
 * The state must be seeded so that it is not everywhere zero. If you have
 * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
 *  output to fill s.
 */

class xoshiro512mm final : public detail::xoshiro_base<xoshiro512mm, 8>
{
private:

    using Base = detail::xoshiro_base<xoshiro512mm, 8>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint64_t result = boost::core::rotl(state_[1] * 5, 7) * 9;

        const std::uint64_t t = state_[1] << 11;

        state_[2] ^= state_[0];
        state_[5] ^= state_[1];
        state_[1] ^= state_[2];
        state_[7] ^= state_[3];
        state_[3] ^= state_[4];
        state_[4] ^= state_[5];
        state_[0] ^= state_[6];
        state_[6] ^= state_[7];

        state_[6] ^= t;

        state_[7] = boost::core::rotl(state_[7], 21);

        return result;
    }
};

/**
 * This is xoshiro512+ 1.0, our generator for floating-point numbers with
 * increased state size. We suggest to use its upper bits for
 * floating-point generation, as it is slightly faster than xoshiro512**.
 * It passes all tests we are aware of except for the lowest three bits,
 * which might fail linearity tests (and just those), so if low linear
 * complexity is not considered an issue (as it is usually the case) it
 * can be used to generate 64-bit outputs, too.
 *
 * We suggest to use a sign test to extract a random Boolean value, and
 * right shifts to extract subsets of bits.
 *
 * The state must be seeded so that it is not everywhere zero. If you have
 * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
 *  output to fill s.
 */

class xoshiro512d final : public detail::xoshiro_base<xoshiro512d, 8, double>
{
private:

    using Base = detail::xoshiro_base<xoshiro512d, 8, double>;

public:

    using Base::Base;

    inline std::uint64_t next_int() noexcept
    {
        const std::uint64_t result = state_[0] + state_[2];

        const std::uint64_t t = state_[1] << 11;

        state_[2] ^= state_[0];
        state_[5] ^= state_[1];
        state_[1] ^= state_[2];
        state_[7] ^= state_[3];
        state_[3] ^= state_[4];
        state_[4] ^= state_[5];
        state_[0] ^= state_[6];
        state_[6] ^= state_[7];

        state_[6] ^= t;

        state_[7] = boost::core::rotl(state_[7], 21);

        return result;
    }

    inline result_type next() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((next_int() >> 11)) * 0x1.0p-53;
        #else
        return static_cast<double>((next_int() >> 11)) * 1.11022302462515654e-16;
        #endif
    }

    static constexpr result_type (min)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 0x1.0p-53;
        #else
        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 1.11022302462515654e-16;
        #endif
    }

    static constexpr result_type (max)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)() >> 11) * 0x1.0p-53;
        #else
        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)() >> 11) * 1.11022302462515654e-16;
        #endif
    }
};

/**
 * This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid
 * generators. It has excellent speed, a state size (128 bits) that is
 * large enough for mild parallelism, and it passes all tests we are aware
 * of.
 *
 * For generating just single-precision (i.e., 32-bit) floating-point
 * numbers, xoshiro128+ is even faster.
 *
 * The state must be seeded so that it is not everywhere zero.
 */
class xoshiro128pp final : public detail::xoshiro_base<xoshiro128pp, 4, std::uint32_t, std::uint32_t>
{
private:

    using Base = detail::xoshiro_base<xoshiro128pp, 4, std::uint32_t, std::uint32_t>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint32_t result = boost::core::rotl(state_[0] + state_[3], 7) + state_[0];

        const std::uint32_t t = state_[1] << 9;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 11);

        return result;
    }
};

/**
 * This is xoshiro128** 1.1, one of our 32-bit all-purpose, rock-solid
 * generators. It has excellent speed, a state size (128 bits) that is
 * large enough for mild parallelism, and it passes all tests we are aware
 * of.
 *
 * Note that version 1.0 had mistakenly state_[0] instead of state_[1] as state
 * word passed to the scrambler.
 *
 * For generating just single-precision (i.e., 32-bit) floating-point
 * numbers, xoshiro128+ is even faster.
 *
 * The state must be seeded so that it is not everywhere zero.
 */
class xoshiro128mm final : public detail::xoshiro_base<xoshiro128mm, 4, std::uint32_t, std::uint32_t>
{
private:

    using Base = detail::xoshiro_base<xoshiro128mm, 4, std::uint32_t, std::uint32_t>;

public:

    using Base::Base;

    inline result_type next() noexcept
    {
        const std::uint32_t result = boost::core::rotl(state_[1] * 5, 7) * 9;

        const std::uint32_t t = state_[1] << 9;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 11);

        return result;
    }
};

/**
 * This is xoshiro128+ 1.0, our best and fastest 32-bit generator for 32-bit
 * floating-point numbers. We suggest to use its upper bits for
 * floating-point generation, as it is slightly faster than xoshiro128**.
 * It passes all tests we are aware of except for
 * linearity tests, as the lowest four bits have low linear complexity, so
 * if low linear complexity is not considered an issue (as it is usually
 * the case) it can be used to generate 32-bit outputs, too.
 *
 * We suggest to use a sign test to extract a random Boolean value, and
 * right shifts to extract subsets of bits.
 *
 * The state must be seeded so that it is not everywhere zero.
 */

class xoshiro128f final : public detail::xoshiro_base<xoshiro128f, 4, float, std::uint32_t>
{
private:

    using Base = detail::xoshiro_base<xoshiro128f, 4, float, std::uint32_t>;

public:

    using Base::Base;

    inline std::uint32_t next_int() noexcept
    {
        const std::uint32_t result = state_[0] + state_[3];

        const std::uint32_t t = state_[1] << 9;

        state_[2] ^= state_[0];
        state_[3] ^= state_[1];
        state_[1] ^= state_[2];
        state_[0] ^= state_[3];

        state_[2] ^= t;

        state_[3] = boost::core::rotl(state_[3], 11);

        return result;
    }

    inline result_type next() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<float>((next_int() >> 8)) * 0x1.0p-24f;
        #else
        return static_cast<float>((next_int() >> 8)) * 5.9604645e-08f;
        #endif
    }

    static constexpr result_type (min)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<float>((std::numeric_limits<std::uint32_t>::min)() >> 8) * 0x1.0p-24f;
        #else
        return static_cast<float>((std::numeric_limits<std::uint64_t>::min)() >> 8) * 5.9604645e-08f;
        #endif
    }

    static constexpr result_type (max)() noexcept
    {
        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
        return static_cast<float>((std::numeric_limits<std::uint32_t>::max)() >> 8) * 0x1.0p-24f;
        #else
        return static_cast<float>((std::numeric_limits<std::uint64_t>::max)() >> 8) * 5.9604645e-08f;
        #endif
    }
};

} // namespace random
} // namespace boost

#endif //BOOST_RANDOM_XOSHIRO_HPP