Main MRPT website > C++ reference
MRPT logo
Classes | Functions | Variables

mrpt::random Namespace Reference


Detailed Description

A namespace of pseudo-random numbers genrators of diferent distributions.

The central class in this namespace is mrpt::random::CRandomGenerator

Classes

class  CRandomGenerator
 A thred-safe pseudo random number generator, based on an internal MT19937 randomness generator. More...

Functions

ptrdiff_t random_generator_for_STL (ptrdiff_t i)
 A random number generator for usage in STL algorithms expecting a function like this (eg, random_shuffle):
 MRPT_DECLARE_DEPRECATED_FUNCTION ("** deprecated **: Use mrpt::random::randomGenerator instead", double normalizedGaussian(double *likelihood=NULL))
 Generate a normalized normally distributed pseudo-random number.
 MRPT_DECLARE_DEPRECATED_FUNCTION ("** deprecated **: Use mrpt::random::randomGenerator instead", double RandomNormal(double mean=0, double std=1))
 Generate a normally distributed pseudo-random number.
 MRPT_DECLARE_DEPRECATED_FUNCTION ("** deprecated **: Use mrpt::random::randomGenerator instead", uint32_t RandomUniInt())
 Generate a uniformly distributed pseudo-random number using the MT19937 algorithm, in the whole range of 32-bit integers.
 MRPT_DECLARE_DEPRECATED_FUNCTION ("** deprecated **: Use mrpt::random::randomGenerator instead", double RandomUni(const double min, const double max))
 Generate a uniformly distributed pseudo-random number using the MT19937 algorithm, scaled to the selected range.
template<class MAT >
void matrixRandomUni (MAT &matrix, const double unif_min=0, const double unif_max=1)
 Fills the given matrix with independent, uniformly distributed samples.
template<class T >
void vectorRandomUni (std::vector< T > &v_out, const T &unif_min=0, const T &unif_max=1)
 Fills the given matrix with independent, uniformly distributed samples.
template<class MAT >
void matrixRandomNormal (MAT &matrix, const double mean=0, const double std=1)
 Fills the given matrix with independent, normally distributed samples.
template<class T >
void vectorRandomNormal (std::vector< T > &v_out, const T &mean=0, const T &std=1)
 Generates a random vector with independent, normally distributed samples.
void Randomize (const uint32_t seed)
 Randomize the generators.
void Randomize ()
template<class T >
void randomPermutation (const std::vector< T > &in_vector, std::vector< T > &out_result)
 Returns a random permutation of a vector: all the elements of the input vector are in the output but at random positions.
template<typename T >
void randomNormalMultiDimensional (const CMatrixTemplateNumeric< T > &cov, std::vector< T > &out_result)
 Generate multidimensional random samples according to a given covariance matrix.
template<typename T >
void randomNormalMultiDimensionalMany (const CMatrixTemplateNumeric< T > &cov, size_t desiredSamples, std::vector< std::vector< T > > &ret, std::vector< T > *samplesLikelihoods=NULL)
 Generate a given number of multidimensional random samples according to a given covariance matrix.
template<typename T , size_t N>
void randomNormalMultiDimensionalMany (const CMatrixFixedNumeric< T, N, N > &cov, size_t desiredSamples, std::vector< std::vector< T > > &ret)
 Generate multidimensional random samples according to a given covariance matrix.
template<typename T , size_t N>
void randomNormalMultiDimensional (const CMatrixFixedNumeric< T, N, N > &cov, std::vector< T > &out_result)
 Generate multidimensional random samples according to a given covariance matrix.

Variables

BASE_IMPEXP CRandomGenerator randomGenerator
 A static instance of a CRandomGenerator class, for use in single-thread applications.

Function Documentation

template<class MAT >
void mrpt::random::matrixRandomNormal ( MAT &  matrix,
const double  mean = 0,
const double  std = 1 
)

Fills the given matrix with independent, normally distributed samples.

Matrix classes can be CMatrixTemplateNumeric or CMatrixFixedNumeric

See also:
matrixRandomUni

Definition at line 373 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussian1D_normalized(), mean(), and randomGenerator.

template<class MAT >
void mrpt::random::matrixRandomUni ( MAT &  matrix,
const double  unif_min = 0,
const double  unif_max = 1 
)

Fills the given matrix with independent, uniformly distributed samples.

Matrix classes can be CMatrixTemplateNumeric or CMatrixFixedNumeric

See also:
matrixRandomNormal

Definition at line 344 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawUniform(), and randomGenerator.

mrpt::random::MRPT_DECLARE_DEPRECATED_FUNCTION ( "** deprecated **: Use mrpt::random::randomGenerator instead"  ,
uint32_t   RandomUniInt() 
)

Generate a uniformly distributed pseudo-random number using the MT19937 algorithm, in the whole range of 32-bit integers.

See: http://en.wikipedia.org/wiki/Mersenne_twister

See also:
RandomUni, Randomize
mrpt::random::MRPT_DECLARE_DEPRECATED_FUNCTION ( "** deprecated **: Use mrpt::random::randomGenerator instead"  ,
double   RandomUniconst double min, const double max 
)

Generate a uniformly distributed pseudo-random number using the MT19937 algorithm, scaled to the selected range.

This function uses internally RandomUniInt to generate the number, then scales it to the desired range. Since MRPT 0.6.0 the MT19937 algorithm is used instead of C runtime library "rand" version. See: http://en.wikipedia.org/wiki/Mersenne_twister

See also:
RandomUniInt, Randomize
mrpt::random::MRPT_DECLARE_DEPRECATED_FUNCTION ( "** deprecated **: Use mrpt::random::randomGenerator instead"  ,
double   normalizedGaussiandouble *likelihood=NULL 
)

Generate a normalized normally distributed pseudo-random number.

Parameters:
likelihoodIf desired, pass a pointer to a double which will receive the likelihood of the given sample to have been obtained, that is, the value of the normal pdf at the sample value.
mrpt::random::MRPT_DECLARE_DEPRECATED_FUNCTION ( "** deprecated **: Use mrpt::random::randomGenerator instead"  ,
double   RandomNormaldouble mean=0, double std=1 
)

Generate a normally distributed pseudo-random number.

Parameters:
meanThe mean value of desired normal distribution
stdThe standard deviation value of desired normal distribution
ptrdiff_t mrpt::random::random_generator_for_STL ( ptrdiff_t  i) [inline]

A random number generator for usage in STL algorithms expecting a function like this (eg, random_shuffle):

Definition at line 305 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawUniform32bit(), and randomGenerator.

Referenced by mrpt::slam::PF_implementation< PARTICLE_TYPE, MYSELF >::PF_SLAM_implementation_pfAuxiliaryPFStandardAndOptimal().

void mrpt::random::Randomize ( ) [inline]
void mrpt::random::Randomize ( const uint32_t  seed) [inline]

Randomize the generators.

A seed can be providen, or a current-time based seed can be used (default)

Definition at line 400 of file RandomGenerators.h.

References randomGenerator, and mrpt::random::CRandomGenerator::randomize().

template<typename T , size_t N>
void mrpt::random::randomNormalMultiDimensional ( const CMatrixFixedNumeric< T, N, N > &  cov,
std::vector< T > &  out_result 
)

Generate multidimensional random samples according to a given covariance matrix.

Exceptions:
std::exceptionOn invalid covariance matrix
See also:
randomNormalMultiDimensionalMany

Definition at line 468 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussianMultivariate(), and randomGenerator.

template<typename T >
void mrpt::random::randomNormalMultiDimensional ( const CMatrixTemplateNumeric< T > &  cov,
std::vector< T > &  out_result 
)

Generate multidimensional random samples according to a given covariance matrix.

Exceptions:
std::exceptionOn invalid covariance matrix
See also:
randomNormalMultiDimensionalMany

Definition at line 423 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussianMultivariate(), and randomGenerator.

template<typename T , size_t N>
void mrpt::random::randomNormalMultiDimensionalMany ( const CMatrixFixedNumeric< T, N, N > &  cov,
size_t  desiredSamples,
std::vector< std::vector< T > > &  ret 
)

Generate multidimensional random samples according to a given covariance matrix.

Exceptions:
std::exceptionOn invalid covariance matrix
See also:
randomNormalMultiDimensional

Definition at line 455 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussianMultivariateMany(), and randomGenerator.

template<typename T >
void mrpt::random::randomNormalMultiDimensionalMany ( const CMatrixTemplateNumeric< T > &  cov,
size_t  desiredSamples,
std::vector< std::vector< T > > &  ret,
std::vector< T > *  samplesLikelihoods = NULL 
)

Generate a given number of multidimensional random samples according to a given covariance matrix.

Parameters:
covThe covariance matrix where to draw the samples from.
desiredSamplesThe number of samples to generate.
samplesLikelihoodsIf desired, set to a valid pointer to a vector, where it will be stored the likelihoods of having obtained each sample: the product of the gaussian-pdf for each independent variable.
retThe output list of samples
Exceptions:
std::exceptionOn invalid covariance matrix
See also:
randomNormalMultiDimensional

Definition at line 441 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussianMultivariateMany(), and randomGenerator.

template<class T >
void mrpt::random::randomPermutation ( const std::vector< T > &  in_vector,
std::vector< T > &  out_result 
)

Returns a random permutation of a vector: all the elements of the input vector are in the output but at random positions.

Definition at line 410 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::permuteVector(), and randomGenerator.

template<class T >
void mrpt::random::vectorRandomNormal ( std::vector< T > &  v_out,
const T &  mean = 0,
const T &  std = 1 
)

Generates a random vector with independent, normally distributed samples.

See also:
matrixRandomUni

Definition at line 387 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawGaussian1D_normalized(), mean(), and randomGenerator.

template<class T >
void mrpt::random::vectorRandomUni ( std::vector< T > &  v_out,
const T &  unif_min = 0,
const T &  unif_max = 1 
)

Fills the given matrix with independent, uniformly distributed samples.

See also:
vectorRandomNormal

Definition at line 358 of file RandomGenerators.h.

References mrpt::random::CRandomGenerator::drawUniform(), and randomGenerator.


Variable Documentation




Page generated by Doxygen 1.7.3 for MRPT 0.9.4 SVN: at Sat Mar 26 06:16:28 UTC 2011