nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Added new files to the brew, mainly distance and new-op-interface related

Browse source
This commit is contained in:
jmerelo 2000-02-07 17:16:16 +00:00
commit 7db1492943
40 changed files with 2490 additions and 992 deletions
Download patch file Download diff file Expand all files Collapse all files

4
eo/configure.in
View file

@ -1,6 +1,7 @@
AC_INIT(src/eo)
AM_INIT_AUTOMAKE(eo, 0.0.8)
dnl Change the version number here
AM_INIT_AUTOMAKE(eo)
AC_PROG_CXX
@ -10,4 +11,5 @@ AM_PROG_LIBTOOL
AM_MAINTAINER_MODE
dnl add Makefiles that must be modified by the configuration here
AC_OUTPUT(Makefile src/Makefile test/Makefile win/Makefile)

25
eo/src/Makefile.am
View file

@ -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

13
eo/src/eo1d.h
View file

@ -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
Serial EO.
(c) GeNeura Team, 1998
//-----------------------------------------------------------------------------
// eo1d.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 +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,

136
eo/src/eo1dWDistance.h Normal file
View 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
View 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

25
eo/src/eoAtomRandom.h
View file

@ -1,10 +1,10 @@
// -*- 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; -*-
-----------------------------------------------------------------------------
eoAtomRandom.h
Increments or decrements by one a single element
(c) GeNeura Team, 1998
//-----------------------------------------------------------------------------
// 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
@ -22,10 +22,11 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
*/
//-----------------------------------------------------------------------------
#ifndef _EOATOMCREEP_H
#define _EOATOMCREEP_H
#include <eoRandom.h>
#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.
@ -35,12 +36,12 @@ class eoAtomRandom: public eoAtomMutator<T> {
public:
///
eoAtomRandom( eoRandom& _rng): rng( _rng ) {};
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();
}
@ -55,7 +56,7 @@ public:
//@}
private:
eoRandom rng;
eoRnd<T>& rng;
};

30
eo/src/eoData.h
View file

@ -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
@ -23,7 +45,9 @@ using namespace std;
#else
#include <float.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
View 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

4
eo/src/eoEasyEA.h
View file

@ -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.

25
eo/src/eoEvalFuncPtr.h
View file

@ -1,9 +1,12 @@
// -*- 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; -*-
-----------------------------------------------------------------------------
eoEvalFuncPtr.h
Converts a classical C fitness evaluation function into a fitness
evaluation object
(c) GeNeura Team, 2000
//-----------------------------------------------------------------------------
// 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
@ -35,16 +38,22 @@
template< class EOT >
struct eoEvalFuncPtr: public eoEvalFunc<EOT> {
eoEvalFuncPtr( void (* _eval)( 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 {
(*evalFunc)( _eo );
_eo.fitness((*evalFunc)( _eo ));
};
private:
void (* evalFunc )( EOT& );
EOFitT (* evalFunc )( EOT& );
};
#endif

62
eo/src/eoEvalFuncPtrCnt.h Normal file
View 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
View 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
View 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

58
eo/src/eoLottery.h
View file

@ -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,52 +33,48 @@
#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];
}
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());
// number of offspring needed
int target = (int)rint(rate * pop.size());
// 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>());
// test of consistency
if (breeders.size() >= target) {
throw("Problem in eoLottery: already too many offspring");
}
// 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]);
}
}

12
eo/src/eoNegExp.h
View file

@ -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) {};

13
eo/src/eoObject.h
View file

@ -1,9 +1,12 @@
// -*- 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; -*-
-----------------------------------------------------------------------------
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
//-----------------------------------------------------------------------------
// 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

1
eo/src/eoOp.h
View file

@ -87,7 +87,6 @@ public:
virtual string className() const {return "eoOp";};
//@}
private:
/// arity is the number of operands it takes
Arity arity;

19
eo/src/eoOpSelector.h
View file

@ -1,9 +1,12 @@
// -*- 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; -*-
-----------------------------------------------------------------------------
eoOpSelector.h
Base class for operator selectors, which return 1 operator according
to some criterium
(c) GeNeura Team 1998, 1999, 2000
//-----------------------------------------------------------------------------
// 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
@ -20,6 +23,7 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
*/
//-----------------------------------------------------------------------------
#ifndef EOOPSELECTOR_H
@ -34,7 +38,7 @@
#include <eoOp.h>
//-----------------------------------------------------------------------------
/** An operator selector is an object that contains a set of EO operators, and
/** 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
*/
@ -42,6 +46,7 @@ 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
@ -55,7 +60,7 @@ public:
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;
virtual const eoOp<EOT>& getOp( ID _id ) = 0;
/** Remove an operator from the operator set
@param _id a previously assigned ID

13
eo/src/eoPop.h
View file

@ -49,16 +49,12 @@ 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
@ -72,9 +68,6 @@ public:
@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 ++ ){
@ -82,16 +75,12 @@ public:
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 ++ ){
@ -100,7 +89,7 @@ public:
push_back( tmpEOT );
}
};
*/
/** Ctor from an istream; reads the population from a stream,
each element should be in different lines
@param _is the stream

13
eo/src/eoPopOps.h
View file

@ -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
View 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

4
eo/src/eoRNG.h
View file

@ -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];
}

10
eo/src/eoRnd.h
View file

@ -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; -*-
-----------------------------------------------------------------------------
eoRnd.h
(c) GeNeura Team, 1998
//-----------------------------------------------------------------------------
// 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

8
eo/src/eoString.h
View file

@ -61,6 +61,14 @@ public:
}
};
/** Ctor from a stream
@param _s input stream
*/
eoString( istream & _s )
: eo1d<char, fitnessT>(){
_s >> *this;
};
/// copy ctor
eoString( const eoString<fitnessT>& _eoStr )
:eo1d<char, fitnessT>( static_cast<const eo1d<char, fitnessT> & > ( _eoStr ) ),

12
eo/src/eoUniform.h
View file

@ -1,10 +1,10 @@
// eoUniform.h
// -*- 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; -*-
-----------------------------------------------------------------------------
eoUniform.h
Uniform random number generator;
(c) GeNeura Team, 1998
//-----------------------------------------------------------------------------
// 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

15
eo/src/eoVector.h
View file

@ -1,9 +1,10 @@
// -*- 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; -*-
-----------------------------------------------------------------------------
eoVector.h
Turns an STL vector into an EO
(c) GeNeura Team, 1998
//-----------------------------------------------------------------------------
// 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
@ -20,8 +21,8 @@
Contact: todos@geneura.ugr.es, http://geneura.ugr.es
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef _eoVector_H
#define _eoVector_H
@ -38,7 +39,7 @@
with the same gene type as the type with which
the vector has been instantiated
*/
template <class T, class fitnessT>
template <class T, class fitnessT=float>
class eoVector: public eo1d<T, fitnessT>, public vector<T> {
public:
typedef T Type ;

31
eo/test/Makefile.am
View file

@ -17,7 +17,36 @@ LDADDS = $(top_builddir)/src/libeo.a
noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness \
t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA\
t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps\
t-eoAtomOps t-selectOne
t-eoAtomOps t-selectOne t-eoaltbreeder t-eoGeneralOps t-eoGOpSel \
t-eoVector
###############################################################################
t_eoVector_SOURCES = t-eoVector.cpp
t_eoVector_DEPENDENCIES = $(DEPS)
t_eoVector_LDFLAGS = -lm
t_eoVector_LDADD = $(LDADDS)
###############################################################################
t_eoGOpSel_SOURCES = t-eoGOpSel.cpp
t_eoGOpSel_DEPENDENCIES = $(DEPS)
t_eoGOpSel_LDFLAGS = -lm
t_eoGOpSel_LDADD = $(LDADDS)
###############################################################################
t_eoGeneralOps_SOURCES = t-eoGeneralOps.cpp
t_eoGeneralOps_DEPENDENCIES = $(DEPS)
t_eoGeneralOps_LDFLAGS = -lm
t_eoGeneralOps_LDADD = $(LDADDS)
###############################################################################
t_eoaltbreeder_SOURCES = t-eoaltbreeder.cpp
t_eoaltbreeder_DEPENDENCIES = $(DEPS)
t_eoaltbreeder_LDFLAGS = -lm
t_eoaltbreeder_LDADD = $(LDADDS)
###############################################################################

65
eo/test/Makefile.in
View file

@ -1,4 +1,4 @@
# Makefile.in generated automatically by automake 1.4 from Makefile.am
# Makefile.in generated automatically by automake 1.4a from Makefile.am
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
@ -49,9 +49,10 @@ AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_FLAG =
transform = @program_transform_name@
NORMAL_INSTALL = :
@ -72,9 +73,9 @@ LN_S = @LN_S@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
NM = @NM@
OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
USE_SYMBOL_UNDERSCORE = @USE_SYMBOL_UNDERSCORE@
VERSION = @VERSION@
DEPS = $(top_builddir)/src/libeo.a
@ -87,9 +88,37 @@ LDADDS = $(top_builddir)/src/libeo.a
###############################################################################
noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps t-eoAtomOps t-selectOne
noinst_PROGRAMS = t-eobreeder t-eoinclusion t-eoinsertion t-eo t-eofitness t-eoproblem t-eobin t-eolottery t-eo2dVector t-eogeneration t-eoEasyEA t-eoNonUniform t-eoUniform t-eoRandom t-parser t-eoESFull t-eoESOps t-eoAtomOps t-selectOne t-eoaltbreeder t-eoGeneralOps t-eoGOpSel t-eoVector
###############################################################################
t_eoVector_SOURCES = t-eoVector.cpp
t_eoVector_DEPENDENCIES = $(DEPS)
t_eoVector_LDFLAGS = -lm
t_eoVector_LDADD = $(LDADDS)
###############################################################################
t_eoGOpSel_SOURCES = t-eoGOpSel.cpp
t_eoGOpSel_DEPENDENCIES = $(DEPS)
t_eoGOpSel_LDFLAGS = -lm
t_eoGOpSel_LDADD = $(LDADDS)
###############################################################################
t_eoGeneralOps_SOURCES = t-eoGeneralOps.cpp
t_eoGeneralOps_DEPENDENCIES = $(DEPS)
t_eoGeneralOps_LDFLAGS = -lm
t_eoGeneralOps_LDADD = $(LDADDS)
###############################################################################
t_eoaltbreeder_SOURCES = t-eoaltbreeder.cpp
t_eoaltbreeder_DEPENDENCIES = $(DEPS)
t_eoaltbreeder_LDFLAGS = -lm
t_eoaltbreeder_LDADD = $(LDADDS)
###############################################################################
t_selectOne_SOURCES = t-selectOne.cpp
@ -250,6 +279,10 @@ t_eoESFull_OBJECTS = t-eoESFull.o
t_eoESOps_OBJECTS = t-eoESOps.o
t_eoAtomOps_OBJECTS = t-eoAtomOps.o
t_selectOne_OBJECTS = t-selectOne.o
t_eoaltbreeder_OBJECTS = t-eoaltbreeder.o
t_eoGeneralOps_OBJECTS = t-eoGeneralOps.o
t_eoGOpSel_OBJECTS = t-eoGOpSel.o
t_eoVector_OBJECTS = t-eoVector.o
CXXFLAGS = @CXXFLAGS@
CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
LTCXXCOMPILE = $(LIBTOOL) --mode=compile $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
@ -267,8 +300,8 @@ DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = gtar
GZIP_ENV = --best
SOURCES = $(t_eobreeder_SOURCES) $(t_eoinclusion_SOURCES) $(t_eoinsertion_SOURCES) $(t_eo_SOURCES) $(t_eofitness_SOURCES) $(t_eoproblem_SOURCES) $(t_eobin_SOURCES) $(t_eolottery_SOURCES) $(t_eo2dVector_SOURCES) $(t_eogeneration_SOURCES) $(t_eoEasyEA_SOURCES) $(t_eoNonUniform_SOURCES) $(t_eoUniform_SOURCES) $(t_eoRandom_SOURCES) $(t_parser_SOURCES) $(t_eoESFull_SOURCES) $(t_eoESOps_SOURCES) $(t_eoAtomOps_SOURCES) $(t_selectOne_SOURCES)
OBJECTS = $(t_eobreeder_OBJECTS) $(t_eoinclusion_OBJECTS) $(t_eoinsertion_OBJECTS) $(t_eo_OBJECTS) $(t_eofitness_OBJECTS) $(t_eoproblem_OBJECTS) $(t_eobin_OBJECTS) $(t_eolottery_OBJECTS) $(t_eo2dVector_OBJECTS) $(t_eogeneration_OBJECTS) $(t_eoEasyEA_OBJECTS) $(t_eoNonUniform_OBJECTS) $(t_eoUniform_OBJECTS) $(t_eoRandom_OBJECTS) $(t_parser_OBJECTS) $(t_eoESFull_OBJECTS) $(t_eoESOps_OBJECTS) $(t_eoAtomOps_OBJECTS) $(t_selectOne_OBJECTS)
SOURCES = $(t_eobreeder_SOURCES) $(t_eoinclusion_SOURCES) $(t_eoinsertion_SOURCES) $(t_eo_SOURCES) $(t_eofitness_SOURCES) $(t_eoproblem_SOURCES) $(t_eobin_SOURCES) $(t_eolottery_SOURCES) $(t_eo2dVector_SOURCES) $(t_eogeneration_SOURCES) $(t_eoEasyEA_SOURCES) $(t_eoNonUniform_SOURCES) $(t_eoUniform_SOURCES) $(t_eoRandom_SOURCES) $(t_parser_SOURCES) $(t_eoESFull_SOURCES) $(t_eoESOps_SOURCES) $(t_eoAtomOps_SOURCES) $(t_selectOne_SOURCES) $(t_eoaltbreeder_SOURCES) $(t_eoGeneralOps_SOURCES) $(t_eoGOpSel_SOURCES) $(t_eoVector_SOURCES)
OBJECTS = $(t_eobreeder_OBJECTS) $(t_eoinclusion_OBJECTS) $(t_eoinsertion_OBJECTS) $(t_eo_OBJECTS) $(t_eofitness_OBJECTS) $(t_eoproblem_OBJECTS) $(t_eobin_OBJECTS) $(t_eolottery_OBJECTS) $(t_eo2dVector_OBJECTS) $(t_eogeneration_OBJECTS) $(t_eoEasyEA_OBJECTS) $(t_eoNonUniform_OBJECTS) $(t_eoUniform_OBJECTS) $(t_eoRandom_OBJECTS) $(t_parser_OBJECTS) $(t_eoESFull_OBJECTS) $(t_eoESOps_OBJECTS) $(t_eoAtomOps_OBJECTS) $(t_selectOne_OBJECTS) $(t_eoaltbreeder_OBJECTS) $(t_eoGeneralOps_OBJECTS) $(t_eoGOpSel_OBJECTS) $(t_eoVector_OBJECTS)
all: all-redirect
.SUFFIXES:
@ -403,6 +436,22 @@ t-eoAtomOps: $(t_eoAtomOps_OBJECTS) $(t_eoAtomOps_DEPENDENCIES)
t-selectOne: $(t_selectOne_OBJECTS) $(t_selectOne_DEPENDENCIES)
@rm -f t-selectOne
$(CXXLINK) $(t_selectOne_LDFLAGS) $(t_selectOne_OBJECTS) $(t_selectOne_LDADD) $(LIBS)
t-eoaltbreeder: $(t_eoaltbreeder_OBJECTS) $(t_eoaltbreeder_DEPENDENCIES)
@rm -f t-eoaltbreeder
$(CXXLINK) $(t_eoaltbreeder_LDFLAGS) $(t_eoaltbreeder_OBJECTS) $(t_eoaltbreeder_LDADD) $(LIBS)
t-eoGeneralOps: $(t_eoGeneralOps_OBJECTS) $(t_eoGeneralOps_DEPENDENCIES)
@rm -f t-eoGeneralOps
$(CXXLINK) $(t_eoGeneralOps_LDFLAGS) $(t_eoGeneralOps_OBJECTS) $(t_eoGeneralOps_LDADD) $(LIBS)
t-eoGOpSel: $(t_eoGOpSel_OBJECTS) $(t_eoGOpSel_DEPENDENCIES)
@rm -f t-eoGOpSel
$(CXXLINK) $(t_eoGOpSel_LDFLAGS) $(t_eoGOpSel_OBJECTS) $(t_eoGOpSel_LDADD) $(LIBS)
t-eoVector: $(t_eoVector_OBJECTS) $(t_eoVector_DEPENDENCIES)
@rm -f t-eoVector
$(CXXLINK) $(t_eoVector_LDFLAGS) $(t_eoVector_OBJECTS) $(t_eoVector_LDADD) $(LIBS)
.cc.o:
$(CXXCOMPILE) -c $<
.cc.lo:
@ -449,7 +498,7 @@ distdir: $(DISTFILES)
@for file in $(DISTFILES); do \
d=$(srcdir); \
if test -d $$d/$$file; then \
cp -pr $$/$$file $(distdir)/$$file; \
cp -pr $$d/$$file $(distdir)/$$file; \
else \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
@ -478,7 +527,7 @@ uninstall: uninstall-am
all-am: Makefile $(PROGRAMS)
all-redirect: all-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
$(MAKE) $(AM_MAKEFLAGS) INSTALL_STRIP_FLAG=-s install
installdirs:

4
eo/test/binary_value.h
View file

@ -8,11 +8,11 @@ typedef eoBin<float> Chrom;
the fitnes.
@param _chrom A binary chromosome
*/
void binary_value(Chrom& _chrom)
float binary_value(const Chrom& _chrom)
{
float sum = 0;
for (unsigned i = 0; i < _chrom.size(); i++)
if (_chrom[i])
sum += pow(2, _chrom.size() - i - 1);
_chrom.fitness(sum);
return sum;
}

7
eo/test/real_value.h
View file

@ -8,7 +8,7 @@ typedef vector<double> Vec;
to -sphere (we'll see later how to minimize rather than maximize!)
@param _ind A floatingpoint vector
*/
float the_real_value(Vec& _ind)
float real_value(const eoESFullChrom<float>& _ind)
{
double sum = 0; /* compute in double format, even if return a float */
for (unsigned i = 0; i < _ind.size(); i++)
@ -16,8 +16,5 @@ float the_real_value(Vec& _ind)
return -sum;
}
typedef eoESFullChrom<float> Ind;
void real_value(Ind & _ind) {
_ind.fitness( the_real_value(_ind) );
}

41
eo/test/t-eoAtomOps.cpp
View file

@ -1,4 +1,29 @@
// Program to test several EO-ES features
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eoAtomOps.cpp
Program that tests the atomic operator classes
(c) GeNeura Team, 1999
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------//
#ifdef _MSC_VER
#pragma warning(disable:4786)
@ -19,15 +44,23 @@ using namespace std;
// Several EOs
#include <eoString.h>
// RNGs
#include <eoNegExp.h>
main(int argc, char *argv[]) {
eoString<float> aString("123456");
eoAtomCreep<char> creeper;
eoAtomMutation< eoString<float> > mutator( creeper, 0.5 );
cout << "Before aString " << aString;
mutator( aString);
cout << " after mutator " << aString;
eoNegExp<char> charNE( 2 );
eoAtomRandom<char> randomer( charNE );
eoAtomMutation< eoString<float> > mutator2 ( randomer, 0.5 );
cout << "Before aString " << aString << endl;
mutator( aString);
cout << " after mutator " << aString << endl;
mutator2( aString);
cout << " after mutator2 " << aString << endl;;
return 0; // to avoid VC++ complaints
}

107
eo/test/t-eoGOpSel.cpp Normal file
View file

@ -0,0 +1,107 @@
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eoGOpSel.cpp
Testing proportional operator selectors
(c) Maarten Keijzer and GeNeura Team, 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------//
// to avoid long name warnings
#pragma warning(disable:4786)
#include "eoBin.h" // eoBin, eoPop, eoBreeder
#include <eoPop.h>
#include <eoBitOp.h>
#include <eoProportionalGOpSel.h>
//#include <eoAltBreeder.h>
// Fitness evaluation
#include "binary_value.h"
//-----------------------------------------------------------------------------
typedef eoBin<float> Chrom;
//-----------------------------------------------------------------------------
main()
{
const unsigned POP_SIZE = 8, CHROM_SIZE = 4;
unsigned i;
eoUniform<Chrom::Type> uniform(false, true);
eoBinRandom<Chrom> random;
eoPop<Chrom> pop;
for (i = 0; i < POP_SIZE; ++i)
{
Chrom chrom(CHROM_SIZE);
random(chrom);
chrom.fitness(binary_value(chrom));
pop.push_back(chrom);
}
cout << "population:" << endl;
for (i = 0; i < pop.size(); ++i)
cout << pop[i] << " " << pop[i].fitness() << endl;
eoBinBitFlip<Chrom> bitflip;
eoBinCrossover<Chrom> xover;
//Create the proportional operator selector and add the
// two operators creatd above to it.
eoProportionalGOpSel<Chrom > propSel;
propSel.addOp(bitflip, 0.5);
propSel.addOp(xover, 0.5);
for ( i = 0; i < POP_SIZE; i ++ ) {
eoGeneralOp<Chrom>& foo = propSel.selectOp();
cout << foo.nInputs() << " "
<< foo.nOutputs() << endl;
}
// eoAltBreeder<Chrom> breeder( propSel );
// breeder(pop);
// eoSequentialOpSelector<Chrom, eoAltBreeder<Chrom>::outIt > seqSel;
// eoAltBreeder<Chrom> breeder2( seqSel );
// seqSel.addOp(bitflip, 0.25);
// seqSel.addOp(xover, 0.75);
// breeder2(pop);
// // reevaluation of fitness
// for_each(pop.begin(), pop.end(), binary_value);
// cout << "new population:" << endl;
// for (i = 0; i < pop.size(); ++i)
// cout << pop[i] << " " << pop[i].fitness() << endl;
return 0;
}
//-----------------------------------------------------------------------------

71
eo/test/t-eoGeneralOps.cpp Normal file
View file

@ -0,0 +1,71 @@
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eoGeneralOps.cpp
Program that tests the General operator interface, and the wrappers
for monary and unary operators.
(c) GeNeura Team, 1999
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------//
#ifdef _MSC_VER
#pragma warning(disable:4786)
#endif
#include <string>
#include <iostream>
#include <iterator>
using namespace std;
// Operators we are going to test
#include <eoAtomCreep.h>
#include <eoAtomBitFlip.h>
#include <eoAtomRandom.h>
#include <eoAtomMutation.h>
// Several EOs
#include <eoString.h>
// generalOp we are testing
#include <eoGeneralOp.h>
main(int argc, char *argv[]) {
eoString<float> aString("123456");
eoAtomCreep<char> creeper;
eoAtomMutation< eoString<float> > mutator( creeper, 0.5 );
eoWrappedMonOp< eoString<float> > wCreeper( mutator );
cout << "Before aString " << aString;
mutator( aString);
cout << " after mutator " << aString;
// Test now the alternative interface
eoPop< eoString<float> > vIn, vOut;
insert_iterator<eoPop<eoString<float> > > ins( vOut, vOut.begin() );
vIn.push_back( aString );
wCreeper( vIn.begin(), ins );
cout << endl << "Before " << vIn[0] << endl << " after " << vOut[0] << endl;;
return 0; // to avoid VC++ complaints
}

29
eo/test/t-eoRandom.cpp
View file

@ -1,22 +1,22 @@
// -*- 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; -*-
/*-----------------------------------------------------------------------------
* t-eoRandom
* Testing program for the eoRNG class
* (c) GeNeura Team, 1999
t-eoRandom.cpp
Test program for random generator
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
(c) GeNeura Team, 1999
This library is distributed in the hope that it will be useful,
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU 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
You should have received a copy of the GNU General Public License
along with this program; 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
@ -25,7 +25,6 @@
//-----------------------------------------------------------------------------
#include <iostream> // cout
#include <strstream> // ostrstream, istrstream
#include <eoUniform.h> // eoBin

57
eo/test/t-eoVector.cpp Normal file
View file

@ -0,0 +1,57 @@
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eoVectpr.cpp
This program tests vector-like chromosomes
(c) GeNeura Team, 1999, 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------
#include <iostream> // cout
#include <strstream> // ostrstream, istrstream
#include <eoUniform.h>
#include <eoVector.h> // eoVector
#include <eo1dWDistance.h>
//-----------------------------------------------------------------------------
typedef eoVector<float> Chrom;
//-----------------------------------------------------------------------------
main()
{
const unsigned SIZE = 4;
unsigned i, j;
eoUniform<Chrom::Type> uniform(-1,1);
Chrom chrom1(SIZE,uniform), chrom2( SIZE, uniform);
cout << "chrom1: " << chrom1 << endl <<
"chrom2: " << chrom2 << endl;
eo1dWDistance< float, float > chromDist( chrom1 );
cout << "Distance from chrom1 to chrom2 " << chromDist.distance( chrom2 ) << endl;
return 0;
}
//-----------------------------------------------------------------------------

98
eo/test/t-eoaltbreeder.cpp Normal file
View file

@ -0,0 +1,98 @@
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eoaltbreeder.cpp
Extensive esting of the eoAltBreeder class
(c) Maarten Keijzer and GeNeura Team, 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------//
// to avoid long name warnings
#pragma warning(disable:4786)
#include "eoBin.h" // eoBin, eoPop, eoBreeder
#include <eoPop.h>
#include <eoBitOp.h>
#include <eoProportionalOpSel.h>
#include <eoAltBreeder.h>
// Fitness evaluation
#include "binary_value.h"
//-----------------------------------------------------------------------------
typedef eoBin<float> Chrom;
//-----------------------------------------------------------------------------
main()
{
const unsigned POP_SIZE = 8, CHROM_SIZE = 4;
unsigned i;
eoUniform<Chrom::Type> uniform(false, true);
eoBinRandom<Chrom> random;
eoPop<Chrom> pop;
for (i = 0; i < POP_SIZE; ++i)
{
Chrom chrom(CHROM_SIZE);
random(chrom);
binary_value(chrom);
pop.push_back(chrom);
}
cout << "population:" << endl;
for (i = 0; i < pop.size(); ++i)
cout << pop[i] << " " << pop[i].fitness() << endl;
eoBinBitFlip<Chrom> bitflip;
eoBinCrossover<Chrom> xover;
eoProportionalOpSelector<Chrom, eoAltBreeder<Chrom>::outIt > propSel;
eoAltBreeder<Chrom> breeder( propSel );
propSel.addOp(bitflip, 0.25);
propSel.addOp(xover, 0.75);
breeder(pop);
eoSequentialOpSelector<Chrom, eoAltBreeder<Chrom>::outIt > seqSel;
eoAltBreeder<Chrom> breeder2( seqSel );
seqSel.addOp(bitflip, 0.25);
seqSel.addOp(xover, 0.75);
breeder2(pop);
// reevaluation of fitness
for_each(pop.begin(), pop.end(), binary_value);
cout << "new population:" << endl;
for (i = 0; i < pop.size(); ++i)
cout << pop[i] << " " << pop[i].fitness() << endl;
return 0;
}
//-----------------------------------------------------------------------------

29
eo/test/t-eobin.cpp
View file

@ -1,22 +1,21 @@
// -*- 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; -*-
//-----------------------------------------------------------------------------
// t-eobin.cpp
// This program test the the binary cromosomes and several genetic operators
// (c) GeNeura Team, 1999
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
t-eobin.cpp
This program tests the the binary cromosomes and several genetic operators
(c) GeNeura Team, 1999
This library is distributed in the hope that it will be useful,
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU 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
You should have received a copy of the GNU General Public License
along with this program; 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

77
eo/test/t-eogeneration.cpp
View file

@ -1,11 +1,38 @@
//-----------------------------------------------------------------------------
// t-eogeneration.cpp
//-----------------------------------------------------------------------------
/* -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
t-eogeneration.cpp
Testing the eoGeneration classes, and classes related to it
(c) GeNeura Team, 1999, 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; 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
*/
//-----------------------------------------------------------------------------//
// to avoid long name warnings
#ifdef _MSC_VER
#pragma warning(disable:4786)
#endif
#include <eo>
#include <eoGeneration.h>
#include <eoEvalFuncPtrCnt.h>
#include "binary_value.h"
@ -23,12 +50,14 @@ main()
eoUniform<Chrom::Type> uniform(false, true);
eoBinRandom<Chrom> random;
eoPop<Chrom> pop;
// Evaluation
eoEvalFuncPtr<Chrom> eval( binary_value );
for (i = 0; i < POP_SIZE; ++i)
{
Chrom chrom(CHROM_SIZE);
random(chrom);
binary_value(chrom);
eval(chrom);
pop.push_back(chrom);
}
@ -51,8 +80,7 @@ main()
// replacement
eoInclusion<Chrom> inclusion;
// Evaluation
eoEvalFuncPtr<Chrom> eval( binary_value );
// GA generation
eoGeneration<Chrom> generation(lottery, breeder, inclusion, eval);
@ -76,6 +104,41 @@ main()
} while (pop[0].fitness() < pow(2.0, CHROM_SIZE) - 1);
// Try again, with a "counted" evaluation function
// GA generation
// Evaluation
eoEvalFuncPtrCnt<Chrom> eval2( binary_value );
eoPop<Chrom> pop2;
for (i = 0; i < POP_SIZE; ++i)
{
Chrom chrom(CHROM_SIZE);
random(chrom);
binary_value(chrom);
eval2(chrom);
pop2.push_back(chrom);
}
eoGeneration<Chrom> generation2(lottery, breeder, inclusion, eval2);
// evolution
do {
try
{
generation2(pop2);
}
catch (exception& e)
{
cout << "exception: " << e.what() << endl;;
exit(EXIT_FAILURE);
}
cout << "pop[" << ++g << "]" << endl;
for (i = 0; i < pop2.size(); ++i)
cout << "\t" << pop2[i] << " " << pop[i].fitness() << endl;
} while (pop2[0].fitness() < pow(2.0, CHROM_SIZE) - 1);
cout << "Number of evaluations " << eval2.getNumOfEvaluations() << endl;
return 0;
}

1
eo/win/Makefile.am
View file

@ -1,3 +1,4 @@
#Some dsps are missing here
EXTRA_DIST=EO.dsw random.dsp t_eoinsertion.dsp t_ops.dsp\
atomops.dsp t_eoaged.dsp t_eornd.dsp t_opsel.dsp\
t_eobin.dsp t_eostring.dsp t_opselmason.dsp\