Changeset 69 in pacpusframework for trunk/include/Pacpus/PacpusTools/math/rng.hpp


Ignore:
Timestamp:
Jan 10, 2013, 12:04:42 AM (12 years ago)
Author:
Marek Kurdej
Message:

Added: more documentation.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/Pacpus/PacpusTools/math/rng.hpp

    r66 r69  
    77/// @version $Id$
    88/// @copyright Copyright (c) UTC/CNRS Heudiasyc 2006 - 2013. All rights reserved.
    9 /// @brief Brief description.
     9/// @brief Random number generators.
    1010///
    1111/// Detailed description.
    … …  
    2222namespace rng {
    2323
    24 /*!
    25  * \class normal_generator
    26  * \brief This class is basic normal random number generator \n
    27  * template id RealType describe number precision (float double ....)\n
    28  * template id PRNG describe pseudo random number generator ( see boost random)
    29  */
    30 template < class RealType , class PRNG > class normal_generator {
    31 public :
    32   /*!
    33    * Default construtor
    34    */
    35   normal_generator():
    36   engine(time(NULL)),
    37   generator(engine,boost::normal_distribution<RealType>(0,1))
    38   {}
    39   /*!
    40    * Construtor
    41    * \param dist : a normal distribution (see boost distributions)
    42    */
    43   normal_generator(const boost::math::normal_distribution<RealType> & dist):
    44   engine(time(NULL)),
    45   generator(engine,boost::normal_distribution<RealType>(dist.mean(),dist.sigma()))
    46   {}
    47   /*!
    48    * Construtor
    49    * \param mean : mean of the normal distribution
    50    * \param sigma : satndard deviation of the normal distribution
    51    */
    52   normal_generator(const RealType & mean ,const RealType & sigma):
    53   engine(time(NULL)),
    54   generator(engine,boost::normal_distribution<RealType>(mean(),sigma()))
    55   {}
    56 
    57   /*!
    58    * Get a random number
    59    */
    60   RealType operator()() {return generator();}
    61 
    62   /*!
    63    * Set normal distribution
    64    * \param dist : a normal distribution (see boost distributions)
    65    */
    66   void distribution( const boost::math::normal_distribution<RealType> & dist) {
    67     generator.dist= boost::normal_distribution<RealType>(dist.mean(),dist.standard_deviation());
    68   }
    69 
    70   /*!
    71    * Set normal distrubution
    72    * \param mean : mean of the normal distribution
    73    * \param sigma : satndard deviation of the normal distribution
    74    */
    75   void distribution( const RealType & mean ,const RealType & sigma) {
    76     generator.distribution()= boost::normal_distribution<RealType>(mean,sigma);
    77   }
    78 
    79   private :
    80 
    81   /*!
    82    * \brief pseudo random number generator
    83    */
    84   PRNG engine;
    85 
    86   /*!
    87    * \brief the normal random number generator
    88    */
    89   boost::variate_generator<PRNG, boost::normal_distribution<RealType> > generator;
     24/// This class is basic normal random number generator
     25///
     26/// @tparam RealType describe number precision, e.g. @c float, @c double
     27/// @tparam PRNG describe pseudo random number generator
     28/// @see boost::random
     29template <class RealType, class PRNG>
     30class normal_generator
     31{
     32public:
     33    /// Default construtor
     34    normal_generator()
     35        : engine(time(NULL))
     36        , generator(engine,boost::normal_distribution<RealType>(0,1))
     37    {}
     38
     39    /// Construtor
     40    ///
     41    /// @param dist a normal distribution
     42    /// @see boost::distributions
     43    normal_generator(const boost::math::normal_distribution<RealType> & dist)
     44        : engine(time(NULL))
     45        , generator(engine,boost::normal_distribution<RealType>(dist.mean(),dist.sigma()))
     46    {}
     47
     48    /// Constructor
     49    ///
     50    /// @param mean mean of the normal distribution
     51    /// @param sigma standard deviation of the normal distribution
     52    normal_generator(const RealType & mean ,const RealType & sigma)
     53        : engine(time(NULL))
     54        , generator(engine,boost::normal_distribution<RealType>(mean(),sigma()))
     55    {}
     56
     57    /// Get a random number
     58    RealType operator()()
     59    {
     60        return generator();
     61    }
     62
     63    /// Set normal distribution
     64    ///
     65    /// @param dist : a normal distribution
     66    /// @see boost::distributions
     67    void distribution( const boost::math::normal_distribution<RealType> & dist)
     68    {
     69        generator.dist= boost::normal_distribution<RealType>(dist.mean(),dist.standard_deviation());
     70    }
     71
     72    /// Set normal distrubution
     73    ///
     74    /// @param mean : mean of the normal distribution
     75    /// @param sigma : satndard deviation of the normal distribution
     76    void distribution( const RealType & mean ,const RealType & sigma) {
     77        generator.distribution()= boost::normal_distribution<RealType>(mean,sigma);
     78    }
     79
     80private:
     81    /// pseudorandom number generator
     82    PRNG engine;
     83
     84    /// the normal random number generator
     85    boost::variate_generator<PRNG, boost::normal_distribution<RealType> > generator;
    9086};
    9187
    92 typedef class normal_generator<double,boost::mt19937> normal_rng;
    93 
    94 
    95 
    96 /*!
    97  * \class uniform_generator
    98  * \brief This class is basic uniform random number generator \n
    99  * template id RealType describe number precision (float double ....)\n
    100  * template id PRNG describe pseudo random number generator ( see boost random)
    101  */
    102 template < class RealType , class PRNG > class uniform_generator {
    103 
    104 public :
    105   /*!
    106    * Default construtor
    107    */
    108   uniform_generator():
    109   engine(time(NULL)),
    110   generator(engine, boost::uniform_real<RealType>(0,1))
    111   {}
    112   /*!
    113    * Construtor
    114    * \param dist : a uniform distribution (see boost distributions)
    115    */
    116    uniform_generator(const boost::math::uniform_distribution<RealType> & dist):
    117    engine(time(NULL)),
    118    generator(engine, boost::uniform_real<RealType>(dist.lower(),dist.upper()))
    119    {}
    120   /*!
    121    * Construtor
    122    * \param lower : the lower value of the uniform distribution
    123    * \param upper : the upper value of the uniform distribution
    124    */
    125   uniform_generator(const RealType & lower , const RealType & upper):
    126   engine(time(NULL)),
    127   generator(engine, boost::uniform_real<RealType>(lower,upper))
    128   {}
    129 
    130   /*!
    131    * Get a random number
    132    */
    133   RealType operator()() {return generator();}
    134   /*!
    135    * Set uniform distribution
    136    * \param dist : a normal distribution (see boost distributions)
    137    */
    138   void distribution( const boost::math::uniform_distribution<RealType> & dist) {
    139     generator.dist()= boost::uniform_real<RealType>(dist.lower(),dist.upper());
    140   }
    141   /*!
    142    * Set uniform distribution
    143    * \param lower : the lower value of the uniform distribution
    144    * \param upper : the upper value of the uniform distribution
    145    */
    146   void distribution( const RealType & lower , const RealType & upper) {
    147     generator.dist()= boost::uniform_real<RealType>(lower,upper);
    148   }
    149 
    150   private :
    151   /*!
    152    * \brief pseudo random number generator
    153    */
    154   PRNG engine;
    155   /*!
    156    * \brief the uniform random number generator
    157    */
    158   boost::variate_generator<PRNG, boost::uniform_real<RealType> > generator;
     88/// Defines normal random number generator as a Mersenne Twister 19937 with double-precision numbers
     89typedef class normal_generator<double, boost::mt19937> normal_rng;
     90
     91/// This class is basic uniform random number generator.
     92///
     93/// @tparam RealType describe number precision, e.g. @c float, @c double
     94/// @tparam PRNG describe pseudo random number generator
     95/// @see boost::random
     96template <class RealType, class PRNG>
     97class uniform_generator
     98{
     99public:
     100    /// Default construtor
     101    uniform_generator()
     102        : engine(time(NULL))
     103        , generator(engine, boost::uniform_real<RealType>(0,1))
     104    {}
     105
     106    /// Construtor
     107    /// @param dist a uniform distribution
     108    /// @see boost::distributions
     109    uniform_generator(const boost::math::uniform_distribution<RealType> & dist)
     110        : engine(time(NULL))
     111        , generator(engine, boost::uniform_real<RealType>(dist.lower(),dist.upper()))
     112    {}
     113   
     114    /// Constructor
     115    ///
     116    /// @param lower the lower value of the uniform distribution
     117    /// @param upper the upper value of the uniform distribution
     118    uniform_generator(const RealType & lower , const RealType & upper)
     119        : engine(time(NULL))
     120        , generator(engine, boost::uniform_real<RealType>(lower,upper))
     121    {}
     122
     123    /// Get a random number
     124    RealType operator()()
     125    {
     126        return generator();
     127    }
     128
     129    /// Set uniform distribution
     130    ///
     131    /// @param dist a normal distribution
     132    /// @see boost::distributions
     133    void distribution( const boost::math::uniform_distribution<RealType> & dist)
     134    {
     135        generator.dist()= boost::uniform_real<RealType>(dist.lower(),dist.upper());
     136    }
     137
     138    /// Set uniform distribution
     139    ///
     140    /// @param lower the lower value of the uniform distribution
     141    /// @param upper the upper value of the uniform distribution
     142    void distribution( const RealType & lower , const RealType & upper)
     143    {
     144        generator.dist()= boost::uniform_real<RealType>(lower,upper);
     145    }
     146
     147private:
     148    /// @brief pseudo random number generator
     149    PRNG engine;
     150    /// @brief the uniform random number generator
     151    boost::variate_generator<PRNG, boost::uniform_real<RealType> > generator;
    159152};
    160153
    161 typedef class uniform_generator<double,boost::mt19937> uniform_rng;
    162 
    163 
    164 /*!
    165  * \class traingle_generator
    166  * \brief This class is basic triangular random number generator \n
    167  * template id RealType describe number precision (float double ....)\n
    168  * template id PRNG describe pseudo random number generator ( see boost random)
    169  */
    170 template < class RealType , class PRNG > class triangle_generator {
    171 
    172 public :
    173   /*!
    174    * Default construtor
    175    */
    176   triangle_generator():
    177   engine(time(NULL)),
    178   generator(engine, boost::triangle_distribution<RealType>(-1,0,1))
    179   {}
    180   /*!
    181    * Construtor
    182    * \param dist : a traingle distribution (see boost distributions)
    183    */
    184    triangle_generator(const boost::math::triangular_distribution<RealType> & dist):
    185    engine(time(NULL)),
    186    generator(engine, boost::triangle_distribution<RealType>(dist.lower(),dist.upper()))
    187    {}
    188   /*!
    189    * Constructor :
    190    * \param lower : the lower value of the uniform distribution
    191    * \param mode : the mode value of the uniform distribution
    192    * \param upper : the upper value of the uniform distribution
    193    */
    194   triangle_generator(const RealType & lower , const RealType & mode ,const RealType & upper):
    195   engine(time(NULL)),
    196   generator(engine, boost::triangle_distribution<RealType>(lower,mode,upper))
    197   {}
    198   /*!
    199    * Get a random number
    200    */
    201   RealType operator()() {return generator();}
    202   /*!
    203    * Set triangle distribution
    204    * \param dist : a normal distribution (see boost distributions)
    205    */
    206   void distribution( const boost::math::triangular_distribution<RealType> & dist) {
    207     generator.dist()= boost::triangle_distribution<RealType>(dist.lower(),dist.mode(),dist.upper());
    208   }
    209   /*!
    210    * Set triangle distribution
    211    * \param lower : the lower value of the uniform distribution
    212    * \param mode : the mode value of the uniform distribution
    213    * \param upper : the upper value of the uniform distribution
    214    */
    215   void distribution( const RealType & lower ,const RealType & mode ,const RealType & upper) {
    216     generator.dist()= boost::triangle_distribution<RealType>(lower,mode,upper);
    217   }
    218 
    219   private :
    220   /*!
    221    * \brief pseudo random number generator
    222    */
    223   PRNG engine;
    224   /*!
    225    * \brief the triangle random number generator
    226    */
    227   boost::variate_generator<PRNG, boost::triangle_distribution<RealType> > generator;
     154/// Defines uniform random number generator as a Mersenne Twister 19937 with double-precision numbers
     155typedef class uniform_generator<double, boost::mt19937> uniform_rng;
     156
     157/// This class is basic triangular random number generator
     158///
     159/// @tparam RealType describe number precision, e.g. @c float, @c double
     160/// @tparam PRNG describe pseudo random number generator ( see boost random)
     161template <class RealType, class PRNG>
     162class triangle_generator
     163{
     164public:
     165    /// Default construtor
     166    triangle_generator()
     167        : engine(time(NULL))
     168        , generator(engine, boost::triangle_distribution<RealType>(-1,0,1))
     169    {}
     170
     171    /// Construtor
     172    ///
     173    /// @param dist : a traingle distribution
     174    /// @see boost distributions
     175    triangle_generator(const boost::math::triangular_distribution<RealType> & dist)
     176        : engine(time(NULL))
     177        ,generator(engine, boost::triangle_distribution<RealType>(dist.lower(),dist.upper()))
     178    {}
     179
     180    /// Constructor
     181    ///
     182    /// @param lower the lower value of the uniform distribution
     183    /// @param mode the mode value of the uniform distribution
     184    /// @param upper the upper value of the uniform distribution
     185    triangle_generator(const RealType & lower, const RealType & mode ,const RealType & upper)
     186        : engine(time(NULL))
     187        , generator(engine, boost::triangle_distribution<RealType>(lower,mode,upper))
     188    {}
     189
     190    /// Get a random number
     191    RealType operator()()
     192    {
     193        return generator();
     194    }
     195
     196    /// Set triangle distribution
     197    /// @param dist a normal distribution
     198    /// @see boost::distributions
     199    void distribution( const boost::math::triangular_distribution<RealType> & dist)
     200    {
     201        generator.dist()= boost::triangle_distribution<RealType>(dist.lower(),dist.mode(),dist.upper());
     202    }
     203
     204    /// Set triangle distribution
     205    /// @param lower    the lower value of the uniform distribution
     206    /// @param mode     the mode value of the uniform distribution
     207    /// @param upper    the upper value of the uniform distribution
     208    void distribution( const RealType & lower, const RealType & mode ,const RealType & upper)
     209    {
     210        generator.dist()= boost::triangle_distribution<RealType>(lower,mode,upper);
     211    }
     212
     213private :
     214    /// pseudorandom number generator
     215    PRNG engine;
     216    /// the triangle random number generator
     217    boost::variate_generator<PRNG, boost::triangle_distribution<RealType> > generator;
    228218};
    229219
    230 typedef class triangle_generator<double,boost::mt19937> triangle_rng;
     220typedef class triangle_generator<double, boost::mt19937> triangle_rng;
    231221
    232222} // namespace rng
Note: See TracChangeset for help on using the changeset viewer.