Classes | Typedefs | Functions | Variables
absl::random_internal Namespace Reference

Classes

struct  DistributionCaller
 
struct  DistributionMoments
 
class  ExplicitSeedSeq
 
class  FastUniformBits
 
class  gaussian_distribution_base
 
struct  GenerateNegativeTag
 
struct  GeneratePositiveTag
 
struct  GenerateSignedTag
 
struct  is_salted_seed_seq
 
struct  is_salted_seed_seq< T, typename std::enable_if< std::is_same< T, SaltedSeedSeq< typename T::inner_sequence_type > >::value >::type >
 
struct  is_urbg
 
struct  is_urbg< URBG, absl::enable_if_t< std::is_same< typename URBG::result_type, typename std::decay< decltype((URBG::min)())>::type >::value >, absl::enable_if_t< std::is_same< typename URBG::result_type, typename std::decay< decltype((URBG::max)())>::type >::value >, absl::enable_if_t< std::is_same< typename URBG::result_type, typename std::decay< decltype(std::declval< URBG >()())>::type >::value > >
 
class  is_widening_convertible
 
struct  IsIntegral
 
struct  IsIntegral< absl::int128 >
 
struct  IsIntegral< absl::uint128 >
 
class  istream_state_saver
 
struct  IsUnsigned
 
struct  IsUnsigned< absl::int128 >
 
struct  IsUnsigned< absl::uint128 >
 
struct  make_unsigned_bits
 
struct  MakeUnsigned
 
struct  MakeUnsigned< absl::int128 >
 
struct  MakeUnsigned< absl::uint128 >
 
class  MockHelpers
 
struct  MockOverloadSet
 
struct  MockOverloadSet< DistrT, FirstSig, Rest... >
 
struct  MockOverloadSet< DistrT, Sig >
 
struct  MockSingleOverload
 
struct  MockSingleOverload< DistrT, Ret(Arg, MockingBitGen &, Args...)>
 
struct  MockSingleOverload< DistrT, Ret(MockingBitGen &, Args...)>
 
class  NonsecureURBGBase
 
class  null_state_saver
 
class  ostream_state_saver
 
class  pcg128_params
 
class  pcg64_params
 
class  pcg_engine
 
struct  pcg_xsh_rr_64_32
 
struct  pcg_xsl_rr_128_64
 
class  PoolURBG
 
class  Randen
 
class  randen_engine
 
class  RandenHwAes
 
class  RandenPool
 
class  RandenPoolSeedSeq
 
class  RandenSlow
 
struct  RandenTraits
 
struct  RejectionLoopTag
 
class  SaltedSeedSeq
 
class  sequence_urbg
 
struct  SimplifiedLoopTag
 
struct  stream_format_type
 
struct  stream_precision_helper
 
struct  stream_precision_helper< double >
 
struct  stream_precision_helper< float >
 
struct  stream_precision_helper< long double >
 
struct  stream_u128_helper
 
struct  stream_u128_helper< absl::uint128 >
 
class  TableGenerator
 
struct  TagTypeCompare
 
struct  U256
 
struct  UniformDistributionWrapper
 
struct  unsigned_bits
 
struct  unsigned_bits< 128 >
 
struct  unsigned_bits< 16 >
 
struct  unsigned_bits< 256 >
 
struct  unsigned_bits< 32 >
 
struct  unsigned_bits< 64 >
 
struct  unsigned_bits< 8 >
 
struct  wide_multiply
 
struct  wide_multiply< uint128 >
 
struct  wide_multiply< uint64_t >
 

Typedefs

using pcg32_2018_engine = pcg_engine< random_internal::pcg64_params< 0x5851f42d4c957f2dull, 0x14057b7ef767814full >, random_internal::pcg_xsh_rr_64_32 >
 
using pcg64_2018_engine = pcg_engine< random_internal::pcg128_params< 0x2360ed051fc65da4ull, 0x4385df649fccf645ull, 0x5851f42d4c957f2d, 0x14057b7ef767814f >, random_internal::pcg_xsl_rr_128_64 >
 
template<typename A , typename B >
using uniform_inferred_return_t = absl::enable_if_t< absl::disjunction< is_widening_convertible< A, B >, is_widening_convertible< B, A > >::value, typename std::conditional< is_widening_convertible< A, B >::value, B, A >::type >
 
template<typename NumType >
using UniformDistribution = typename std::conditional< IsIntegral< NumType >::value, absl::uniform_int_distribution< NumType >, absl::uniform_real_distribution< NumType > >::type
 

Functions

double beta (double p, double q)
 
double BetaIncomplete (const double x, const double p, const double q)
 
double BetaIncompleteInv (const double p, const double q, const double alpha)
 
template<typename T >
int BitWidth (T v)
 
template<typename Iterator , typename Expected >
double ChiSquare (Iterator it, Iterator end, Expected eit, Expected eend)
 
double ChiSquarePValue (double chi_square, int dof)
 
double ChiSquareValue (int dof, double p)
 
template<typename Iterator >
double ChiSquareWithExpected (Iterator begin, Iterator end, double expected)
 
DistributionMoments ComputeDistributionMoments (absl::Span< const double > data_points)
 
bool CPUSupportsRandenHwAes ()
 
double erfinv (double x)
 
template<typename RealType , typename SignedTag = GeneratePositiveTag, bool IncludeZero = true>
RealType GenerateRealFromBits (uint64_t bits, int exp_bias=0)
 
absl::optional< uint32_tGetSaltMaterial ()
 
bool HasRandenHwAesImplementation ()
 
std::vector< std::pair< double, size_t > > InitDiscreteDistribution (std::vector< double > *probabilities)
 
template<typename UIntType >
constexpr UIntType IntegerLog2 (UIntType n)
 
int IntLog2Ceil (uint64_t n)
 
int IntLog2Floor (uint64_t n)
 
double InverseNormalSurvival (double x)
 
template<typename FloatType >
absl::enable_if_t< std::is_floating_point< FloatType >::value, boolis_uniform_range_valid (FloatType a, FloatType b)
 
template<typename IntType >
absl::enable_if_t< IsIntegral< IntType >::value, boolis_uniform_range_valid (IntType a, IntType b)
 
template<typename IntType >
absl::enable_if_t< std::is_integral< IntType >::value, boolis_uniform_range_valid (IntType a, IntType b)
 
template<typename UIntType >
constexpr bool IsPowerOfTwoOrZero (UIntType n)
 
template<typename CharT , typename Traits >
istream_state_saver< std::basic_istream< CharT, Traits > > make_istream_state_saver (std::basic_istream< CharT, Traits > &is, std::ios_base::fmtflags flags=std::ios_base::dec|std::ios_base::scientific|std::ios_base::skipws)
 
template<typename T >
absl::enable_if_t<!std::is_base_of< std::ios_base, T >::value, null_state_saver< T > > make_istream_state_saver (T &is, std::ios_base::fmtflags flags=std::ios_base::dec)
 
template<typename CharT , typename Traits >
ostream_state_saver< std::basic_ostream< CharT, Traits > > make_ostream_state_saver (std::basic_ostream< CharT, Traits > &os, std::ios_base::fmtflags flags=std::ios_base::dec|std::ios_base::left|std::ios_base::scientific)
 
template<typename T >
absl::enable_if_t<!std::is_base_of< std::ios_base, T >::value, null_state_saver< T > > make_ostream_state_saver (T &is, std::ios_base::fmtflags flags=std::ios_base::dec)
 
template<typename SSeq , typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
SSeq MakeSaltedSeedSeq (SSeq &&seq)
 
template<typename SSeq , typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
SaltedSeedSeq< typename std::decay< SSeq >::typeMakeSaltedSeedSeq (SSeq &&seq)
 
template<typename UIntType >
constexpr UIntType MaskFromShift (size_t n)
 
double MaxErrorTolerance (double acceptance_probability)
 
void MixIntoSeedMaterial (absl::Span< const uint32_t > sequence, absl::Span< uint32_t > seed_material)
 
U256 MultiplyU128ToU256 (uint128 a, uint128 b)
 
absl::uint128 MultiplyU64ToU128 (uint64_t a, uint64_t b)
 
bool Near (absl::string_view msg, double actual, double expected, double bound)
 
template<typename URBG >
constexpr size_t NumBits ()
 
template<typename T >
constexpr bool operator!= (TagTypeCompare< T >, TagTypeCompare< T >)
 
std::ostream & operator<< (std::ostream &os, const DistributionMoments &moments)
 
template<typename T >
constexpr bool operator== (TagTypeCompare< T >, TagTypeCompare< T >)
 
template<typename URBG >
constexpr URBG::result_type RangeSize ()
 
template<typename FloatType , typename IStream >
FloatType read_floating_point (IStream &is)
 
bool ReadSeedMaterialFromOSEntropy (absl::Span< uint32_t > values)
 
template<typename URBG >
ABSL_MUST_USE_RESULT bool ReadSeedMaterialFromURBG (URBG *urbg, absl::Span< uint32_t > values)
 
double RequiredSuccessProbability (const double p_fail, const int num_trials)
 
constexpr size_t SeedBitsToBlocks (size_t seed_size)
 
double StirlingLogFactorial (double n)
 
void ThrowSeedGenException ()
 
template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalOpenClosedTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, FloatType > uniform_lower_bound (Tag, FloatType a, FloatType b)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral< IntType >, absl::disjunction< std::is_same< Tag, IntervalOpenClosedTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, IntType > uniform_lower_bound (Tag, IntType a, IntType)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral< IntType >, absl::disjunction< std::is_same< Tag, IntervalOpenClosedTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, IntType > uniform_lower_bound (Tag, IntType a, IntType)
 
template<typename NumType , typename Tag >
absl::enable_if_t< absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalClosedOpenTag > >::value, NumType > uniform_lower_bound (Tag, NumType a, NumType)
 
template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalClosedOpenTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, FloatType > uniform_upper_bound (Tag, FloatType, FloatType b)
 
template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalOpenClosedTag > > >::value, FloatType > uniform_upper_bound (Tag, FloatType, FloatType b)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral< IntType >, absl::disjunction< std::is_same< Tag, IntervalClosedOpenTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, IntType > uniform_upper_bound (Tag, IntType, IntType b)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral< IntType >, absl::disjunction< std::is_same< Tag, IntervalClosedOpenTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, IntType > uniform_upper_bound (Tag, IntType, IntType b)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral< IntType >, absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalOpenClosedTag > > >::value, IntType > uniform_upper_bound (Tag, IntType, IntType b)
 
template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral< IntType >, absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalOpenClosedTag > > >::value, IntType > uniform_upper_bound (Tag, IntType, IntType b)
 
double ZScore (double expected_mean, const DistributionMoments &moments)
 

Variables

constexpr const char kChiSquared [] = "chi-squared"
 
constexpr size_t kEntropyBitsNeeded = 256
 
constexpr size_t kEntropyBlocksNeeded
 
const unsigned char kRandenRoundKeys [kKeyBytes]
 
const unsigned char kRandenRoundKeysBE [kKeyBytes]
 

Typedef Documentation

◆ pcg32_2018_engine

◆ pcg64_2018_engine

typedef pcg_engine< random_internal::pcg128_params< 0x2360ed051fc65da4ull, 0x4385df649fccf645ull, 0x5851f42d4c957f2d, 0x14057b7ef767814f >, random_internal::pcg_xsl_rr_128_64 > absl::random_internal::pcg64_2018_engine

◆ uniform_inferred_return_t

template<typename A , typename B >
using absl::random_internal::uniform_inferred_return_t = typedef absl::enable_if_t<absl::disjunction<is_widening_convertible<A, B>, is_widening_convertible<B, A> >::value, typename std::conditional< is_widening_convertible<A, B>::value, B, A>::type>

◆ UniformDistribution

template<typename NumType >
using absl::random_internal::UniformDistribution = typedef typename std::conditional<std::is_integral<NumType>::value, absl::uniform_int_distribution<NumType>, absl::uniform_real_distribution<NumType> >::type

Function Documentation

◆ beta()

double absl::random_internal::beta ( double  p,
double  q 
)

◆ BetaIncomplete()

double absl::random_internal::BetaIncomplete ( const double  x,
const double  p,
const double  q 
)

◆ BetaIncompleteInv()

double absl::random_internal::BetaIncompleteInv ( const double  p,
const double  q,
const double  alpha 
)

◆ BitWidth()

template<typename T >
int absl::random_internal::BitWidth ( T  v)

Definition at line 133 of file abseil-cpp/absl/random/internal/traits.h.

◆ ChiSquare()

template<typename Iterator , typename Expected >
double absl::random_internal::ChiSquare ( Iterator  it,
Iterator  end,
Expected  eit,
Expected  eend 
)

Definition at line 56 of file abseil-cpp/absl/random/internal/chi_square.h.

◆ ChiSquarePValue()

double absl::random_internal::ChiSquarePValue ( double  chi_square,
int  dof 
)

◆ ChiSquareValue()

double absl::random_internal::ChiSquareValue ( int  dof,
double  p 
)

◆ ChiSquareWithExpected()

template<typename Iterator >
double absl::random_internal::ChiSquareWithExpected ( Iterator  begin,
Iterator  end,
double  expected 
)

Definition at line 40 of file abseil-cpp/absl/random/internal/chi_square.h.

◆ ComputeDistributionMoments()

DistributionMoments absl::random_internal::ComputeDistributionMoments ( absl::Span< const double >  data_points)

◆ CPUSupportsRandenHwAes()

bool absl::random_internal::CPUSupportsRandenHwAes ( )

◆ erfinv()

double absl::random_internal::erfinv ( double  x)

◆ GenerateRealFromBits()

template<typename RealType , typename SignedTag = GeneratePositiveTag, bool IncludeZero = true>
RealType absl::random_internal::GenerateRealFromBits ( uint64_t  bits,
int  exp_bias = 0 
)
inline

◆ GetSaltMaterial()

absl::optional< uint32_t > absl::random_internal::GetSaltMaterial ( )

◆ HasRandenHwAesImplementation()

bool absl::random_internal::HasRandenHwAesImplementation ( )

◆ InitDiscreteDistribution()

std::vector< std::pair< double, size_t > > absl::random_internal::InitDiscreteDistribution ( std::vector< double > *  probabilities)

◆ IntegerLog2()

template<typename UIntType >
constexpr UIntType absl::random_internal::IntegerLog2 ( UIntType  n)
constexpr

◆ IntLog2Ceil()

int absl::random_internal::IntLog2Ceil ( uint64_t  n)
inline

Definition at line 39 of file abseil-cpp/absl/random/internal/fastmath.h.

◆ IntLog2Floor()

int absl::random_internal::IntLog2Floor ( uint64_t  n)
inline

Definition at line 36 of file abseil-cpp/absl/random/internal/fastmath.h.

◆ InverseNormalSurvival()

double absl::random_internal::InverseNormalSurvival ( double  x)

◆ is_uniform_range_valid() [1/3]

template<typename FloatType >
absl::enable_if_t< std::is_floating_point< FloatType >::value, bool > absl::random_internal::is_uniform_range_valid ( FloatType  a,
FloatType  b 
)

◆ is_uniform_range_valid() [2/3]

template<typename IntType >
absl::enable_if_t<IsIntegral<IntType>::value, bool> absl::random_internal::is_uniform_range_valid ( IntType  a,
IntType  b 
)

◆ is_uniform_range_valid() [3/3]

template<typename IntType >
absl::enable_if_t<std::is_integral<IntType>::value, bool> absl::random_internal::is_uniform_range_valid ( IntType  a,
IntType  b 
)

◆ IsPowerOfTwoOrZero()

template<typename UIntType >
constexpr bool absl::random_internal::IsPowerOfTwoOrZero ( UIntType  n)
constexpr

◆ make_istream_state_saver() [1/2]

template<typename CharT , typename Traits >
istream_state_saver< std::basic_istream< CharT, Traits > > absl::random_internal::make_istream_state_saver ( std::basic_istream< CharT, Traits > &  is,
std::ios_base::fmtflags  flags = std::ios_base::dec | std::ios_base::scientific | std::ios_base::skipws 
)

◆ make_istream_state_saver() [2/2]

template<typename T >
absl::enable_if_t<!std::is_base_of< std::ios_base, T >::value, null_state_saver< T > > absl::random_internal::make_istream_state_saver ( T is,
std::ios_base::fmtflags  flags = std::ios_base::dec 
)

◆ make_ostream_state_saver() [1/2]

template<typename CharT , typename Traits >
ostream_state_saver< std::basic_ostream< CharT, Traits > > absl::random_internal::make_ostream_state_saver ( std::basic_ostream< CharT, Traits > &  os,
std::ios_base::fmtflags  flags = std::ios_base::dec | std::ios_base::left | std::ios_base::scientific 
)

◆ make_ostream_state_saver() [2/2]

template<typename T >
absl::enable_if_t<!std::is_base_of< std::ios_base, T >::value, null_state_saver< T > > absl::random_internal::make_ostream_state_saver ( T is,
std::ios_base::fmtflags  flags = std::ios_base::dec 
)

◆ MakeSaltedSeedSeq() [1/2]

template<typename SSeq , typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
SSeq absl::random_internal::MakeSaltedSeedSeq ( SSeq &&  seq)

◆ MakeSaltedSeedSeq() [2/2]

template<typename SSeq , typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
SaltedSeedSeq< typename std::decay< SSeq >::type > absl::random_internal::MakeSaltedSeedSeq ( SSeq &&  seq)

◆ MaskFromShift()

template<typename UIntType >
constexpr UIntType absl::random_internal::MaskFromShift ( size_t  n)
constexpr

◆ MaxErrorTolerance()

double absl::random_internal::MaxErrorTolerance ( double  acceptance_probability)

◆ MixIntoSeedMaterial()

void absl::random_internal::MixIntoSeedMaterial ( absl::Span< const uint32_t sequence,
absl::Span< uint32_t seed_material 
)

◆ MultiplyU128ToU256()

U256 absl::random_internal::MultiplyU128ToU256 ( uint128  a,
uint128  b 
)
inline

◆ MultiplyU64ToU128()

absl::uint128 absl::random_internal::MultiplyU64ToU128 ( uint64_t  a,
uint64_t  b 
)
inline

◆ Near()

bool absl::random_internal::Near ( absl::string_view  msg,
double  actual,
double  expected,
double  bound 
)

◆ NumBits()

template<typename URBG >
constexpr size_t absl::random_internal::NumBits ( )
constexpr

◆ operator!=()

template<typename T >
constexpr bool absl::random_internal::operator!= ( TagTypeCompare< T ,
TagTypeCompare< T  
)
constexpr

◆ operator<<()

std::ostream & absl::random_internal::operator<< ( std::ostream &  os,
const DistributionMoments moments 
)

◆ operator==()

template<typename T >
constexpr bool absl::random_internal::operator== ( TagTypeCompare< T ,
TagTypeCompare< T  
)
constexpr

◆ RangeSize()

template<typename URBG >
constexpr URBG::result_type absl::random_internal::RangeSize ( )
constexpr

◆ read_floating_point()

template<typename FloatType , typename IStream >
FloatType absl::random_internal::read_floating_point ( IStream &  is)
inline

◆ ReadSeedMaterialFromOSEntropy()

ABSL_MUST_USE_RESULT bool absl::random_internal::ReadSeedMaterialFromOSEntropy ( absl::Span< uint32_t values)

◆ ReadSeedMaterialFromURBG()

template<typename URBG >
ABSL_MUST_USE_RESULT bool absl::random_internal::ReadSeedMaterialFromURBG ( URBG *  urbg,
absl::Span< uint32_t values 
)

◆ RequiredSuccessProbability()

double absl::random_internal::RequiredSuccessProbability ( const double  p_fail,
const int  num_trials 
)

◆ SeedBitsToBlocks()

constexpr size_t absl::random_internal::SeedBitsToBlocks ( size_t  seed_size)
constexpr

◆ StirlingLogFactorial()

double absl::random_internal::StirlingLogFactorial ( double  n)
inline

Definition at line 43 of file abseil-cpp/absl/random/internal/fastmath.h.

◆ ThrowSeedGenException()

void absl::random_internal::ThrowSeedGenException ( )

Definition at line 35 of file abseil-cpp/absl/random/seed_gen_exception.cc.

◆ uniform_lower_bound() [1/4]

template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalOpenClosedTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, FloatType > absl::random_internal::uniform_lower_bound ( Tag  ,
FloatType  a,
FloatType  b 
)

◆ uniform_lower_bound() [2/4]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral<IntType>, absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>, std::is_same<Tag, IntervalOpenOpenTag> > >::value, IntType> absl::random_internal::uniform_lower_bound ( Tag  ,
IntType  a,
IntType   
)

◆ uniform_lower_bound() [3/4]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral<IntType>, absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>, std::is_same<Tag, IntervalOpenOpenTag> > >::value, IntType> absl::random_internal::uniform_lower_bound ( Tag  ,
IntType  a,
IntType   
)

◆ uniform_lower_bound() [4/4]

template<typename NumType , typename Tag >
absl::enable_if_t< absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalClosedOpenTag > >::value, NumType > absl::random_internal::uniform_lower_bound ( Tag  ,
NumType  a,
NumType   
)

◆ uniform_upper_bound() [1/6]

template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalClosedOpenTag >, std::is_same< Tag, IntervalOpenOpenTag > > >::value, FloatType > absl::random_internal::uniform_upper_bound ( Tag  ,
FloatType  ,
FloatType  b 
)

◆ uniform_upper_bound() [2/6]

template<typename FloatType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_floating_point< FloatType >, absl::disjunction< std::is_same< Tag, IntervalClosedClosedTag >, std::is_same< Tag, IntervalOpenClosedTag > > >::value, FloatType > absl::random_internal::uniform_upper_bound ( Tag  ,
FloatType  ,
FloatType  b 
)

◆ uniform_upper_bound() [3/6]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral<IntType>, absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>, std::is_same<Tag, IntervalOpenOpenTag> > >::value, IntType> absl::random_internal::uniform_upper_bound ( Tag  ,
IntType  ,
IntType  b 
)

◆ uniform_upper_bound() [4/6]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral<IntType>, absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>, std::is_same<Tag, IntervalOpenOpenTag> > >::value, IntType> absl::random_internal::uniform_upper_bound ( Tag  ,
IntType  ,
IntType  b 
)

◆ uniform_upper_bound() [5/6]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< IsIntegral<IntType>, absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>, std::is_same<Tag, IntervalOpenClosedTag> > >::value, IntType> absl::random_internal::uniform_upper_bound ( Tag  ,
IntType  ,
IntType  b 
)

◆ uniform_upper_bound() [6/6]

template<typename IntType , typename Tag >
absl::enable_if_t< absl::conjunction< std::is_integral<IntType>, absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>, std::is_same<Tag, IntervalOpenClosedTag> > >::value, IntType> absl::random_internal::uniform_upper_bound ( Tag  ,
IntType  ,
IntType  b 
)

◆ ZScore()

double absl::random_internal::ZScore ( double  expected_mean,
const DistributionMoments moments 
)

Variable Documentation

◆ kChiSquared

constexpr const char absl::random_internal::kChiSquared = "chi-squared"
constexpr

Definition at line 35 of file abseil-cpp/absl/random/internal/chi_square.h.

◆ kEntropyBitsNeeded

constexpr size_t absl::random_internal::kEntropyBitsNeeded = 256
constexpr

◆ kEntropyBlocksNeeded

constexpr size_t absl::random_internal::kEntropyBlocksNeeded
constexpr

◆ kRandenRoundKeys

const unsigned char absl::random_internal::kRandenRoundKeys

◆ kRandenRoundKeysBE

const unsigned char absl::random_internal::kRandenRoundKeysBE
absl::random_internal::SeedBitsToBlocks
constexpr size_t SeedBitsToBlocks(size_t seed_size)
Definition: abseil-cpp/absl/random/internal/seed_material.h:35
absl::random_internal::kEntropyBitsNeeded
constexpr size_t kEntropyBitsNeeded
Definition: abseil-cpp/absl/random/internal/seed_material.h:41


grpc
Author(s):
autogenerated on Fri May 16 2025 03:02:54