eoRndGenerators.h

/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

  -----------------------------------------------------------------------------
  eoRndGenerators.h

  mimics the rnd_generator.h by putting the generators in the EO-hierarchy

 (c) Maarten Keijzer (mak@dhi.dk) and GeNeura Team, 1999, 2000

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
 */

//-----------------------------------------------------------------------------

#ifndef eoRndGenerators_h
#define eoRndGenerators_h

#include "eoRNG.h"
#include <eoFunctor.h>
#include <stdexcept>

using eo::rng;

template <class T>
class eoRndGenerator : public eoF<T>
{
  typedef T AtomType;
};

template <class T = double> class eoUniformGenerator : public eoRndGenerator<T>
{
  // added new ctor with 2 params, and modified the data to minim and range
  // (was maxim only). MS 3/11/2000
  public :
    eoUniformGenerator(T _max = T(1.0), eoRng& _rng = rng) :
      minim(T(0.0)), range(_max), uniform(_rng) {}
    eoUniformGenerator(T _min, T _max, eoRng& _rng = rng) :
      minim(_min), range(_max-_min), uniform(_rng)
  {
    if (_min>_max)
      throw std::logic_error("Min is greater than Max in uniform_generator");
  }

  T operator()(void) { return minim+static_cast<T>(uniform.uniform(range)); }

private :
  T minim;
  T range;
  eoRng& uniform;
};


template <>
inline bool eoUniformGenerator<bool>::operator()(void)
{
    return uniform.flip(0.5);
}

class eoBooleanGenerator : public eoRndGenerator<bool>
{
  public :
  eoBooleanGenerator(float _bias = 0.5, eoRng& _rng = rng) : bias(_bias), gen(_rng) {}

  bool operator()(void) { return gen.flip(bias); }
  private :
  float bias;
  eoRng& gen;
};

template <class T = double> class eoNormalGenerator : public eoRndGenerator<T>
{
  public :
    eoNormalGenerator(T _stdev = T(1.0), eoRng& _rng = rng) : stdev(_stdev), normal(_rng) {}

  T operator()(void) { return (T) normal.normal(stdev); }

  private :
    T stdev;
  eoRng& normal;
};

template <class T = double> class eoNegExpGenerator : public eoRndGenerator<T>
{
  public :
    eoNegExpGenerator(T _mean = 1.0, eoRng& _rng = rng) : mean(_mean), negexp(_rng) {}

  T operator()(void) { return (T) negexp.negexp(mean); }

  private :
    T mean;
  eoRng& negexp;
};

#endif

---