Added new files to the brew, mainly distance and new-op-interface related
This commit is contained in:
jmerelo
parent
472898871c
commit
7db1492943
40 changed files with 2490 additions and 992 deletions
|
|
@ -5,22 +5,25 @@
|
|||
###############################################################################
|
||||
|
||||
lib_LIBRARIES = libeo.a
|
||||
libeo_a_SOURCES = eoPrintable.cpp eoPersistent.cpp eoParserUtils.cpp
|
||||
libeo_a_SOURCES = eoPrintable.cpp eoPersistent.cpp
|
||||
|
||||
libeoincdir = $(includedir)/eo
|
||||
libeoinc_HEADERS = EO.h eo eo1d.h eo2d.h eo2dVector.h eoAged.h eoAlgo.h\
|
||||
libeoinc_HEADERS = EO.h eo eo1d.h eo1dWDistance.h eo2d.h \
|
||||
eo2dVector.h eoAged.h eoAlgo.h\
|
||||
eoAltBreeder.h eoAltProportionalOpSel.h\
|
||||
eoAtomBitFlip.h eoAtomCreep.h eoAtomMutation.h eoAtomMutator.h \
|
||||
eoAtomRandom.h eoBin.h eoBitOp.h eoBitOpFactory.h eoBreeder.h\
|
||||
eoData.h eoDetTournament.h eoDup.h eoESChrom.h eoESFullChrom.h \
|
||||
eoESFullMut.h eoEasyEA.h\
|
||||
eoEvalFunc.h eoEvalFuncPtr.h eoFitTerm.h eoFitness.h\
|
||||
eoGenTerm.h eoGeneration.h eoID.h eoInclusion.h eoInsertion.h\
|
||||
eoKill.h eoLottery.h eoMerge.h eoMultiBinOp.h eoMultiMonOp.h \
|
||||
eoMutation.h eoNegExp.h\
|
||||
eoData.h eoDetTournament.h eoDistance.h eoDup.h eoESChrom.h \
|
||||
eoESFullChrom.h eoESFullMut.h eoEasyEA.h\
|
||||
eoEvalFunc.h eoEvalFuncPtr.h eoEvalFuncPtrCnt.h eoFitTerm.h eoFitness.h\
|
||||
eoGenTerm.h eoGeneralOp.h eoGeneration.h eoGOpSelector.h eoID.h\
|
||||
eoInclusion.h eoInsertion.h\
|
||||
eoKill.h eoLottery.h eoMerge.h eoMultiBinOp.h eoMultiMonOp.h eoMutation.h eoNegExp.h\
|
||||
eoNonUniform.h eoNormal.h eoObject.h eoOp.h eoOpSelector.h\
|
||||
eoParser.h eoPersistent.h eoPop.h eoPopOps.h eoPrintable.h\
|
||||
eoProblem.h eoProportionalOpSel.h eoRNG.h eoRnd.h eoString.h\
|
||||
eoProblem.h eoProportionalGOpSel.h eoProportionalOpSel.h eoRNG.h\
|
||||
eoRnd.h eoString.h\
|
||||
eoStochTournament.h eoTerm.h eoTranspose.h eoUniform.h \
|
||||
eoUniformSelect.h eoUniformXOver.h eoVector.h eoXOver2.h \
|
||||
eoParserUtils.h
|
||||
eoUniformSelect.h eoUniformXOver.h eoVector.h eoXOver2.h
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eo1d.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
eo1d.h
|
||||
Serial EO.
|
||||
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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
|
||||
|
|
@ -43,7 +45,6 @@ using namespace std;
|
|||
*/
|
||||
|
||||
//@{
|
||||
|
||||
/** eo1d: Base class for "chromosomes" with a single dimension
|
||||
#T# is the type it will be instantiated with; this type must have, at
|
||||
least, a copy ctor, assignment operators,
|
||||
|
|
@ -91,7 +92,7 @@ public:
|
|||
This implies that T must have a copy ctor .
|
||||
@param _i index of the gene, which is the minimal unit. Must be
|
||||
an unsigned less than #length()#
|
||||
@return what's inside the gene, with the correct type
|
||||
@return what's inside the gene, with the correct type
|
||||
@exception out_of_range if _i > size()
|
||||
*/
|
||||
virtual T getGene( unsigned _i ) const = 0;
|
||||
|
|
@ -99,8 +100,8 @@ public:
|
|||
/** Overwrites the gene placed in position _i with a
|
||||
* new value. This means that the assignment operator
|
||||
* for T must be defined .
|
||||
@param _i index
|
||||
@return what's inside the gene, with the correct type
|
||||
@param _i index
|
||||
@return what's inside the gene, with the correct type
|
||||
@exception out_of_range if _i > size()
|
||||
*/
|
||||
virtual void setGene( unsigned _i, const T& _value ) = 0;
|
||||
|
|
@ -121,16 +122,16 @@ public:
|
|||
|
||||
/// Returns the number of genes in the eo1d
|
||||
virtual unsigned length() const = 0;
|
||||
|
||||
/// @name Methods from eoObject
|
||||
|
||||
/// @name Methods from eoObject
|
||||
//@{
|
||||
/**
|
||||
* Read object. Theoretically, the length is known in advance. All objects
|
||||
* Read object. Theoretically, the length is known in advance. All objects
|
||||
* Should call base class
|
||||
* @param _s A istream.
|
||||
* @throw runtime_exception If a valid object can't be read.
|
||||
*/
|
||||
virtual void readFrom(istream& _s) {
|
||||
virtual void readFrom(istream& _s) {
|
||||
|
||||
for ( unsigned i = 0; i < length(); i ++ ) {
|
||||
T tmp;
|
||||
|
|
@ -142,7 +143,7 @@ public:
|
|||
}
|
||||
|
||||
/** Print itself: inherited from eoObject implementation.
|
||||
Instance from base classes are processed in
|
||||
Instance from base classes are processed in
|
||||
base classes, so you don´t have to worry about, for instance, fitness.
|
||||
@param _s the ostream in which things are written*/
|
||||
virtual void printOn( ostream& _s ) const{
|
||||
|
|
@ -155,8 +156,8 @@ public:
|
|||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eo1d";};
|
||||
|
||||
//@}
|
||||
|
||||
//@}
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -171,7 +172,7 @@ public:
|
|||
@param _ID An ID string, preferably unique
|
||||
*/
|
||||
template< class T, class fitnessT>
|
||||
eo1d<T,fitnessT>::eo1d<T,fitnessT>( unsigned _size, eoRnd<T>& _rndGen,
|
||||
eo1d<T,fitnessT>::eo1d<T,fitnessT>( unsigned _size, eoRnd<T>& _rndGen,
|
||||
const string& _ID )
|
||||
:EO<fitnessT> ( _ID ) {
|
||||
for ( unsigned i = 0; i < _size; i ++ ) {
|
||||
|
|
|
|||
136
eo/src/eo1dWDistance.h
Normal file
136
eo/src/eo1dWDistance.h
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eo1dWDistance.h
|
||||
Serial EO with distances. Acts as a wrapper for normal eo1ds
|
||||
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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 _EO1DWDISTANCE_H
|
||||
#define _EO1DWDISTANCE_H
|
||||
|
||||
#include <iostream> // for ostream
|
||||
|
||||
// EO Includes
|
||||
#include <eo1d.h>
|
||||
#include <eoDistance.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
/** eo1dWDistance: wraps around eo1ds and adds the possibility of computing distances
|
||||
around them.
|
||||
*/
|
||||
template<class T, class fitnessT = float>
|
||||
class eo1dWDistance:
|
||||
public eo1d< T,fitnessT >,
|
||||
public eoDistance<eo1d<T,fitnessT> > {
|
||||
public:
|
||||
|
||||
/** Can be used as default ctor; should be called from derived
|
||||
classes. Fitness should be at birth
|
||||
*/
|
||||
eo1dWDistance( eo1d<T,fitnessT>& _eo)
|
||||
:eo1d<T,fitnessT> (), eoDistance< eo1d<T,fitnessT> >(), innereo1d( _eo ) {};
|
||||
|
||||
/// Needed virtual dtor
|
||||
virtual ~eo1dWDistance(){};
|
||||
|
||||
/** Reads and returns a copy of the gene in position _i
|
||||
This implies that T must have a copy ctor .
|
||||
@param _i index of the gene, which is the minimal unit. Must be
|
||||
an unsigned less than #length()#
|
||||
@return what's inside the gene, with the correct type
|
||||
@exception out_of_range if _i > size()
|
||||
*/
|
||||
virtual T getGene( unsigned _i ) const {
|
||||
return innereo1d.getGene( _i );
|
||||
};
|
||||
|
||||
/** Overwrites the gene placed in position _i with a
|
||||
* new value. This means that the assignment operator
|
||||
* for T must be defined .
|
||||
@param _i index
|
||||
@return what's inside the gene, with the correct type
|
||||
@exception out_of_range if _i > size()
|
||||
*/
|
||||
virtual void setGene( unsigned _i, const T& _value ) {
|
||||
innereo1d.setGene( _i, _value);
|
||||
};
|
||||
|
||||
/** Inserts a gene, moving the rest to the right. If
|
||||
* _i = length(), it should insert it at the end.
|
||||
* Obviously, changes length
|
||||
@param _i index
|
||||
@param _val new value
|
||||
*/
|
||||
virtual void insertGene( unsigned _i, T _val ) {
|
||||
innereo1d.insertGene( _i, _val);
|
||||
}
|
||||
|
||||
/** Eliminates the gene at position _i; all the other genes will
|
||||
be shifted left
|
||||
@param _i index of the gene that is going to be modified.
|
||||
*/
|
||||
virtual void deleteGene( unsigned _i ) {
|
||||
innereo1d.deleteGene( _i );
|
||||
}
|
||||
|
||||
/// Returns the number of genes in the eo1d
|
||||
virtual unsigned length() const {
|
||||
return innereo1d.length();
|
||||
}
|
||||
|
||||
/// Returns the distance from this EO to the other
|
||||
virtual double distance( const eo1d<T,fitnessT>& _eo ) const {
|
||||
double tmp = 0;
|
||||
// Which one is shorter
|
||||
unsigned len = (innereo1d.length() < _eo.length()) ? _eo.length():innereo1d.length();
|
||||
|
||||
// Compute over the whole length. If it does not exists, it counts as 0
|
||||
for ( unsigned i = 0; i < len; i ++ ) {
|
||||
T val1, val2;
|
||||
val1 = ( i > innereo1d.length())?0:innereo1d.getGene(i);
|
||||
val2 = ( i > _eo.length() )?0:_eo.getGene(i);
|
||||
double diff = val1 - val2;
|
||||
tmp += diff*diff;
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eo1dWDistance";};
|
||||
|
||||
//@}
|
||||
|
||||
private:
|
||||
///Private ctor. Do not use
|
||||
eo1dWDistance() {};
|
||||
|
||||
|
||||
eo1d<T,fitnessT>& innereo1d;
|
||||
};
|
||||
|
||||
//@}
|
||||
|
||||
|
||||
#endif
|
||||
302
eo/src/eoAltBreeder.h
Normal file
302
eo/src/eoAltBreeder.h
Normal file
|
|
@ -0,0 +1,302 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// eoBreeder.h
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef eoBreeder_h
|
||||
#define eoBreeder_h
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <vector> // vector
|
||||
#include <iterator>
|
||||
#include <eoUniform.h> // eoUniform
|
||||
#include <eoOp.h> // eoOp, eoMonOp, eoBinOp
|
||||
#include <eoPop.h> // eoPop
|
||||
#include <eoPopOps.h> // eoTransform
|
||||
#include <eoOpSelector.h> // eoOpSelector
|
||||
#include <list>
|
||||
#include "eoRng.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
/*****************************************************************************
|
||||
* eoBreeder: transforms a population using genetic operators. *
|
||||
* For every operator there is a rated to be applyed. *
|
||||
*****************************************************************************/
|
||||
|
||||
template<class EOT, class OutIt>
|
||||
class eoGeneralOp: public eoOp<EOT>
|
||||
{
|
||||
public:
|
||||
|
||||
eoGeneralOp()
|
||||
:eoOp<EOT>( Nary ) {};
|
||||
virtual ~eoGeneralOp () {};
|
||||
|
||||
virtual void operator()( vector<const EOT*> _in, OutIt _out) const = 0;
|
||||
virtual int nInputs(void) const = 0;
|
||||
virtual int nOutputs(void) const = 0; // no support for 2 -> 2 xover
|
||||
|
||||
virtual string className() const {return "eoGeneralOp";};
|
||||
};
|
||||
|
||||
template <class EOT, class OutIt>
|
||||
class eoWrappedMonOp : public eoGeneralOp<EOT, OutIt>
|
||||
{
|
||||
public :
|
||||
eoWrappedMonOp(const eoMonOp<EOT>& _op) : eoGeneralOp<EOT, OutIt>(), op(_op) {}
|
||||
virtual ~eoWrappedMonOp() {}
|
||||
|
||||
void operator()( vector<const EOT*> _in, OutIt _out) const
|
||||
{
|
||||
*_out = *_in[0];
|
||||
op(*_out );
|
||||
}
|
||||
|
||||
int nInputs(void) const { return 1; }
|
||||
int nOutputs(void) const { return 1; }
|
||||
|
||||
virtual string className() const {return "eoWrappedOp";};
|
||||
|
||||
|
||||
private :
|
||||
const eoMonOp<EOT>& op;
|
||||
};
|
||||
|
||||
template <class EOT, class OutIt>
|
||||
class eoWrappedBinOp : public eoGeneralOp<EOT, OutIt>
|
||||
{
|
||||
public :
|
||||
eoWrappedBinOp(const eoBinOp<EOT>& _op) : eoGeneralOp<EOT, OutIt>(), op(_op) {}
|
||||
virtual ~eoWrappedBinOp() {}
|
||||
|
||||
void operator()( vector<const EOT*> _in, OutIt _out) const
|
||||
{
|
||||
*_out = *_in[0];
|
||||
*(_out + 1) = *_in[1];
|
||||
op(*_out, *(_out + 1));
|
||||
}
|
||||
|
||||
int nInputs(void) const { return 2; }
|
||||
int nOutputs(void) const { return 2; } // Yup, due to the bad design, can't choose between outputting 1 or 2
|
||||
|
||||
virtual string className() const {return "eoWrappedOp";};
|
||||
|
||||
|
||||
private :
|
||||
const eoBinOp<EOT>& op;
|
||||
};
|
||||
|
||||
template <class EOT, class OutIt>
|
||||
class eoCombinedOp : public eoGeneralOp<EOT, OutIt>
|
||||
{
|
||||
public :
|
||||
|
||||
eoCombinedOp() : eoGeneralOp<EOT, OutIt>(), arity(0) {}
|
||||
virtual ~eoCombinedOp() {}
|
||||
|
||||
int nInputs(void) const { return arity; }
|
||||
int nOutputs(void) const { return 1; }
|
||||
|
||||
void addOp(eoGeneralOp<EOT, OutIt>* _op)
|
||||
{
|
||||
ops.push_back(_op);
|
||||
arity = arity < _op->nInputs()? _op->nInputs() : arity;
|
||||
}
|
||||
|
||||
|
||||
void clear(void)
|
||||
{
|
||||
ops.resize(0);
|
||||
}
|
||||
|
||||
|
||||
void operator()( vector<const EOT*> _in, OutIt _out) const
|
||||
{
|
||||
for (int i = 0; i < ops.size(); ++i)
|
||||
{
|
||||
(*ops[i])(_in, _out);
|
||||
_in[0] = &*_out;
|
||||
}
|
||||
}
|
||||
|
||||
private :
|
||||
vector<eoGeneralOp<EOT, OutIt>* > ops;
|
||||
int arity;
|
||||
};
|
||||
|
||||
template<class EOT, class OutIt>
|
||||
class eoAltOpSelector: public eoOpSelector<EOT>, public vector<eoGeneralOp<EOT, OutIt>*>
|
||||
{
|
||||
public:
|
||||
|
||||
virtual ID addOp( eoOp<EOT>& _op, float _arg )
|
||||
{
|
||||
eoGeneralOp<EOT, OutIt>* op = dynamic_cast<eoGeneralOp<EOT, OutIt>*>(&_op);
|
||||
|
||||
|
||||
if (op == 0)
|
||||
{
|
||||
switch(_op.readArity())
|
||||
{
|
||||
case unary :
|
||||
oplist.push_back(auto_ptr<eoGeneralOp<EOT, OutIt> >(new eoWrappedMonOp<EOT, OutIt>(static_cast<eoMonOp<EOT>&>(_op))));
|
||||
|
||||
op = oplist.back().get();
|
||||
break;
|
||||
case binary :
|
||||
oplist.push_back(auto_ptr<eoGeneralOp<EOT, OutIt> >(new eoWrappedBinOp<EOT, OutIt>(static_cast<eoBinOp<EOT>&>(_op))));
|
||||
op = oplist.back().get();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
iterator result = find(begin(), end(), (eoGeneralOp<EOT, OutIt>*) 0); // search for nullpointer
|
||||
|
||||
if (result == end())
|
||||
{
|
||||
push_back(op);
|
||||
rates.push_back(_arg);
|
||||
return size();
|
||||
}
|
||||
// else
|
||||
|
||||
*result = op;
|
||||
ID id = result - begin();
|
||||
rates[id] = _arg;
|
||||
return id;
|
||||
}
|
||||
|
||||
virtual const eoOp<EOT>& getOp( ID _id )
|
||||
{
|
||||
return *operator[](_id);
|
||||
}
|
||||
|
||||
virtual void deleteOp( ID _id )
|
||||
{
|
||||
operator[](_id) = 0; // TODO, check oplist and clear it there too.
|
||||
rates[_id] = 0.0;
|
||||
}
|
||||
|
||||
virtual eoOp<EOT>* Op()
|
||||
{
|
||||
return &selectOp();
|
||||
}
|
||||
|
||||
|
||||
virtual eoGeneralOp<EOT, OutIt>& selectOp() = 0;
|
||||
|
||||
|
||||
virtual string className() const { return "eoAltOpSelector"; };
|
||||
|
||||
void printOn(ostream& _os) const {}
|
||||
|
||||
|
||||
protected :
|
||||
|
||||
vector<float> rates;
|
||||
list<auto_ptr<eoGeneralOp<EOT, OutIt> > > oplist;
|
||||
};
|
||||
|
||||
template <class EOT, class OutIt>
|
||||
class eoProportionalOpSelector : public eoAltOpSelector<EOT, OutIt>
|
||||
{
|
||||
public :
|
||||
eoProportionalOpSelector() : eoAltOpSelector<EOT, OutIt>() {}
|
||||
|
||||
|
||||
virtual eoGeneralOp<EOT, OutIt>& selectOp()
|
||||
{
|
||||
int what = rng.roulette_wheel(rates);
|
||||
|
||||
return *operator[](what);
|
||||
}
|
||||
};
|
||||
|
||||
template <class EOT, class OutIt>
|
||||
class eoSequentialOpSelector : public eoAltOpSelector<EOT, OutIt>
|
||||
{
|
||||
public :
|
||||
|
||||
eoSequentialOpSelector() : eoAltOpSelector<EOT, OutIt>() {}
|
||||
|
||||
virtual eoGeneralOp<EOT, OutIt>& selectOp()
|
||||
{
|
||||
for (int i = 0; i < size(); ++i)
|
||||
{
|
||||
if (operator[](i) == 0)
|
||||
continue;
|
||||
|
||||
if (rng.flip(rates[i]))
|
||||
combined.addOp(operator[](i));
|
||||
}
|
||||
|
||||
return combined;
|
||||
}
|
||||
|
||||
private :
|
||||
|
||||
eoCombinedOp<EOT, OutIt> combined;
|
||||
};
|
||||
|
||||
template <class EOT>
|
||||
class eoRandomIndy // living in a void right now
|
||||
{
|
||||
public :
|
||||
|
||||
eoRandomIndy() {}
|
||||
|
||||
vector<const EOT*> operator()(int _n, eoPop<EOT>::iterator _begin, eoPop<EOT>::iterator _end)
|
||||
{
|
||||
vector<const EOT*> result(_n);
|
||||
|
||||
for (int i = 0; i < result.size(); ++i)
|
||||
{
|
||||
result[i] = &*(_begin + rng.random(_end - _begin));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<class Chrom> class eoAltBreeder: public eoTransform<Chrom>
|
||||
{
|
||||
public:
|
||||
typedef eoPop<Chrom>::reverse_iterator outIt;
|
||||
/// Default constructor.
|
||||
eoAltBreeder( eoAltOpSelector<Chrom, outIt>& _opSel): opSel( _opSel ) {}
|
||||
|
||||
/// Destructor.
|
||||
virtual ~eoAltBreeder() {}
|
||||
|
||||
/**
|
||||
* Enlarges the population.
|
||||
* @param pop The population to be transformed.
|
||||
*/
|
||||
void operator()(eoPop<Chrom>& pop)
|
||||
{
|
||||
int size = pop.size();
|
||||
|
||||
for (unsigned i = 0; i < size; i++)
|
||||
{
|
||||
eoGeneralOp<Chrom, outIt>& op = opSel.selectOp();
|
||||
|
||||
pop.resize(pop.size() + op.nOutputs());
|
||||
vector<const Chrom*> indies = indySelector(op.nInputs(), pop.begin(), pop.begin() + size);
|
||||
|
||||
op(indies, pop.rbegin());
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/// The class name.
|
||||
string classname() const { return "eoAltBreeder"; }
|
||||
|
||||
private:
|
||||
eoAltOpSelector<Chrom, outIt >& opSel;
|
||||
eoRandomIndy<Chrom> indySelector;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif eoBreeder_h
|
||||
|
|
@ -1,63 +1,64 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoAtomRandom.h
|
||||
// Increments or decrements by one a single element
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 _EOATOMCREEP_H
|
||||
#define _EOATOMCREEP_H
|
||||
|
||||
#include <eoRandom.h>
|
||||
|
||||
/** Modifies using a random number generator, that is entered in the ctor.
|
||||
The RNG must return positive or negative numbers, whatever.
|
||||
*/
|
||||
template <class T>
|
||||
class eoAtomRandom: public eoAtomMutator<T> {
|
||||
public:
|
||||
|
||||
///
|
||||
eoAtomRandom( eoRandom& _rng): rng( _rng ) {};
|
||||
|
||||
///
|
||||
virtual ~eoAtomRandom() {};
|
||||
|
||||
///
|
||||
virtual void operator()( T& _val ) const {
|
||||
_val += rng();
|
||||
}
|
||||
|
||||
/** @name Methods from eoObject
|
||||
*/
|
||||
//@{
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eoAtomRandom";};
|
||||
//@}
|
||||
|
||||
private:
|
||||
eoRandom rng;
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoAtomRandom.h
|
||||
Increments or decrements by one a single element
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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 _EOATOMRANDOM_H
|
||||
#define _EOATOMRANDOM_H
|
||||
|
||||
#include <eoRnd.h>
|
||||
|
||||
/** Modifies using a random number generator, that is entered in the ctor.
|
||||
The RNG must return positive or negative numbers, whatever.
|
||||
*/
|
||||
template <class T>
|
||||
class eoAtomRandom: public eoAtomMutator<T> {
|
||||
public:
|
||||
|
||||
///
|
||||
eoAtomRandom( eoRnd<T>& _rng): rng( _rng ) {};
|
||||
|
||||
///
|
||||
virtual ~eoAtomRandom() {};
|
||||
|
||||
/// Adds the value generated by the RNG to the former value
|
||||
virtual void operator()( T& _val ) const {
|
||||
_val += rng();
|
||||
}
|
||||
|
||||
/** @name Methods from eoObject
|
||||
*/
|
||||
//@{
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eoAtomRandom";};
|
||||
//@}
|
||||
|
||||
private:
|
||||
eoRnd<T>& rng;
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,6 +1,28 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// eoData.h
|
||||
//-----------------------------------------------------------------------------
|
||||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoData.h
|
||||
Some numeric limits and types and things like that; with #ifdefs to keep
|
||||
compatibility
|
||||
|
||||
(c) GeNeura Team & Maarten Keijzer, 1998, 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 EODATA_H
|
||||
#define EODATA_H
|
||||
|
|
@ -22,8 +44,10 @@ using namespace std;
|
|||
#define MAXINT numeric_limits<int>::max()
|
||||
#else
|
||||
#include <float.h>
|
||||
#include <limits.h>
|
||||
#include <limits.h>
|
||||
#ifndef _WIN32 // should be the define for UN*X flavours: _POSIX??
|
||||
#include <values.h>
|
||||
#endif
|
||||
#ifndef MAXFLOAT
|
||||
#define MAXFLOAT (float)1e127
|
||||
#define MAXDOUBLE (double)1.79769313486231570e+308
|
||||
|
|
|
|||
63
eo/src/eoDistance.h
Normal file
63
eo/src/eoDistance.h
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoObject.h
|
||||
This is the base class for most objects in EO. It basically defines an interf
|
||||
face for giving names to classes.
|
||||
|
||||
(c) GeNeura Team, 1998, 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 EODISTANCE_H
|
||||
#define EODISTANCE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
using namespace std;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoDistance
|
||||
//-----------------------------------------------------------------------------
|
||||
/** Defines an interface for measuring distances between evolving objects */
|
||||
template <class EOT>
|
||||
class eoDistance {
|
||||
public:
|
||||
|
||||
/// Default Constructor.
|
||||
eoDistance() {}
|
||||
|
||||
/// Copy constructor.
|
||||
eoDistance( const eoDistance& ) {}
|
||||
|
||||
/// Virtual dtor. They are needed in virtual class hierarchies.
|
||||
virtual ~eoDistance() {}
|
||||
|
||||
|
||||
/** Return the distance from the object with this interface to other
|
||||
object of the same type.
|
||||
*/
|
||||
virtual double distance( const EOT& ) const = 0;
|
||||
|
||||
/// Returns classname
|
||||
virtual string className() const { return "eoDistance"; }
|
||||
|
||||
};
|
||||
|
||||
#endif EOOBJECT_H
|
||||
|
|
@ -57,7 +57,7 @@ template<class Chrom> class eoEasyEA: public eoAlgo<Chrom>
|
|||
|
||||
/// Apply one generation of evolution to the population.
|
||||
virtual void operator()(eoPop<Chrom>& pop) {
|
||||
while ( terminator( pop ) ){
|
||||
do {
|
||||
try
|
||||
{
|
||||
step(pop);
|
||||
|
|
@ -68,7 +68,7 @@ template<class Chrom> class eoEasyEA: public eoAlgo<Chrom>
|
|||
s.append( " in eoEasyEA ");
|
||||
throw runtime_error( s );
|
||||
}
|
||||
}
|
||||
} while ( terminator( pop ) );
|
||||
}
|
||||
|
||||
/// Class name.
|
||||
|
|
|
|||
|
|
@ -1,50 +1,59 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoOp.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 EOEVALFUNCPTR_H
|
||||
#define EOEVALFUNCPTR_H
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
|
||||
/** EOEvalFuncPtr: This class
|
||||
* takes an existing function pointer and converts it into a evaluation
|
||||
* function class. That way, old style C or C++ functions can be adapted to EO
|
||||
* function classes.
|
||||
*/
|
||||
template< class EOT >
|
||||
struct eoEvalFuncPtr: public eoEvalFunc<EOT> {
|
||||
|
||||
eoEvalFuncPtr( void (* _eval)( EOT& ) )
|
||||
: eoEvalFunc<EOT>(), evalFunc( _eval ) {};
|
||||
|
||||
/// Effectively applies the evaluation function to an EO
|
||||
virtual void operator() ( EOT & _eo ) const {
|
||||
(*evalFunc)( _eo );
|
||||
};
|
||||
|
||||
private:
|
||||
void (* evalFunc )( EOT& );
|
||||
};
|
||||
|
||||
#endif
|
||||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoEvalFuncPtr.h
|
||||
Converts a classical C fitness evaluation function into a fitness
|
||||
evaluation object
|
||||
|
||||
(c) GeNeura Team, 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 EOEVALFUNCPTR_H
|
||||
#define EOEVALFUNCPTR_H
|
||||
|
||||
#include <eoEvalFunc.h>
|
||||
|
||||
/** EOEvalFuncPtr: This class
|
||||
* takes an existing function pointer and converts it into a evaluation
|
||||
* function class. That way, old style C or C++ functions can be adapted to EO
|
||||
* function classes.
|
||||
*/
|
||||
template< class EOT >
|
||||
struct eoEvalFuncPtr: public eoEvalFunc<EOT> {
|
||||
|
||||
/** Applies the function to the chromosome and sets the fitness of the
|
||||
Chrom. Thus, the evaluation function need not be worried about that.
|
||||
@param _eval pointer to the evaluation function, takes a EOT as an
|
||||
argument and returns the fitness
|
||||
@return the evaluated fitness for that object.
|
||||
*/
|
||||
eoEvalFuncPtr( EOFitT (* _eval)( const EOT& ) )
|
||||
: eoEvalFunc<EOT>(), evalFunc( _eval ) {};
|
||||
|
||||
/// Effectively applies the evaluation function to an EO
|
||||
virtual void operator() ( EOT & _eo ) const {
|
||||
_eo.fitness((*evalFunc)( _eo ));
|
||||
};
|
||||
|
||||
private:
|
||||
EOFitT (* evalFunc )( EOT& );
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
62
eo/src/eoEvalFuncPtrCnt.h
Normal file
62
eo/src/eoEvalFuncPtrCnt.h
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoEvalFuncPtrCnt.h
|
||||
Same as eoEvalFuncPtr, but counts the number of evaluations
|
||||
|
||||
(c) GeNeura Team, 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 EOEVALFUNCPTRCNT_H
|
||||
#define EOEVALFUNCPTRCNT_H
|
||||
|
||||
#include <eoEvalFuncPtr.h>
|
||||
|
||||
/** EOEvalFuncCntPtr: This class
|
||||
* takes an existing function pointer and converts it into a evaluation
|
||||
* function class. That way, old style C or C++ functions can be adapted to EO
|
||||
* function classes.
|
||||
*/
|
||||
template< class EOT >
|
||||
struct eoEvalFuncPtrCnt: public eoEvalFuncPtr<EOT> {
|
||||
|
||||
/** Applies the function to the chromosome and sets the fitness of the
|
||||
Chrom. Thus, the evaluation function need not be worried about that.
|
||||
@param _eval pointer to the evaluation function, takes a EOT as an
|
||||
argument and returns the fitness
|
||||
@return the evaluated fitness for that object.
|
||||
*/
|
||||
eoEvalFuncPtrCnt( EOFitT (* _eval)( const EOT& ) )
|
||||
: eoEvalFuncPtr<EOT>( _eval ), numOfEvaluations( 0 ) {};
|
||||
|
||||
/// Effectively applies the evaluation function to an EO
|
||||
virtual void operator() ( EOT & _eo ) const {
|
||||
eoEvalFuncPtr<EOT>::operator()( _eo );
|
||||
numOfEvaluations++;
|
||||
};
|
||||
|
||||
///
|
||||
unsigned getNumOfEvaluations() const { return numOfEvaluations; };
|
||||
|
||||
private:
|
||||
mutable unsigned numOfEvaluations;
|
||||
};
|
||||
|
||||
#endif
|
||||
139
eo/src/eoGOpSelector.h
Normal file
139
eo/src/eoGOpSelector.h
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoGOpSelector.h
|
||||
Base class for generalized (n-inputs, n-outputs) operator selectors.
|
||||
Includes code and variables that contain operators and rates
|
||||
|
||||
(c) Maarten Keijzer, GeNeura Team 1998, 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 eoGOpSelector_h
|
||||
#define eoGOpSelector_h
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <vector> // vector
|
||||
#include <iterator>
|
||||
#include <eoUniform.h> // eoUniform
|
||||
#include <eoGeneralOp.h> // eoOp, eoMonOp, eoBinOp
|
||||
#include <eoPop.h> // eoPop
|
||||
#include <eoPopOps.h> // eoTransform
|
||||
#include <eoOpSelector.h> // eoOpSelector
|
||||
#include <list>
|
||||
#include "eoRNG.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
/** Base class for alternative selectors, which use the generalized operator
|
||||
interface */
|
||||
|
||||
template<class EOT>
|
||||
class eoGOpSelector: public eoOpSelector<EOT>, public vector<eoGeneralOp<EOT>*>
|
||||
{
|
||||
public:
|
||||
|
||||
/// Dtor
|
||||
virtual ~eoGOpSelector() {
|
||||
for ( list< eoGeneralOp<EOT>* >::iterator i= ownOpList.begin();
|
||||
i != ownOpList.begin(); i ++ ) {
|
||||
delete *i;
|
||||
}
|
||||
}
|
||||
|
||||
/// Add any kind of operator to the operator mix, with an argument
|
||||
virtual ID addOp( eoOp<EOT>& _op, float _arg ) {
|
||||
eoGeneralOp<EOT>* op = dynamic_cast<eoGeneralOp<EOT>*>(&_op);
|
||||
|
||||
// if it's not a general op, it's a "old" op; create a wrapped op from it
|
||||
// and keep it on a list to delete them afterwards
|
||||
// will use auto_ptr when they're readily available
|
||||
if (op == 0) {
|
||||
switch(_op.readArity())
|
||||
{
|
||||
case unary :
|
||||
op= new eoWrappedMonOp<EOT>(static_cast<eoMonOp<EOT>&>(_op));
|
||||
break;
|
||||
case binary :
|
||||
op = new eoWrappedBinOp<EOT>(static_cast<eoBinOp<EOT>&>(_op));
|
||||
break;
|
||||
}
|
||||
ownOpList.push_back( op );
|
||||
}
|
||||
|
||||
iterator result = find(begin(), end(), (eoGeneralOp<EOT>*) 0); // search for nullpointer
|
||||
|
||||
if (result == end())
|
||||
{
|
||||
push_back(op);
|
||||
rates.push_back(_arg);
|
||||
return size();
|
||||
}
|
||||
// else
|
||||
|
||||
*result = op;
|
||||
ID id = result - begin();
|
||||
rates[id] = _arg;
|
||||
return id;
|
||||
}
|
||||
|
||||
/** Retrieve the operator using its integer handle
|
||||
@param _id The id number. Should be a valid id, or an exception
|
||||
will be thrown
|
||||
@return a reference of the operator corresponding to that id.
|
||||
*/
|
||||
virtual const eoOp<EOT>& getOp( ID _id )
|
||||
{
|
||||
return *operator[](_id);
|
||||
}
|
||||
|
||||
///
|
||||
virtual void deleteOp( ID _id )
|
||||
{
|
||||
operator[](_id) = 0; // TODO, check oplist and clear it there too.
|
||||
rates[_id] = 0.0;
|
||||
}
|
||||
|
||||
///
|
||||
virtual eoOp<EOT>* Op()
|
||||
{
|
||||
return &selectOp();
|
||||
}
|
||||
|
||||
///
|
||||
virtual eoGeneralOp<EOT>& selectOp() = 0;
|
||||
|
||||
///
|
||||
virtual string className() const { return "eoGOpSelector"; };
|
||||
|
||||
///
|
||||
void printOn(ostream& _os) const {
|
||||
_os << className() << endl;
|
||||
for ( unsigned i=0; i!= rates.size(); i++ ) {
|
||||
_os << *(operator[](i)) << "\t" << rates[i] << endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
protected :
|
||||
vector<float> rates;
|
||||
list< eoGeneralOp<EOT>* > ownOpList;
|
||||
};
|
||||
|
||||
#endif eoGOpSelector_h
|
||||
200
eo/src/eoGeneralOp.h
Normal file
200
eo/src/eoGeneralOp.h
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoGeneralOp.h
|
||||
General genetic operator, which can be used to wrap any unary or binary
|
||||
operator
|
||||
(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 eoGeneralOp_h
|
||||
#define eoGeneralOp_h
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <vector> // vector
|
||||
#include <iterator>
|
||||
#include <eoUniform.h> // eoUniform
|
||||
#include <eoOp.h> // eoOp, eoMonOp, eoBinOp
|
||||
#include <eoPop.h> // eoPop
|
||||
#include <eoPopOps.h> // eoTransform
|
||||
#include <eoOpSelector.h> // eoOpSelector
|
||||
#include <list>
|
||||
#include "eoRNG.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
/**
|
||||
* eGeneralOp: General genetic operator; for objects used to transform sets
|
||||
of EOs
|
||||
*/
|
||||
template<class EOT>
|
||||
class eoGeneralOp: public eoOp<EOT>
|
||||
{
|
||||
public:
|
||||
|
||||
/// Ctor that honors its superclass
|
||||
eoGeneralOp(): eoOp<EOT>( Nary ) {};
|
||||
|
||||
/// Virtual dtor
|
||||
virtual ~eoGeneralOp () {};
|
||||
|
||||
/** Method that really does the stuff. Applies the genetic operator
|
||||
to a vector of inputs, and puts results in the output vector */
|
||||
virtual void operator()( eoPop<EOT>::iterator _in,
|
||||
insert_iterator< eoPop<EOT> > _out) const = 0;
|
||||
|
||||
/// Number of inputs
|
||||
virtual unsigned nInputs(void) const { return repNInputs;};
|
||||
|
||||
/// Number of output arguments, or arguments that are pushed onto the output vector
|
||||
virtual unsigned nOutputs(void) const { return repNOutputs; };
|
||||
|
||||
virtual string className() const {return "eoGeneralOp";};
|
||||
|
||||
protected:
|
||||
/// Default ctor; protected so that only derived classes can use it
|
||||
eoGeneralOp( unsigned _nInputs = 0, unsigned _nOutputs = 0 )
|
||||
: repNInputs( _nInputs), repNOutputs( _nOutputs) {};
|
||||
|
||||
/// change number of inputs
|
||||
void setNInputs( unsigned _nInputs) { repNInputs = _nInputs;};
|
||||
|
||||
/// change number of outputs
|
||||
void setNOutputs( unsigned _nOutputs) { repNOutputs = _nOutputs;};
|
||||
|
||||
private:
|
||||
unsigned repNInputs;
|
||||
unsigned repNOutputs;
|
||||
};
|
||||
|
||||
|
||||
/// Wraps monary operators
|
||||
template <class EOT>
|
||||
class eoWrappedMonOp : public eoGeneralOp<EOT>
|
||||
{
|
||||
public :
|
||||
///
|
||||
eoWrappedMonOp(const eoMonOp<EOT>& _op) : eoGeneralOp<EOT>( 1, 1), op(_op) {};
|
||||
|
||||
///
|
||||
virtual ~eoWrappedMonOp() {}
|
||||
|
||||
/// Instantiates the abstract method
|
||||
void operator()( eoPop<EOT>::iterator _in,
|
||||
insert_iterator< eoPop< EOT> > _out ) const {
|
||||
EOT result = *_in;
|
||||
op( result );
|
||||
*_out = result;
|
||||
}
|
||||
|
||||
///
|
||||
virtual string className() const {return "eoWrappedMonOp";};
|
||||
|
||||
|
||||
private :
|
||||
const eoMonOp<EOT>& op;
|
||||
};
|
||||
|
||||
|
||||
/// Wraps binary operators
|
||||
template <class EOT>
|
||||
class eoWrappedBinOp : public eoGeneralOp<EOT>
|
||||
{
|
||||
public :
|
||||
///
|
||||
eoWrappedBinOp(const eoBinOp<EOT>& _op) : eoGeneralOp<EOT>(2, 2), op(_op) {}
|
||||
|
||||
///
|
||||
virtual ~eoWrappedBinOp() {}
|
||||
|
||||
/// Instantiates the abstract method. EOT should have copy ctor.
|
||||
void operator()(eoPop<EOT>::iterator _in,
|
||||
insert_iterator< eoPop< EOT> > _out ) const {
|
||||
EOT out1 = *_in;
|
||||
_in++;
|
||||
EOT out2 = *_in;
|
||||
op(out1, out2);
|
||||
*_out++ = out1;
|
||||
*_out = out2;
|
||||
}
|
||||
|
||||
///
|
||||
virtual string className() const {return "eoWrappedBinOp";};
|
||||
|
||||
private :
|
||||
const eoBinOp<EOT>& op;
|
||||
};
|
||||
|
||||
/// Combines several ops
|
||||
template <class EOT>
|
||||
class eoCombinedOp : public eoGeneralOp<EOT>
|
||||
{
|
||||
public :
|
||||
|
||||
///
|
||||
eoCombinedOp() : eoGeneralOp<EOT>() {}
|
||||
|
||||
///
|
||||
virtual ~eoCombinedOp() {}
|
||||
|
||||
/// Adds a new operator to the combined Op
|
||||
void addOp(eoGeneralOp<EOT>* _op) {
|
||||
ops.push_back(_op);
|
||||
unsigned nInputs = nInputs() < _op->nInputs()? _op->nInputs() : nInputs;
|
||||
setNInputs( nInputs );
|
||||
unsigned nOutputs = nOutputs() < _op->nOutputs()? _op->nOutputs() : nOutputs;
|
||||
setNOutputs( nInputs );
|
||||
}
|
||||
|
||||
|
||||
/// Erases all operators added so far
|
||||
void clear(void) {
|
||||
ops.resize(0);
|
||||
}
|
||||
|
||||
|
||||
/// Applies all ops in the combined op
|
||||
void operator()( eoPop<EOT>::iterator _in,
|
||||
insert_iterator< eoPop< EOT> > _out ) const {
|
||||
// used for provisional input and output. Results are put in provOut,
|
||||
// and copied back to provIn.
|
||||
eoPop<EOT> provIn, provOut;
|
||||
insert_iterator< eoPop< EOT> > out = provOut.begin();
|
||||
ops[0]( _in, out );
|
||||
for ( unsigned i = 1; i < ops.size; i ++ ) {
|
||||
copy( provOut.begin(), provOut.end(), provIn.begin() );
|
||||
insert_iterator< eoPop< EOT> > in = provIn.begin();
|
||||
out = provOut.begin();
|
||||
ops[i]( in, out );
|
||||
}
|
||||
|
||||
// Copy back to output
|
||||
copy( provOut.begin(), provOut.end(), _out );
|
||||
|
||||
|
||||
}
|
||||
|
||||
private :
|
||||
vector<eoGeneralOp<EOT>* > ops;
|
||||
};
|
||||
|
||||
#endif eoGeneral_h
|
||||
|
|
@ -71,9 +71,9 @@ template<class Chrom> class eoGeneration: public eoAlgo<Chrom>
|
|||
string className() const { return "eoGeneration"; }
|
||||
|
||||
private:
|
||||
eoBinPopOp<Chrom>& select;
|
||||
eoBinPopOp<Chrom>& select;
|
||||
eoMonPopOp<Chrom>& transform;
|
||||
eoBinPopOp<Chrom>& replace;
|
||||
eoBinPopOp<Chrom>& replace;
|
||||
eoEvalFunc<Chrom>& evaluator;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// eoLottery.h
|
||||
// Implements the lottery procedure for selection
|
||||
// (c) GeNeura Team, 1998
|
||||
// (c) GeNeura Team, 1998 - Marc Schoenauer, 2000
|
||||
/*
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -33,53 +33,49 @@
|
|||
#include <eo> // eoPop eoSelect MINFLOAT
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/// eoLottery: a selection method.
|
||||
/// requires Chrom::Fitness to be float castable
|
||||
/** eoLottery: a selection method. Puts into the output a group of individuals
|
||||
selected using lottery; individuals with higher probability will have more
|
||||
chances of being selected.
|
||||
Requires EOT::Fitness to be float castable
|
||||
*/
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
template<class Chrom> class eoLottery: public eoBinPopOp<Chrom>
|
||||
template<class EOT> class eoLottery: public eoBinPopOp<EOT>
|
||||
{
|
||||
public:
|
||||
/// (Default) Constructor.
|
||||
eoLottery(const float& _rate = 1.0): rate(_rate) {}
|
||||
|
||||
///
|
||||
void operator()( eoPop<Chrom>& pop, eoPop<Chrom>& breeders)
|
||||
/** actually selects individuals from pop and pushes them back them into breeders
|
||||
* until breeders has the right size: rate*pop.size()
|
||||
* BUT what happens if breeders is already too big?
|
||||
* Too big for what?
|
||||
*/
|
||||
void operator()( eoPop<EOT>& pop, eoPop<EOT>& breeders)
|
||||
{
|
||||
// scores of chromosomes
|
||||
vector<float> score(pop.size());
|
||||
|
||||
// calculates accumulated scores for chromosomes
|
||||
for (unsigned i = 0; i < pop.size(); i++)
|
||||
// calculates total scores for chromosomes
|
||||
float total = 0;
|
||||
for (unsigned i = 0; i < pop.size(); i++) {
|
||||
score[i] = static_cast<float>(pop[i].fitness());
|
||||
total += score[i];
|
||||
}
|
||||
|
||||
// number of offspring needed
|
||||
int target = (int)rint(rate * pop.size());
|
||||
|
||||
// test of consistency
|
||||
if (breeders.size() >= target) {
|
||||
throw("Problem in eoLottery: already too many offspring");
|
||||
}
|
||||
|
||||
float sum = accumulate(score.begin(), score.end(), MINFLOAT);
|
||||
transform(score.begin(), score.end(), score.begin(),
|
||||
bind2nd(divides<float>(), sum));
|
||||
partial_sum(score.begin(), score.end(), score.begin());
|
||||
|
||||
// generates random numbers
|
||||
vector<float> random(rint(rate * pop.size()));
|
||||
generate(random.begin(), random.end(), eoUniform<float>(0,1));
|
||||
sort(random.begin(), random.end(), less<float>());
|
||||
|
||||
// selection of chromosomes
|
||||
unsigned score_index = 0; // position in score vector
|
||||
unsigned random_index = 0; // position in random vector
|
||||
while (breeders.size() < random.size())
|
||||
{
|
||||
if(random[random_index] < score[score_index])
|
||||
{
|
||||
breeders.push_back(pop[score_index]);
|
||||
random_index++;
|
||||
}
|
||||
else
|
||||
if (score_index < pop.size())
|
||||
score_index++;
|
||||
else
|
||||
fill_n(back_insert_iterator<eoPop<Chrom> >(breeders),
|
||||
random.size() - breeders.size(), pop.back());
|
||||
}
|
||||
while (breeders.size() < target) {
|
||||
unsigned indloc = rng.roulette_wheel(score, total);
|
||||
breeders.push_back(pop[indloc]);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoNegExp.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
eoNegExp.h
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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
|
||||
|
|
@ -43,7 +43,7 @@ class eoNegExp: public eoRnd<T>
|
|||
public:
|
||||
/**
|
||||
* Default constructor.
|
||||
* @param _mean Dsitribution mean
|
||||
* @param _mean Distribution mean
|
||||
*/
|
||||
eoNegExp(T _mean): eoRnd<T>(), mean(_mean) {};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,66 +1,69 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoObject.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 EOOBJECT_H
|
||||
#define EOOBJECT_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoData.h> // For limits definition
|
||||
#include <iostream> // istream, ostream
|
||||
#include <string> // string
|
||||
|
||||
using namespace std;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoObject
|
||||
//-----------------------------------------------------------------------------
|
||||
/**
|
||||
This is the base class for the whole hierarchy; an eoObject defines
|
||||
basically an interface for the whole hierarchy: each object should
|
||||
know its name (#className#). Previously, this object defined a print and read
|
||||
interface, but it´s been moved to eoPrintable and eoPersistent.
|
||||
*/
|
||||
class eoObject
|
||||
{
|
||||
public:
|
||||
|
||||
/// Default Constructor.
|
||||
eoObject() {}
|
||||
|
||||
/// Copy constructor.
|
||||
eoObject( const eoObject& ) {}
|
||||
|
||||
/// Virtual dtor. They are needed in virtual class hierarchies.
|
||||
virtual ~eoObject() {}
|
||||
|
||||
/** Return the class id. This should be redefined in each class; but
|
||||
it's got code as an example of implementation. Only "leaf" classes
|
||||
can be non-virtual.
|
||||
*/
|
||||
virtual string className() const { return "eoObject"; }
|
||||
|
||||
};
|
||||
|
||||
#endif EOOBJECT_H
|
||||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoObject.h
|
||||
This is the base class for most objects in EO. It basically defines an interf
|
||||
face for giving names to classes.
|
||||
|
||||
(c) GeNeura Team, 1998, 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 EOOBJECT_H
|
||||
#define EOOBJECT_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoData.h> // For limits definition
|
||||
#include <iostream> // istream, ostream
|
||||
#include <string> // string
|
||||
|
||||
using namespace std;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoObject
|
||||
//-----------------------------------------------------------------------------
|
||||
/**
|
||||
This is the base class for the whole hierarchy; an eoObject defines
|
||||
basically an interface for the whole hierarchy: each object should
|
||||
know its name (#className#). Previously, this object defined a print and read
|
||||
interface, but it´s been moved to eoPrintable and eoPersistent.
|
||||
*/
|
||||
class eoObject
|
||||
{
|
||||
public:
|
||||
|
||||
/// Default Constructor.
|
||||
eoObject() {}
|
||||
|
||||
/// Copy constructor.
|
||||
eoObject( const eoObject& ) {}
|
||||
|
||||
/// Virtual dtor. They are needed in virtual class hierarchies.
|
||||
virtual ~eoObject() {}
|
||||
|
||||
/** Return the class id. This should be redefined in each class; but
|
||||
it's got code as an example of implementation. Only "leaf" classes
|
||||
can be non-virtual.
|
||||
*/
|
||||
virtual string className() const { return "eoObject"; }
|
||||
|
||||
};
|
||||
|
||||
#endif EOOBJECT_H
|
||||
|
|
|
|||
|
|
@ -77,16 +77,15 @@ public:
|
|||
* @param _os A ostream.
|
||||
*/
|
||||
virtual void printOn(ostream& _os) const {
|
||||
_os << className();
|
||||
// _os << arity;
|
||||
_os << className();
|
||||
// _os << arity;
|
||||
};
|
||||
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
virtual string className() const {return "eoOp";};
|
||||
//@}
|
||||
|
||||
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
virtual string className() const {return "eoOp";};
|
||||
//@}
|
||||
|
||||
private:
|
||||
/// arity is the number of operands it takes
|
||||
|
|
|
|||
|
|
@ -1,85 +1,90 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoOpSelector.h
|
||||
// (c) GeNeura Team 1998
|
||||
/*
|
||||
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 EOOPSELECTOR_H
|
||||
#define EOOPSELECTOR_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <stdexcept> // runtime_error
|
||||
|
||||
#include <eoObject.h>
|
||||
#include <eoPrintable.h>
|
||||
#include <eoOp.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/** An operator selector is an object that contains a set of EO operators, and
|
||||
and selects one based on whatever criteria. It will be used in the breeder objects.\\
|
||||
This class is basically a generic interface for operator selection
|
||||
*/
|
||||
template<class EOT>
|
||||
class eoOpSelector: public eoObject, public eoPrintable
|
||||
{
|
||||
public:
|
||||
typedef unsigned ID;
|
||||
|
||||
/** add an operator to the operator set
|
||||
@param _op a genetic operator, that will be applied in some way
|
||||
@param _arg the operator rate, usually, or any other argument to the operator
|
||||
@return an ID that will be used to identify the operator
|
||||
*/
|
||||
virtual ID addOp( eoOp<EOT>& _op, float _arg ) = 0;
|
||||
|
||||
/** Gets a non-const reference to an operator, so that it can be changed,
|
||||
modified or whatever
|
||||
@param _id a previously assigned ID
|
||||
@throw runtime_exception if the ID does not exist*/
|
||||
virtual eoOp<EOT>& getOp( ID _id ) = 0;
|
||||
|
||||
/** Remove an operator from the operator set
|
||||
@param _id a previously assigned ID
|
||||
@throw runtime_exception if the ID does not exist
|
||||
*/
|
||||
virtual void deleteOp( ID _id ) = 0;
|
||||
|
||||
/// Returns a genetic operator according to the established criteria
|
||||
virtual eoOp<EOT>* Op() = 0;
|
||||
|
||||
/// Methods inherited from eoObject
|
||||
//@{
|
||||
|
||||
/** Return the class id.
|
||||
@return the class name as a string
|
||||
*/
|
||||
virtual string className() const { return "eoOpSelector"; };
|
||||
|
||||
/**
|
||||
* Read object and print objects are left for subclasses to define.
|
||||
*/
|
||||
//@}
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif EO_H
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoOpSelector.h
|
||||
Base class for operator selectors, which return 1 operator according
|
||||
to some criterium
|
||||
|
||||
(c) GeNeura Team 1998, 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 EOOPSELECTOR_H
|
||||
#define EOOPSELECTOR_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <stdexcept> // runtime_error
|
||||
|
||||
#include <eoObject.h>
|
||||
#include <eoPrintable.h>
|
||||
#include <eoOp.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/** An operator selector is an object that contains a set of EO operators,
|
||||
and selects one based on whatever criteria. It will be used in the breeder objects.\\
|
||||
This class is basically a generic interface for operator selection
|
||||
*/
|
||||
template<class EOT>
|
||||
class eoOpSelector: public eoObject, public eoPrintable
|
||||
{
|
||||
public:
|
||||
/// type of IDs assigned to each operators, used to handle them
|
||||
typedef unsigned ID;
|
||||
|
||||
/** add an operator to the operator set
|
||||
@param _op a genetic operator, that will be applied in some way
|
||||
@param _arg the operator rate, usually, or any other argument to the operator
|
||||
@return an ID that will be used to identify the operator
|
||||
*/
|
||||
virtual ID addOp( eoOp<EOT>& _op, float _arg ) = 0;
|
||||
|
||||
/** Gets a non-const reference to an operator, so that it can be changed,
|
||||
modified or whatever
|
||||
@param _id a previously assigned ID
|
||||
@throw runtime_exception if the ID does not exist*/
|
||||
virtual const eoOp<EOT>& getOp( ID _id ) = 0;
|
||||
|
||||
/** Remove an operator from the operator set
|
||||
@param _id a previously assigned ID
|
||||
@throw runtime_exception if the ID does not exist
|
||||
*/
|
||||
virtual void deleteOp( ID _id ) = 0;
|
||||
|
||||
/// Returns a genetic operator according to the established criteria
|
||||
virtual eoOp<EOT>* Op() = 0;
|
||||
|
||||
/// Methods inherited from eoObject
|
||||
//@{
|
||||
|
||||
/** Return the class id.
|
||||
@return the class name as a string
|
||||
*/
|
||||
virtual string className() const { return "eoOpSelector"; };
|
||||
|
||||
/**
|
||||
* Read object and print objects are left for subclasses to define.
|
||||
*/
|
||||
//@}
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif EO_H
|
||||
|
|
|
|||
153
eo/src/eoPop.h
153
eo/src/eoPop.h
|
|
@ -49,87 +49,76 @@ to the population.
|
|||
template<class EOT>
|
||||
class eoPop: public vector<EOT>, public eoObject, public eoPersistent {
|
||||
|
||||
/*
|
||||
Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
|
||||
An EO can have NO genes.
|
||||
/// Type is the type of each gene in the chromosome
|
||||
#ifdef _MSC_VER
|
||||
typedef EOT::Type Type;
|
||||
#else
|
||||
typedef typename EOT::Type Type;
|
||||
#endif
|
||||
*/
|
||||
|
||||
public:
|
||||
/** Protected ctor. This is intended to avoid creation of void populations, except
|
||||
from sibling classes
|
||||
*/
|
||||
eoPop():vector<EOT>() {};
|
||||
|
||||
|
||||
/** Ctor for fixed-size chromosomes, with variable content
|
||||
@param _popSize total population size
|
||||
@param _eoSize chromosome size. EOT should accept a fixed-size ctor
|
||||
@param _geneRdn random number generator for each of the genes
|
||||
*/
|
||||
/*
|
||||
Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
|
||||
This constructor must be substitued by one using factories.
|
||||
eoPop( unsigned _popSize, unsigned _eoSize, eoRnd<Type> & _geneRnd )
|
||||
:vector<EOT>() {
|
||||
for ( unsigned i = 0; i < _popSize; i ++ ){
|
||||
EOT tmpEOT( _eoSize, _geneRnd);
|
||||
push_back( tmpEOT );
|
||||
}
|
||||
};
|
||||
*/
|
||||
|
||||
/** Ctor for variable-size chromosomes, with variable content
|
||||
@param _popSize total population size
|
||||
@param _sizeRnd RNG for the chromosome size. This will be added 1, just in case.
|
||||
@param _geneRdn random number generator for each of the genes
|
||||
*/
|
||||
/*
|
||||
Victor Rivas (vrivas@ujaen.es): 15-Dec-1999
|
||||
This constructor must be substitued by one using factories.
|
||||
eoPop( unsigned _popSize, eoRnd<unsigned> & _sizeRnd, eoRnd<Type> & _geneRnd )
|
||||
:vector<EOT>() {
|
||||
for ( unsigned i = 0; i < _popSize; i ++ ){
|
||||
unsigned size = 1 + _sizeRnd();
|
||||
EOT tmpEOT( size, _geneRnd);
|
||||
push_back( tmpEOT );
|
||||
}
|
||||
};
|
||||
*/
|
||||
/** Ctor from an istream; reads the population from a stream,
|
||||
each element should be in different lines
|
||||
@param _is the stream
|
||||
*/
|
||||
eoPop( istream& _is ):vector<EOT>() {
|
||||
readFrom( _is );
|
||||
}
|
||||
|
||||
///
|
||||
~eoPop() {};
|
||||
|
||||
/** @name Methods from eoObject */
|
||||
//@{
|
||||
/**
|
||||
* Read object. The EOT class must have a ctor from a stream;
|
||||
in this case, a strstream is used.
|
||||
* @param _is A istream.
|
||||
|
||||
*/
|
||||
/// Type is the type of each gene in the chromosome
|
||||
#ifdef _MSC_VER
|
||||
typedef EOT::Type Type;
|
||||
#else
|
||||
typedef typename EOT::Type Type;
|
||||
#endif
|
||||
|
||||
public:
|
||||
/** Protected ctor. This is intended to avoid creation of void populations, except
|
||||
from sibling classes
|
||||
*/
|
||||
eoPop() :vector<EOT>() {};
|
||||
|
||||
|
||||
/** Ctor for fixed-size chromosomes, with variable content
|
||||
@param _popSize total population size
|
||||
@param _eoSize chromosome size. EOT should accept a fixed-size ctor
|
||||
@param _geneRdn random number generator for each of the genes
|
||||
*/
|
||||
eoPop( unsigned _popSize, unsigned _eoSize, eoRnd<Type> & _geneRnd )
|
||||
:vector<EOT>() {
|
||||
for ( unsigned i = 0; i < _popSize; i ++ ){
|
||||
EOT tmpEOT( _eoSize, _geneRnd);
|
||||
push_back( tmpEOT );
|
||||
}
|
||||
};
|
||||
|
||||
/** Ctor for variable-size chromosomes, with variable content
|
||||
@param _popSize total population size
|
||||
@param _sizeRnd RNG for the chromosome size. This will be added 1, just in case.
|
||||
@param _geneRdn random number generator for each of the genes
|
||||
*/
|
||||
eoPop( unsigned _popSize, eoRnd<unsigned> & _sizeRnd, eoRnd<Type> & _geneRnd )
|
||||
:vector<EOT>() {
|
||||
for ( unsigned i = 0; i < _popSize; i ++ ){
|
||||
unsigned size = 1 + _sizeRnd();
|
||||
EOT tmpEOT( size, _geneRnd);
|
||||
push_back( tmpEOT );
|
||||
}
|
||||
};
|
||||
|
||||
/** Ctor from an istream; reads the population from a stream,
|
||||
each element should be in different lines
|
||||
@param _is the stream
|
||||
*/
|
||||
eoPop( istream& _is ):vector<EOT>() {
|
||||
readFrom( _is );
|
||||
}
|
||||
|
||||
///
|
||||
~eoPop() {};
|
||||
|
||||
/** @name Methods from eoObject */
|
||||
//@{
|
||||
/**
|
||||
* Read object. The EOT class must have a ctor from a stream;
|
||||
in this case, a strstream is used.
|
||||
* @param _is A istream.
|
||||
|
||||
*/
|
||||
virtual void readFrom(istream& _is) {
|
||||
while( _is ) { // reads line by line, and creates an object per
|
||||
// line
|
||||
char line[MAXLINELENGTH];
|
||||
_is.getline( line, MAXLINELENGTH-1 );
|
||||
if (strlen( line ) ) {
|
||||
istrstream s( line );
|
||||
EOT thisEOT( s );
|
||||
push_back( thisEOT );
|
||||
}
|
||||
if (strlen( line ) ) {
|
||||
istrstream s( line );
|
||||
EOT thisEOT( s );
|
||||
push_back( thisEOT );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -138,18 +127,18 @@ public:
|
|||
* @param _os A ostream. In this case, prints the population to
|
||||
standard output. The EOT class must hav standard output with cout,
|
||||
but since it should be an eoObject anyways, it's no big deal.
|
||||
*/
|
||||
*/
|
||||
virtual void printOn(ostream& _os) const {
|
||||
copy( begin(), end(), ostream_iterator<EOT>( _os, "\n") );
|
||||
};
|
||||
|
||||
|
||||
/** Inherited from eoObject. Returns the class name.
|
||||
@see eoObject
|
||||
*/
|
||||
virtual string className() const {return "eoPop";};
|
||||
//@}
|
||||
|
||||
protected:
|
||||
|
||||
//@}
|
||||
|
||||
protected:
|
||||
|
||||
};
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoPopOps.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
eoPopOps.h
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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
|
||||
|
|
@ -108,7 +108,8 @@ class eoBinPopOp: public eoObject{
|
|||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/** eoSelect usually takes elements from one population, with or without transformation, and transfers them to the other population */
|
||||
/** eoSelectone selects only one element from a whole population. Usually used to
|
||||
select mates*/
|
||||
template<class EOT>
|
||||
class eoSelectOne: public eoObject{
|
||||
|
||||
|
|
|
|||
51
eo/src/eoProportionalGOpSel.h
Normal file
51
eo/src/eoProportionalGOpSel.h
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoProportionalGOpSel.h
|
||||
Proportional operator selector, selects operators proportionally to its rate
|
||||
|
||||
(c) Maarten Keijzer, GeNeura Team 1998, 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 eoProportionalGOpSel_h
|
||||
#define eoProportionalGOpSel_h
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoGOpSelector.h> // eoOpSelector
|
||||
|
||||
template <class EOT>
|
||||
class eoProportionalGOpSel : public eoGOpSelector<EOT>
|
||||
{
|
||||
public :
|
||||
eoProportionalGOpSel() : eoGOpSelector<EOT>() {}
|
||||
|
||||
/** Returns the operator proportionally selected */
|
||||
virtual eoGeneralOp<EOT>& selectOp()
|
||||
{
|
||||
unsigned what = rng.roulette_wheel(rates);
|
||||
return *operator[](what);
|
||||
}
|
||||
|
||||
///
|
||||
virtual string className() const { return "eoGOpSelector"; };
|
||||
|
||||
};
|
||||
|
||||
#endif eoProportionalGOpSel_h
|
||||
|
|
@ -113,7 +113,7 @@ public :
|
|||
@see reseed
|
||||
*/
|
||||
|
||||
eoRng(uint32 s = (uint32) time(0) ) : state(0), next(0), left(-1), cached(false), N(624), M(397), K((0x9908B0DFU)) {
|
||||
eoRng(uint32 s = (uint32) time(0) ) : state(0), next(0), left(-1), cached(false), N(624), M(397), K(0x9908B0DFU) {
|
||||
state = new uint32[N+1];
|
||||
initialize(s);
|
||||
}
|
||||
|
|
@ -197,7 +197,7 @@ public :
|
|||
{
|
||||
if (total == 0)
|
||||
{ // count
|
||||
for (unsigned i = 0; i < vec.size(); ++i)
|
||||
for (int i = 0; i < vec.size(); ++i)
|
||||
total += vec[i];
|
||||
}
|
||||
|
||||
|
|
|
|||
228
eo/src/eoRnd.h
228
eo/src/eoRnd.h
|
|
@ -1,114 +1,114 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoRnd.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 _EORND_H
|
||||
#define _EORND_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoObject.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class eoRnd
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <stdlib.h> // srand
|
||||
#include <time.h> // time
|
||||
#include <stdexcept> // runtime_error
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoPersistent.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/**
|
||||
* Base class for a family of random number generators. Generates numbers
|
||||
* according to the parameters given in the constructor. Uses the machine's
|
||||
* own random number generators. Which is not too good, after all.
|
||||
*/
|
||||
template<class T>
|
||||
class eoRnd: public eoObject, public eoPersistent
|
||||
{
|
||||
public:
|
||||
|
||||
/// default constructor
|
||||
eoRnd(unsigned _seed = 0) {
|
||||
if ( !started ) {
|
||||
srand(_seed?_seed:time(0));
|
||||
started = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// Copy cotor
|
||||
eoRnd(const eoRnd& _r ) {srand(time(0));};
|
||||
|
||||
/** Main function: random generators act as functors, that return random numbers.
|
||||
It´s non-const because it might modify a seed
|
||||
@return return a random number
|
||||
*/
|
||||
virtual T operator()() = 0;
|
||||
|
||||
/** Return the class id.
|
||||
@return the class name as a string
|
||||
*/
|
||||
virtual string className() const { return "eoRandom"; };
|
||||
|
||||
/**
|
||||
* Read object.
|
||||
* @param is A istream.
|
||||
* @throw runtime_exception If a valid object can't be read.
|
||||
*/
|
||||
virtual void readFrom(istream& _is);
|
||||
|
||||
/**
|
||||
* print object. Prints just the ID, since the seed is not accesible.
|
||||
* @param is A ostream.
|
||||
*/
|
||||
void printOn(ostream& _os) const { _os << endl; };
|
||||
|
||||
private:
|
||||
/// true if the RNG has been started already. If it starts every time, means trouble.
|
||||
static bool started;
|
||||
};
|
||||
|
||||
template<class T> bool eoRnd<T>::started = false;
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Read object.
|
||||
* @param is A istream.
|
||||
* @throw runtime_exception If a valid object can't be read.
|
||||
*/
|
||||
template<class T>
|
||||
void eoRnd<T>::readFrom(istream& _is) {
|
||||
if (!_is)
|
||||
throw runtime_error("Problems reading from stream in eoRnd");
|
||||
long seed;
|
||||
_is >> seed;
|
||||
srand(seed);
|
||||
}
|
||||
|
||||
#endif
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoRnd.h
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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 _EORND_H
|
||||
#define _EORND_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoObject.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class eoRnd
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <stdlib.h> // srand
|
||||
#include <time.h> // time
|
||||
#include <stdexcept> // runtime_error
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoPersistent.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/**
|
||||
* Base class for a family of random number generators. Generates numbers
|
||||
* according to the parameters given in the constructor. Uses the machine's
|
||||
* own random number generators. Which is not too good, after all.
|
||||
*/
|
||||
template<class T>
|
||||
class eoRnd: public eoObject, public eoPersistent
|
||||
{
|
||||
public:
|
||||
|
||||
/// default constructor
|
||||
eoRnd(unsigned _seed = 0) {
|
||||
if ( !started ) {
|
||||
srand(_seed?_seed:time(0));
|
||||
started = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// Copy cotor
|
||||
eoRnd(const eoRnd& _r ) {srand(time(0));};
|
||||
|
||||
/** Main function: random generators act as functors, that return random numbers.
|
||||
It´s non-const because it might modify a seed
|
||||
@return return a random number
|
||||
*/
|
||||
virtual T operator()() = 0;
|
||||
|
||||
/** Return the class id.
|
||||
@return the class name as a string
|
||||
*/
|
||||
virtual string className() const { return "eoRandom"; };
|
||||
|
||||
/**
|
||||
* Read object.
|
||||
* @param is A istream.
|
||||
* @throw runtime_exception If a valid object can't be read.
|
||||
*/
|
||||
virtual void readFrom(istream& _is);
|
||||
|
||||
/**
|
||||
* print object. Prints just the ID, since the seed is not accesible.
|
||||
* @param is A ostream.
|
||||
*/
|
||||
void printOn(ostream& _os) const { _os << endl; };
|
||||
|
||||
private:
|
||||
/// true if the RNG has been started already. If it starts every time, means trouble.
|
||||
static bool started;
|
||||
};
|
||||
|
||||
template<class T> bool eoRnd<T>::started = false;
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Read object.
|
||||
* @param is A istream.
|
||||
* @throw runtime_exception If a valid object can't be read.
|
||||
*/
|
||||
template<class T>
|
||||
void eoRnd<T>::readFrom(istream& _is) {
|
||||
if (!_is)
|
||||
throw runtime_error("Problems reading from stream in eoRnd");
|
||||
long seed;
|
||||
_is >> seed;
|
||||
srand(seed);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -60,6 +60,14 @@ public:
|
|||
*this += _rnd();
|
||||
}
|
||||
};
|
||||
|
||||
/** Ctor from a stream
|
||||
@param _s input stream
|
||||
*/
|
||||
eoString( istream & _s )
|
||||
: eo1d<char, fitnessT>(){
|
||||
_s >> *this;
|
||||
};
|
||||
|
||||
/// copy ctor
|
||||
eoString( const eoString<fitnessT>& _eoStr )
|
||||
|
|
|
|||
|
|
@ -1,71 +1,71 @@
|
|||
// eoUniform.h
|
||||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// EOUniform.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 _EOUNIFORM_H
|
||||
#define _EOUNIFORM_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoRnd.h>
|
||||
#include <eoRNG.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class eoUniform
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/// Generates uniform random number over the interval [min, max)
|
||||
template<class T>
|
||||
class eoUniform: public eoRnd<T>
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Default constructor.
|
||||
* @param _min The minimum value in the interval.
|
||||
* @param _max The maximum value in the interval.
|
||||
*/
|
||||
eoUniform(T _min = 0, T _max = 1)
|
||||
: eoRnd<T>(), min(_min), diff(_max - _min) {}
|
||||
|
||||
/**
|
||||
* copy constructor.
|
||||
* @param _rnd the other rnd
|
||||
*/
|
||||
eoUniform( const eoUniform& _rnd)
|
||||
: eoRnd<T>( _rnd), min(_rnd.minim), diff(_rnd.diff) {}
|
||||
|
||||
/** Returns an uniform random number over the interval [min, max)
|
||||
Uses global rng object */
|
||||
virtual T operator()() {
|
||||
return min + T( rng.uniform( diff ) );
|
||||
}
|
||||
|
||||
private:
|
||||
T min;
|
||||
double diff;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoUniform.h
|
||||
Uniform random number generator;
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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 _EOUNIFORM_H
|
||||
#define _EOUNIFORM_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <eoRnd.h>
|
||||
#include <eoRNG.h>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class eoUniform
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/// Generates uniform random number over the interval [min, max)
|
||||
template<class T>
|
||||
class eoUniform: public eoRnd<T>
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Default constructor.
|
||||
* @param _min The minimum value in the interval.
|
||||
* @param _max The maximum value in the interval.
|
||||
*/
|
||||
eoUniform(T _min = 0, T _max = 1)
|
||||
: eoRnd<T>(), min(_min), diff(_max - _min) {}
|
||||
|
||||
/**
|
||||
* copy constructor.
|
||||
* @param _rnd the other rnd
|
||||
*/
|
||||
eoUniform( const eoUniform& _rnd)
|
||||
: eoRnd<T>( _rnd), min(_rnd.minim), diff(_rnd.diff) {}
|
||||
|
||||
/** Returns an uniform random number over the interval [min, max)
|
||||
Uses global rng object */
|
||||
virtual T operator()() {
|
||||
return min + T( rng.uniform( diff ) );
|
||||
}
|
||||
|
||||
private:
|
||||
T min;
|
||||
double diff;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,169 +1,170 @@
|
|||
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// eoVector.h
|
||||
// (c) GeNeura Team, 1998
|
||||
/*
|
||||
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 _eoVector_H
|
||||
#define _eoVector_H
|
||||
|
||||
// STL libraries
|
||||
#include <vector> // For vector<int>
|
||||
#include <stdexcept>
|
||||
#include <strstream>
|
||||
|
||||
#include <eo1d.h>
|
||||
#include <eoRnd.h>
|
||||
|
||||
/** Adaptor that turns an STL vector into an EO
|
||||
with the same gene type as the type with which
|
||||
the vector has been instantiated
|
||||
*/
|
||||
template <class T, class fitnessT>
|
||||
class eoVector: public eo1d<T, fitnessT>, public vector<T> {
|
||||
public:
|
||||
typedef T Type ;
|
||||
|
||||
/// Canonical part of the objects: several ctors, copy ctor, dtor and assignment operator
|
||||
//@{
|
||||
|
||||
/** Ctor.
|
||||
@param _size Lineal length of the object
|
||||
@param _val Common initial value
|
||||
*/
|
||||
eoVector( unsigned _size = 0, T _val = 0)
|
||||
: eo1d<T, fitnessT>(), vector<T>( _size, _val ){ };
|
||||
|
||||
/** Ctor using a random number generator
|
||||
@param _size Lineal length of the object
|
||||
@param _rnd a random number generator, which returns a random value each time it´s called
|
||||
*/
|
||||
eoVector( unsigned _size, eoRnd<T>& _rnd );
|
||||
|
||||
/** Ctor from a istream. The T class should accept reading from a istream. It doesn't read fitness,
|
||||
which is supposed to be dynamic and dependent on environment.
|
||||
@param _is the input stream; should have all values in a single line, separated by whitespace
|
||||
*/
|
||||
eoVector( istream& _is);
|
||||
|
||||
|
||||
/// copy ctor
|
||||
eoVector( const eoVector & _eo )
|
||||
: eo1d<T, fitnessT>( _eo ), vector<T>( _eo ){ };
|
||||
|
||||
/// Assignment operator
|
||||
const eoVector& operator =( const eoVector & _eo ) {
|
||||
if ( this != &_eo ){
|
||||
eo1d<T, fitnessT>::operator=( _eo );
|
||||
vector<T>::operator=( _eo );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// dtor
|
||||
virtual ~eoVector() {};
|
||||
|
||||
//@}
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual T getGene( unsigned _i ) const {
|
||||
if ( _i >= length() )
|
||||
throw out_of_range( "out_of_range when reading gene");
|
||||
return (*this)[_i];
|
||||
};
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void setGene( unsigned _i, const T& _value ) {
|
||||
if ( _i >= size() )
|
||||
throw out_of_range( "out_of_range when writing a gene");
|
||||
(*this)[_i] = _value;
|
||||
};
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void insertGene( unsigned _i, T _val ) {
|
||||
if (_i <= size() ) {
|
||||
vector<T>::iterator i = begin()+_i;
|
||||
insert( i, _val );
|
||||
} else {
|
||||
throw out_of_range( "out_of_range when inserting a gene");
|
||||
}
|
||||
};
|
||||
|
||||
/** Eliminates the gene at position _i
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void deleteGene( unsigned _i ) {
|
||||
if (_i < this->size() ) {
|
||||
vector<T>::iterator i = this->begin()+_i;
|
||||
this->erase( i );
|
||||
} else {
|
||||
throw out_of_range( "out_of_range when deleting a gene");
|
||||
};
|
||||
};
|
||||
|
||||
/// methods that implement the EO <em>protocol</em>
|
||||
virtual unsigned length() const { return this->size(); };
|
||||
|
||||
/** @name Methods from eoObject
|
||||
readFrom and printOn are directly inherited from eo1d
|
||||
*/
|
||||
//@{
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eoVector";};
|
||||
//@}
|
||||
|
||||
};
|
||||
|
||||
|
||||
//____________________________ Some method implementation _______________________
|
||||
|
||||
// Ctors______________________________________________________________________________
|
||||
//____________________________________________________________________________________
|
||||
template <class T, class fitnessT>
|
||||
eoVector<T,fitnessT>::eoVector( unsigned _size, eoRnd<T>& _rnd )
|
||||
: eo1d<T, fitnessT>(), vector<T>( _size ){
|
||||
for ( iterator i = begin(); i != end(); i ++ ) {
|
||||
*i = _rnd();
|
||||
}
|
||||
};
|
||||
|
||||
//____________________________________________________________________________________
|
||||
template <class T, class fitnessT>
|
||||
eoVector<T,fitnessT>::eoVector( istream& _is)
|
||||
: eo1d<T, fitnessT>(), vector<T>( ){
|
||||
while (_is ) {
|
||||
T tmp;
|
||||
_is >> tmp;
|
||||
push_back( tmp );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
eoVector.h
|
||||
Turns an STL vector into an EO
|
||||
(c) GeNeura Team, 1998
|
||||
|
||||
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 _eoVector_H
|
||||
#define _eoVector_H
|
||||
|
||||
// STL libraries
|
||||
#include <vector> // For vector<int>
|
||||
#include <stdexcept>
|
||||
#include <strstream>
|
||||
|
||||
#include <eo1d.h>
|
||||
#include <eoRnd.h>
|
||||
|
||||
/** Adaptor that turns an STL vector into an EO
|
||||
with the same gene type as the type with which
|
||||
the vector has been instantiated
|
||||
*/
|
||||
template <class T, class fitnessT=float>
|
||||
class eoVector: public eo1d<T, fitnessT>, public vector<T> {
|
||||
public:
|
||||
typedef T Type ;
|
||||
|
||||
/// Canonical part of the objects: several ctors, copy ctor, dtor and assignment operator
|
||||
//@{
|
||||
|
||||
/** Ctor.
|
||||
@param _size Lineal length of the object
|
||||
@param _val Common initial value
|
||||
*/
|
||||
eoVector( unsigned _size = 0, T _val = 0)
|
||||
: eo1d<T, fitnessT>(), vector<T>( _size, _val ){ };
|
||||
|
||||
/** Ctor using a random number generator
|
||||
@param _size Lineal length of the object
|
||||
@param _rnd a random number generator, which returns a random value each time it´s called
|
||||
*/
|
||||
eoVector( unsigned _size, eoRnd<T>& _rnd );
|
||||
|
||||
/** Ctor from a istream. The T class should accept reading from a istream. It doesn't read fitness,
|
||||
which is supposed to be dynamic and dependent on environment.
|
||||
@param _is the input stream; should have all values in a single line, separated by whitespace
|
||||
*/
|
||||
eoVector( istream& _is);
|
||||
|
||||
|
||||
/// copy ctor
|
||||
eoVector( const eoVector & _eo )
|
||||
: eo1d<T, fitnessT>( _eo ), vector<T>( _eo ){ };
|
||||
|
||||
/// Assignment operator
|
||||
const eoVector& operator =( const eoVector & _eo ) {
|
||||
if ( this != &_eo ){
|
||||
eo1d<T, fitnessT>::operator=( _eo );
|
||||
vector<T>::operator=( _eo );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// dtor
|
||||
virtual ~eoVector() {};
|
||||
|
||||
//@}
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual T getGene( unsigned _i ) const {
|
||||
if ( _i >= length() )
|
||||
throw out_of_range( "out_of_range when reading gene");
|
||||
return (*this)[_i];
|
||||
};
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void setGene( unsigned _i, const T& _value ) {
|
||||
if ( _i >= size() )
|
||||
throw out_of_range( "out_of_range when writing a gene");
|
||||
(*this)[_i] = _value;
|
||||
};
|
||||
|
||||
/** methods that implement the eo1d <em>protocol</em>
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void insertGene( unsigned _i, T _val ) {
|
||||
if (_i <= size() ) {
|
||||
vector<T>::iterator i = begin()+_i;
|
||||
insert( i, _val );
|
||||
} else {
|
||||
throw out_of_range( "out_of_range when inserting a gene");
|
||||
}
|
||||
};
|
||||
|
||||
/** Eliminates the gene at position _i
|
||||
@exception out_of_range if _i is larger than EO´s size
|
||||
*/
|
||||
virtual void deleteGene( unsigned _i ) {
|
||||
if (_i < this->size() ) {
|
||||
vector<T>::iterator i = this->begin()+_i;
|
||||
this->erase( i );
|
||||
} else {
|
||||
throw out_of_range( "out_of_range when deleting a gene");
|
||||
};
|
||||
};
|
||||
|
||||
/// methods that implement the EO <em>protocol</em>
|
||||
virtual unsigned length() const { return this->size(); };
|
||||
|
||||
/** @name Methods from eoObject
|
||||
readFrom and printOn are directly inherited from eo1d
|
||||
*/
|
||||
//@{
|
||||
/** Inherited from eoObject
|
||||
@see eoObject
|
||||
*/
|
||||
string className() const {return "eoVector";};
|
||||
//@}
|
||||
|
||||
};
|
||||
|
||||
|
||||
//____________________________ Some method implementation _______________________
|
||||
|
||||
// Ctors______________________________________________________________________________
|
||||
//____________________________________________________________________________________
|
||||
template <class T, class fitnessT>
|
||||
eoVector<T,fitnessT>::eoVector( unsigned _size, eoRnd<T>& _rnd )
|
||||
: eo1d<T, fitnessT>(), vector<T>( _size ){
|
||||
for ( iterator i = begin(); i != end(); i ++ ) {
|
||||
*i = _rnd();
|
||||
}
|
||||
};
|
||||
|
||||
//____________________________________________________________________________________
|
||||
template <class T, class fitnessT>
|
||||
eoVector<T,fitnessT>::eoVector( istream& _is)
|
||||
: eo1d<T, fitnessT>(), vector<T>( ){
|
||||
while (_is ) {
|
||||
T tmp;
|
||||
_is >> tmp;
|
||||
push_back( tmp );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Reference in a new issue