EvolvingObjects
rnd_generators.h
00001 /* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
00002 
00003   -----------------------------------------------------------------------------
00004   rnd_generators.h
00005     Some utility functors for generating random generators:
00006         uniform_generator : generates uniform floats or doubles
00007         random_generator  : generates unsigneds, ints etc.
00008         normal_generator  : normally distributed floats or doubles
00009 
00010  (c) Maarten Keijzer (mak@dhi.dk) and GeNeura Team, 1999, 2000
00011 
00012     This library is free software; you can redistribute it and/or
00013     modify it under the terms of the GNU Lesser General Public
00014     License as published by the Free Software Foundation; either
00015     version 2 of the License, or (at your option) any later version.
00016 
00017     This library is distributed in the hope that it will be useful,
00018     but WITHOUT ANY WARRANTY; without even the implied warranty of
00019     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020     Lesser General Public License for more details.
00021 
00022     You should have received a copy of the GNU Lesser General Public
00023     License along with this library; if not, write to the Free Software
00024     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00025 
00026     Contact: todos@geneura.ugr.es, http://geneura.ugr.es
00027  */
00028 
00029 //-----------------------------------------------------------------------------
00030 
00031 #ifndef eoRND_GENERATORS_H
00032 #define eoRND_GENERATORS_H
00033 
00034 #include "eoRNG.h"
00035 #include <stdexcept>
00036 
00048 template <class T = double> class uniform_generator
00049 {
00050   // added new ctor with 2 params, and modified the data to minim and range
00051   // (was maxim only). MS 3/11/2000
00052   public :
00053     uniform_generator(T _max = T(1.0), eoRng& _rng = rng) :
00054       minim(T(0.0)), range(_max), uniform(_rng) {}
00055     uniform_generator(T _min, T _max, eoRng& _rng = rng) :
00056       minim(_min), range(_max-_min), uniform(_rng)
00057   {
00058     if (_min>_max)
00059       throw std::logic_error("Min is greater than Max in uniform_generator");
00060   }
00061 
00062   T operator()(void) { return minim+static_cast<T>(uniform.uniform(range)); }
00063 
00064 private :
00065   T minim;
00066   T range;
00067   eoRng& uniform;
00068 };
00069 
00074 class boolean_generator
00075 {
00076   public :
00077     boolean_generator(float _bias = 0.5, eoRng& _rng = rng) : bias(_bias), gen(_rng) {}
00078 
00079   bool operator()(void) { return gen.flip(bias); }
00080   private :
00081   float bias;
00082   eoRng& gen;
00083 };
00084 
00091 template <class T = uint32_t> class random_generator
00092 {
00093   public :
00094   // added new ctor with 2 params, and modified the data to minim and range
00095   // (was maxim only). MS 3/11/2000
00096     random_generator(T _max, eoRng& _rng = rng) :
00097       minim(T(0.0)), range(_max), random(_rng) {}
00098     random_generator(T _min, T _max, eoRng& _rng = rng) :
00099       minim(_min), range(_max-_min), random(_rng)
00100   {
00101     if (_min>_max)
00102       throw std::logic_error("Min is greater than Max in random_generator");
00103   }
00104 
00105   T operator()(void) { return (T) (minim + random.random(range)); }
00106 
00107 private :
00108   T minim;
00109   T range;
00110   eoRng& random;
00111 };
00112 
00114 template <>
00115 inline bool random_generator<bool>::operator()(void)
00116 {
00117     return random.flip(0.5);
00118 }
00119 
00125 template <class T = uint32_t> class UF_random_generator
00126 {
00127   public :
00128     UF_random_generator(eoRng& _rng = rng) :
00129       random(_rng) {}
00130 
00131   T operator()(T _t) { return (T) (random.random(_t)); }
00132 
00133 private :
00134   eoRng& random;
00135 };
00136 
00137 
00143 template <class T = double> class normal_generator
00144 {
00145   public :
00146     normal_generator(T _stdev = T(1.0), eoRng& _rng = rng) : stdev(_stdev), normal(_rng) {}
00147 
00148   T operator()(void) { return (T) normal.normal(stdev); }
00149 
00150   private :
00151     T stdev;
00152   eoRng& normal;
00153 };
00154 
00160 template <class T = double> class negexp_generator
00161 {
00162   public :
00163     negexp_generator(T _mean = 1.0, eoRng& _rng = rng) : mean(_mean), negexp(_rng) {}
00164 
00165   T operator()(void) { return (T) negexp.negexp(mean); }
00166 
00167   private :
00168     T mean;
00169   eoRng& negexp;
00170 };
00171 
00173 #endif
 All Classes Namespaces Files Functions Variables Typedefs Friends