368faacac7
This commit reverts 5aaefa51 (and also partly 7f285f48e77 and b6d75682f9, which were related to the original commit). As landed, 5aaefa51 had unintended consequences on some downstream bots and didn't have proper coverage upstream due to a few subtle things. Implementing this is something we should do in libc++, however we'll first need to address a few issues listed in https://reviews.llvm.org/D106124#3349710. Differential Revision: https://reviews.llvm.org/D120683
272 lines
9.2 KiB
C++
272 lines
9.2 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
|
|
#define _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
|
|
|
|
#include <__config>
|
|
#include <__random/is_seed_sequence.h>
|
|
#include <__random/log2.h>
|
|
#include <__utility/move.h>
|
|
#include <iosfwd>
|
|
#include <limits>
|
|
#include <type_traits>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
#include <__undef_macros>
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template<class _Engine, size_t __w, class _UIntType>
|
|
class _LIBCPP_TEMPLATE_VIS independent_bits_engine
|
|
{
|
|
template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
|
|
class __get_n
|
|
{
|
|
static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
|
|
static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
|
|
static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
|
|
static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
|
|
public:
|
|
static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
|
|
};
|
|
public:
|
|
// types
|
|
typedef _UIntType result_type;
|
|
|
|
private:
|
|
_Engine __e_;
|
|
|
|
static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
|
|
static_assert( 0 < __w, "independent_bits_engine invalid parameters");
|
|
static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
|
|
|
|
typedef typename _Engine::result_type _Engine_result_type;
|
|
typedef typename conditional
|
|
<
|
|
sizeof(_Engine_result_type) <= sizeof(result_type),
|
|
result_type,
|
|
_Engine_result_type
|
|
>::type _Working_result_type;
|
|
#ifdef _LIBCPP_CXX03_LANG
|
|
static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
|
|
+ _Working_result_type(1);
|
|
#else
|
|
static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
|
|
+ _Working_result_type(1);
|
|
#endif
|
|
static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
|
|
static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
|
|
static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
|
|
static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
|
|
static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
|
|
static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
|
|
static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
|
|
(_Rp >> __w0) << __w0;
|
|
static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
|
|
(_Rp >> (__w0+1)) << (__w0+1);
|
|
static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
|
|
_Engine_result_type(~0) >> (_EDt - __w0) :
|
|
_Engine_result_type(0);
|
|
static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
|
|
_Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
|
|
_Engine_result_type(~0);
|
|
public:
|
|
static _LIBCPP_CONSTEXPR const result_type _Min = 0;
|
|
static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
|
|
(result_type(1) << __w) - result_type(1);
|
|
static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
|
|
|
|
// engine characteristics
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
|
|
|
|
// constructors and seeding functions
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
independent_bits_engine() {}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit independent_bits_engine(const _Engine& __e)
|
|
: __e_(__e) {}
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit independent_bits_engine(_Engine&& __e)
|
|
: __e_(_VSTD::move(__e)) {}
|
|
#endif // _LIBCPP_CXX03_LANG
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
|
|
template<class _Sseq>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit independent_bits_engine(_Sseq& __q,
|
|
typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
|
|
!is_convertible<_Sseq, _Engine>::value>::type* = 0)
|
|
: __e_(__q) {}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void seed() {__e_.seed();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void seed(result_type __sd) {__e_.seed(__sd);}
|
|
template<class _Sseq>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_seed_sequence<_Sseq, independent_bits_engine>::value,
|
|
void
|
|
>::type
|
|
seed(_Sseq& __q) {__e_.seed(__q);}
|
|
|
|
// generating functions
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
|
|
|
|
// property functions
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const _Engine& base() const _NOEXCEPT {return __e_;}
|
|
|
|
template<class _Eng, size_t _Wp, class _UInt>
|
|
friend
|
|
bool
|
|
operator==(
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
|
|
|
|
template<class _Eng, size_t _Wp, class _UInt>
|
|
friend
|
|
bool
|
|
operator!=(
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
|
|
|
|
template <class _CharT, class _Traits,
|
|
class _Eng, size_t _Wp, class _UInt>
|
|
friend
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
|
|
|
|
template <class _CharT, class _Traits,
|
|
class _Eng, size_t _Wp, class _UInt>
|
|
friend
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __is,
|
|
independent_bits_engine<_Eng, _Wp, _UInt>& __x);
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
result_type __eval(false_type);
|
|
result_type __eval(true_type);
|
|
|
|
template <size_t __count>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static
|
|
typename enable_if
|
|
<
|
|
__count < _Dt,
|
|
result_type
|
|
>::type
|
|
__lshift(result_type __x) {return __x << __count;}
|
|
|
|
template <size_t __count>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static
|
|
typename enable_if
|
|
<
|
|
(__count >= _Dt),
|
|
result_type
|
|
>::type
|
|
__lshift(result_type) {return result_type(0);}
|
|
};
|
|
|
|
template<class _Engine, size_t __w, class _UIntType>
|
|
inline
|
|
_UIntType
|
|
independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
|
|
{
|
|
return static_cast<result_type>(__e_() & __mask0);
|
|
}
|
|
|
|
template<class _Engine, size_t __w, class _UIntType>
|
|
_UIntType
|
|
independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
|
|
{
|
|
result_type _Sp = 0;
|
|
for (size_t __k = 0; __k < __n0; ++__k)
|
|
{
|
|
_Engine_result_type __u;
|
|
do
|
|
{
|
|
__u = __e_() - _Engine::min();
|
|
} while (__u >= __y0);
|
|
_Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
|
|
}
|
|
for (size_t __k = __n0; __k < __n; ++__k)
|
|
{
|
|
_Engine_result_type __u;
|
|
do
|
|
{
|
|
__u = __e_() - _Engine::min();
|
|
} while (__u >= __y1);
|
|
_Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
|
|
}
|
|
return _Sp;
|
|
}
|
|
|
|
template<class _Eng, size_t _Wp, class _UInt>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
|
|
{
|
|
return __x.base() == __y.base();
|
|
}
|
|
|
|
template<class _Eng, size_t _Wp, class _UInt>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator!=(
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
|
|
{
|
|
return !(__x == __y);
|
|
}
|
|
|
|
template <class _CharT, class _Traits,
|
|
class _Eng, size_t _Wp, class _UInt>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
|
const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
|
|
{
|
|
return __os << __x.base();
|
|
}
|
|
|
|
template <class _CharT, class _Traits,
|
|
class _Eng, size_t _Wp, class _UInt>
|
|
basic_istream<_CharT, _Traits>&
|
|
operator>>(basic_istream<_CharT, _Traits>& __is,
|
|
independent_bits_engine<_Eng, _Wp, _UInt>& __x)
|
|
{
|
|
_Eng __e;
|
|
__is >> __e;
|
|
if (!__is.fail())
|
|
__x.__e_ = __e;
|
|
return __is;
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#endif // _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
|