Reference

Summary

namespace alps

Summary

Members

public inline std::ostream & operator<<(std::ostream & os,const buffered_rng_base & r)

writes the state of the generator to a std::ostream See also: buffered_rng_base

public inline std::istream & operator>>(std::istream & is,buffered_rng_base & r)

reads the state of the generator from a std::istream See also: buffered_rng_base

public template<>
void seed_with_sequence(RNG & rng,uint32_t seed)

a generic seeding function for random number generators

Parameters

• rng the random number generator to be seeded

• seed the seed block number

seeds a random number generator following the Boost specifications for such generators with a unique sequence of random numbers obtained from the specified seed with the pseudo_des generator. This function is useful to prepare seed blocks for Monte Carlo simulations or similar applications.

public template<>
void seed_with_generator(RNG & rng,INIGEN & inigen)

class alps::basic_buffered_generator

class alps::basic_buffered_generator
  : public alps::buffered_generator< ResultType >

a concrete implementation of a buffered generator

Parameters

• Generator the type of the generator used to fill the buffer

• ResultType the type of values generated

This class template is a concrete derived class template for runtime-polymorphic generators. It uses the generator provided as template argument to fill the buffer of the buffered_generator base class. If the Generator is a reference type, a reference to the generator passed to the constructor is used. Otherwise a copy of the generator is used.

Summary

Members

public inline basic_buffered_generator(std::size_t buffer_size)

constructs a buffer of the size given as argument, and a default-generated Generator.

Parameters

• buffer_size the size of the buffer

public inline basic_buffered_generator(generator_type gen,std::size_t buffer_size)

constructs a buffered generator from the given argument

Parameters

• gen the generator used to generate values

• buffer_size the size of the buffer

If a reference type is specifed as Generator type, a reference to the generator gen is stored and used, otherweise the generator is copied.

typedef generator_type

the date type of the generator used to fill the buffer

typedef result_type

the type of values generated

class alps::basic_buffered_uniform_01

class alps::basic_buffered_uniform_01
  : public alps::buffered_uniform_01< double >

a runtime-polymorphic buffered random number generator generating double values in the interval [0,1[

Parameters

• Engine the type of random number generator engine

• RealType the floating point type of the random numbers, defaults to double

This class template is a concrete derived class template for runtime-polymorphic generators. It uses a variate_generator producing uniform random numbers in the interval[0,1) to fill the buffer of the alps::buffered_generator base class. If the Engine is a reference type,

Summary

Members

public inline basic_buffered_uniform_01(std::size_t buffer_size)

constructs a default-seeded generator with a buffer of the size given as argument, and uses a default-generated random number generator.

Parameters

• buffer_size the size of the buffer

public inline basic_buffered_uniform_01(engine_type engine,std::size_t buffer_size)

constructs a generator from the given engine

Parameters

• engine the engine used to generate values

• buffer_size the size of the buffer

If a reference type is specifed as Engine type, a reference to the engine is stored and used, otherweise the engine is copied.

typedef result_type

the type of random numbers

typedef engine_type

the type of random number generator engine

typedef distribution_type

typedef generator_type

class alps::buffered_generator

abstract base class of a runtime-polymorphic buffered_generator

Parameters

• ResultType the type of values generated

This class template is an abstract base class for runtime-polymorphic generators. In order to mask the abstraction penalty of a virtual operator(), the buffered_generator does not produce single numbers at each call, but instead a large buffer is filled in a virtual function call, and then numbers from this buffer used when operator() is called.

Summary

Members

public inline buffered_generator(std::size_t buffer_size)

the constructor of the buffered generator

Parameters

• buffer_size the size of the buffer

Constructs a [buffered_generator](#d2/dad/classalps_1_1buffered__generator) with a buffer of the size given as argument.

public inline buffered_generator(const buffered_generator & gen)

the copy constructor copies the buffer

public inline virtual ~buffered_generator()

trivial virtual destructor

public inline buffered_generator&operator=(const buffered_generator & gen)

non-trivial the assignment

public inline result_type operator()()

returns the next generated value

values are taken from the buffer, which is refilled by a call to fill_buffer when all values have been used up

public inline void reset()

discards all elements in the buffers and forces a new call to fill_buffer when the next value is requested

typedef result_type

typedef buffer_type

the data type of the buffer used

class alps::buffered_rng

class alps::buffered_rng
  : public alps::buffered_rng_base

a concrete implementation of a buffered random number generator

Parameters

• RNG the type of random number generator

Summary

Members

public inline buffered_rng()

constructs a default-seeded generator

public inline buffered_rng(RNG rng)

constructs a generator by copying the argument

Parameters

• rng generator to be copied

public template<>
inline void seed(IT start,IT end)

public inline virtual void seed(uint32_t s)

seed from an integer using seed_with_sequence See also: seed_with_sequence()

public virtual void seed()

seed with the default value

public inline virtual void seed(pseudo_des & inigen)

seed with the pseudo_des generator

public inline virtual result_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const

public inline virtual result_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const

public virtual void write(std::ostream &) const

write the state to a std::ostream

public virtual void read(std::istream &)

read the state from a std::istream

public virtual void write_all(std::ostream & os) const

write the full state (including buffer) to a std::ostream

public virtual void read_all(std::istream &)

read the full state (including buffer) from a std::istream

protected RNG rng_

protected virtual void fill_buffer()

refills the buffer

class alps::buffered_rng_base

abstract base class of a runtime-polymorphic random number generator

In order to mask the abstraction penalty, the derived generators do not produce single random numbers at each call, but instead a large buffer is filled in a virtual function call, and then numbers from this buffer used when operator() is called.

Summary

Members

public BOOST_STATIC_CONSTANT(bool,has_fixed_range)

public inline buffered_rng_base(std::size_t b)

the constructor

Parameters

• b the size of the buffer

public inline buffered_rng_base(const buffered_rng_base & gen)

public inline virtual ~buffered_rng_base()

public inline result_type operator()()

returns the next random number

numbers are taken from the buffer, which is refilled by a call to fill_buffer when it gets empty

public template<>
OutputIterator generate_n(std::size_t n,OutputIterator it)

public void seed(uint32_t)

seed with an unsigned integer

public void seed()

seed with the default value

public void seed(pseudo_des & inigen)

seed with the pseudo_des generator

public void write(std::ostream &) const

write the state to a std::ostream

public void read(std::istream &)

read the state from a std::istream

public void write_all(std::ostream & os) const

write the full state (including buffer) to a std::ostream

public void read_all(std::istream &)

read the full state (including buffer) from a std::istream

public result_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const

public result_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const

protected std::vector< result_type>buf_

protected std::vector< result_type>::iteratorptr_

typedef result_type

we create random numbers of type uint32_t

typedef buffer_type

class alps::buffered_uniform_01

class alps::buffered_uniform_01
  : public alps::buffered_generator< double >

the abstract base class of a runtime-polymorphic buffered random number generator generating double values in the interval [0,1[

Parameters

• RealType the floating point type of the random numbers, defaults to double

This class template is an abstract base class template for runtime-polymorphic uniform random number generators producing numbers in the interval [0,1). It inherits from alps::buffered_generator and provides min() and @max () functions returning 0. and 1. respectively,

Summary

Members

public inline buffered_uniform_01(std::size_t buffer_size)

constructs the generator

Parameters

• buffer_size the size of the buffer

public inline result_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const

public inline result_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const

typedef result_type

the type of random numbers

class alps::multivariate_normal_distribution

a distribution creating correlated multi-variate normally distributed numbers

the multivariate normal distribution creates correlated random numbers with a specified mean vector and covariance matrix. Instead of using a vector as the result_type, the result_type is a scalar real number, and the operator() should be called once for each element of the vector.

Summary

Members

public BOOST_STATIC_ASSERT(!std::numeric_limits< RealType >::is_integer)

INTERNAL ONLY.

public inline multivariate_normal_distribution(const matrix_type& cholesky,constvector_type & mean)

the constructor of the multi-variate normal distribution

Parameters

• mean the vector of mean values

• cholesky the Cholesky decomposition of the covariance matrix

The Cholesky decomposition has to be a square matrix and its dimension has to be the same as that of the mean vector. Instead of a Cholesky decomposition any other square root of the covariance matrix could be passed.

Requires: mean.size() == cholesky.size1() and cholesky.size1() == cholesky.size2()

public inline explicit multivariate_normal_distribution(const matrix_type & cholesky)

the constructor of the multi-variate normal distribution with zero mean

Parameters

• cholesky the Cholesky decomposition of the covariance matrix

Instead of a Cholesky decomposition any other square root of the covariance matrix could be passed.

Requires: cholesky.size1() == cholesky.size2()

public inline multivariate_normal_distribution(const multivariate_normal_distribution & other)

INTERNAL ONLY.

public inline multivariate_normal_distribution&operator=(const multivariate_normal_distribution & other)

INTERNAL ONLY.

public inline vector_typeconst &mean() const

Returns

the vector of mean values

public inline matrix_typeconst &cholesky() const

Returns

the Cholesky decomposition of the covariance marix

public inline void reset()

purges the cache.

Purges the cache. The next call to oeprator() will create a new vector.

public template<>
inline result_type operator()(Engine & eng)

Returns

On the first call, it creates a vector of n multivariate normally distributed random numbers, caches it, and returns the first value. The next n-1 calls return the next elements of the vector. The n+1-st call again creates a new vector of multivariate normally distributed random numbers.

typedef result_type

the type of random numbers produced

typedef input_type

the input type

typedef vector_type

the type of the vector of mean values

typedef matrix_type

the type of the matrix storing the Cholesky decomposition of the covariance matrix

class alps::pseudo_des

A random number generator using the pseudo-DES algorithm.

The random number generator follows the BOOST (standard C++) specifications

Summary

Members

public BOOST_STATIC_CONSTANT(uint32_t,default_seed)

the default seed is 4357

public inline result_typeminBOOST_PREVENT_MACRO_SUBSTITUTION() const

minim value is 0

public inline result_typemaxBOOST_PREVENT_MACRO_SUBSTITUTION() const

maximum value is 2^32-1

public inline pseudo_des()

the default constructor

public inline explicit pseudo_des(uint32_t s)

construct with specified seed

public inline void seed(uint32_t s) = default

seed the generator

public inline result_type operator()()

get the next value

public inline void operator+=(uint32_t skip)

skip forward by skip numbers

public inline std::ostream & write(std::ostream & os) const

write the state to a std::ostream

public inline std::istream & read(std::istream & is)

read the state from a std::istream

public inline bool operator==(const pseudo_des & rhs) const

check whether the initial seed and current state of two generators is the same

typedef result_type

type of the random numbers

class alps::random_choice

class alps::random_choice
  : public alps::detail::random_choice_walker< RNG::result_type, unsigned int, double >

Summary

Members

public inline random_choice()

public template<>
inline random_choice(const CONT & weights)

class alps::random_choice< double >

class alps::random_choice< double >
  : public alps::detail::random_choice_walker< double, unsigned int, double >

Summary

Members

public inline random_choice()

public template<>
inline random_choice(const CONT & weights)

class alps::random_choice< unsigned int >

class alps::random_choice< unsigned int >
  : public alps::detail::random_choice_walker< unsigned int, unsigned int, double >

Summary

Members

public inline random_choice()

public template<>
inline random_choice(const CONT & weights)

class alps::RNGFactory

class alps::RNGFactory
  : public factory< std::string, buffered_rng_base >

a factory to create random number generators from their name

Summary

Members

public RNGFactory()

public template<>
inline void register_rng(const std::string & name)

class alps::uniform_on_sphere_n

Summary

Members

public BOOST_STATIC_CONSTANT(int,dim)

public inline uniform_on_sphere_n()

public inline void reset()

public template<>
inline const result_type & operator()(Engine & eng)

typedef input_type

typedef result_type

class alps::uniform_on_sphere_n< 1, RealType, Cont >

Summary

Members

public BOOST_STATIC_CONSTANT(int,dim)

public inline uniform_on_sphere_n()

public inline void reset()

public template<>
inline const result_type & operator()(Engine & eng)

typedef input_type

typedef result_type

class alps::uniform_on_sphere_n< 2, RealType, Cont >

Summary

Members

public BOOST_STATIC_CONSTANT(int,dim)

public inline uniform_on_sphere_n()

public inline void reset()

public template<>
inline const result_type & operator()(Engine & eng)

typedef input_type

typedef result_type

class alps::uniform_on_sphere_n< 3, RealType, Cont >

Summary

Members

public BOOST_STATIC_CONSTANT(int,dim)

public inline uniform_on_sphere_n()

public inline void reset()

public template<>
inline const result_type & operator()(Engine & eng)

typedef input_type

typedef result_type

namespace alps::detail

Summary

Members

public template<>
inline bool check_table(WVEC const & weights,std::vector< std::pair< CutoffType, IndexType > > const & table,double tol)

public template<>
inline void fill_ft2009(WVEC const & weights,std::vector< std::pair< CutoffType, IndexType > > & table,typename boost::enable_if< boost::is_float< CutoffType > >::type *,typename boost::enable_if< boost::is_integral< IndexType > >::type *)

public template<>
inline void fill_ft2009(WVEC const & weights,std::vector< std::pair< CutoffType, IndexType > > & table,typename boost::enable_if< boost::is_integral< CutoffType > >::type *,typename boost::enable_if< boost::is_integral< IndexType > >::type *)

public template<>
inline void fill_walker1977(WVEC const & weights,std::vector< std::pair< CutoffType, IndexType > > & table,CutoffType tol,typename boost::enable_if< boost::is_float< CutoffType > >::type *,typename boost::enable_if< boost::is_integral< IndexType > >::type *)

class alps::detail::random_choice_bsearch

Summary

Members

public inline random_choice_bsearch()

public template<>
inline random_choice_bsearch(CONT const & weights)

public template<>
inline void init(CONT const & weights)

public template<>
inline result_type operator()(Engine & eng) const

typedef input_type

typedef result_type

class alps::detail::random_choice_lsearch

Summary

Members

public inline random_choice_lsearch()

public template<>
inline random_choice_lsearch(CONT const & weights)

public template<>
inline void init(CONT const & weights)

public template<>
inline result_type operator()(Engine & eng) const

typedef input_type

typedef result_type

class alps::detail::random_choice_walker

Summary

Members

class alps::detail::random_choice_walker< double, IntType, RealType >

Summary

Members

public inline random_choice_walker()

public template<>
inline random_choice_walker(const CONT & weights)

public template<>
inline void init(const CONT & weights)

public template<>
inline result_type operator()(Engine & eng) const

public template<>
inline bool check(const CONT & weights,RealType tol) const

protected inline IntType size() const

protected inline RealType cutoff(result_type i) const

protected inline result_type alias(result_type i) const

typedef input_type

typedef result_type

class alps::detail::random_choice_walker< unsigned int, IntType, RealType >

Summary

Members

public inline random_choice_walker()

public template<>
inline random_choice_walker(const CONT & weights)

public template<>
inline void init(const CONT & weights)

public template<>
inline result_type operator()(Engine & eng) const

public template<>
inline bool check(const CONT & weights,RealType tol) const

protected inline IntType cutoff(IntType i) const

protected inline IntType alias(IntType i) const

typedef input_type

typedef result_type

Generated by Moxygen