diff --git a/eo/configure.in b/eo/configure.in index 46910ca5e..f089acf0c 100644 --- a/eo/configure.in +++ b/eo/configure.in @@ -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) diff --git a/eo/src/Makefile.am b/eo/src/Makefile.am index 3b4a1c90e..9dc0eb505 100644 --- a/eo/src/Makefile.am +++ b/eo/src/Makefile.am @@ -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 + diff --git a/eo/src/eo1d.h b/eo/src/eo1d.h index e9c4d66f0..31ed415fe 100644 --- a/eo/src/eo1d.h +++ b/eo/src/eo1d.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::eo1d( unsigned _size, eoRnd& _rndGen, +eo1d::eo1d( unsigned _size, eoRnd& _rndGen, const string& _ID ) :EO ( _ID ) { for ( unsigned i = 0; i < _size; i ++ ) { diff --git a/eo/src/eo1dWDistance.h b/eo/src/eo1dWDistance.h new file mode 100644 index 000000000..0cd940497 --- /dev/null +++ b/eo/src/eo1dWDistance.h @@ -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 // for ostream + +// EO Includes +#include +#include + +using namespace std; + +/** eo1dWDistance: wraps around eo1ds and adds the possibility of computing distances +around them. +*/ +template +class eo1dWDistance: + public eo1d< T,fitnessT >, + public eoDistance > { +public: + + /** Can be used as default ctor; should be called from derived + classes. Fitness should be at birth + */ + eo1dWDistance( eo1d& _eo) + :eo1d (), eoDistance< eo1d >(), 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& _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& innereo1d; +}; + +//@} + + +#endif diff --git a/eo/src/eoAltBreeder.h b/eo/src/eoAltBreeder.h new file mode 100644 index 000000000..737fbdd9b --- /dev/null +++ b/eo/src/eoAltBreeder.h @@ -0,0 +1,302 @@ +//----------------------------------------------------------------------------- +// eoBreeder.h +//----------------------------------------------------------------------------- + +#ifndef eoBreeder_h +#define eoBreeder_h + +//----------------------------------------------------------------------------- + +#include // vector +#include +#include // eoUniform +#include // eoOp, eoMonOp, eoBinOp +#include // eoPop +#include // eoTransform +#include // eoOpSelector +#include +#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 eoGeneralOp: public eoOp +{ +public: + + eoGeneralOp() + :eoOp( Nary ) {}; + virtual ~eoGeneralOp () {}; + + virtual void operator()( vector _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 eoWrappedMonOp : public eoGeneralOp +{ +public : + eoWrappedMonOp(const eoMonOp& _op) : eoGeneralOp(), op(_op) {} + virtual ~eoWrappedMonOp() {} + + void operator()( vector _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& op; +}; + +template +class eoWrappedBinOp : public eoGeneralOp +{ +public : + eoWrappedBinOp(const eoBinOp& _op) : eoGeneralOp(), op(_op) {} + virtual ~eoWrappedBinOp() {} + + void operator()( vector _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& op; +}; + +template +class eoCombinedOp : public eoGeneralOp +{ +public : + + eoCombinedOp() : eoGeneralOp(), arity(0) {} + virtual ~eoCombinedOp() {} + + int nInputs(void) const { return arity; } + int nOutputs(void) const { return 1; } + + void addOp(eoGeneralOp* _op) + { + ops.push_back(_op); + arity = arity < _op->nInputs()? _op->nInputs() : arity; + } + + + void clear(void) + { + ops.resize(0); + } + + + void operator()( vector _in, OutIt _out) const + { + for (int i = 0; i < ops.size(); ++i) + { + (*ops[i])(_in, _out); + _in[0] = &*_out; + } + } + +private : + vector* > ops; + int arity; +}; + +template +class eoAltOpSelector: public eoOpSelector, public vector*> +{ +public: + + virtual ID addOp( eoOp& _op, float _arg ) + { + eoGeneralOp* op = dynamic_cast*>(&_op); + + + if (op == 0) + { + switch(_op.readArity()) + { + case unary : + oplist.push_back(auto_ptr >(new eoWrappedMonOp(static_cast&>(_op)))); + + op = oplist.back().get(); + break; + case binary : + oplist.push_back(auto_ptr >(new eoWrappedBinOp(static_cast&>(_op)))); + op = oplist.back().get(); + break; + } + } + + iterator result = find(begin(), end(), (eoGeneralOp*) 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& 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* Op() + { + return &selectOp(); + } + + + virtual eoGeneralOp& selectOp() = 0; + + + virtual string className() const { return "eoAltOpSelector"; }; + + void printOn(ostream& _os) const {} + + +protected : + + vector rates; + list > > oplist; +}; + +template +class eoProportionalOpSelector : public eoAltOpSelector +{ + public : + eoProportionalOpSelector() : eoAltOpSelector() {} + + + virtual eoGeneralOp& selectOp() + { + int what = rng.roulette_wheel(rates); + + return *operator[](what); + } +}; + +template +class eoSequentialOpSelector : public eoAltOpSelector +{ + public : + + eoSequentialOpSelector() : eoAltOpSelector() {} + + virtual eoGeneralOp& 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 combined; +}; + +template +class eoRandomIndy // living in a void right now +{ + public : + + eoRandomIndy() {} + + vector operator()(int _n, eoPop::iterator _begin, eoPop::iterator _end) + { + vector result(_n); + + for (int i = 0; i < result.size(); ++i) + { + result[i] = &*(_begin + rng.random(_end - _begin)); + } + + return result; + } +}; + +template class eoAltBreeder: public eoTransform +{ + public: + typedef eoPop::reverse_iterator outIt; + /// Default constructor. + eoAltBreeder( eoAltOpSelector& _opSel): opSel( _opSel ) {} + + /// Destructor. + virtual ~eoAltBreeder() {} + + /** + * Enlarges the population. + * @param pop The population to be transformed. + */ + void operator()(eoPop& pop) + { + int size = pop.size(); + + for (unsigned i = 0; i < size; i++) + { + eoGeneralOp& op = opSel.selectOp(); + + pop.resize(pop.size() + op.nOutputs()); + vector indies = indySelector(op.nInputs(), pop.begin(), pop.begin() + size); + + op(indies, pop.rbegin()); + + } + } + + /// The class name. + string classname() const { return "eoAltBreeder"; } + + private: + eoAltOpSelector& opSel; + eoRandomIndy indySelector; +}; + + + +#endif eoBreeder_h diff --git a/eo/src/eoAtomRandom.h b/eo/src/eoAtomRandom.h index e7faaab33..07d2eb98d 100644 --- a/eo/src/eoAtomRandom.h +++ b/eo/src/eoAtomRandom.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 - -/** Modifies using a random number generator, that is entered in the ctor. - The RNG must return positive or negative numbers, whatever. -*/ -template -class eoAtomRandom: public eoAtomMutator { -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 + +/** Modifies using a random number generator, that is entered in the ctor. + The RNG must return positive or negative numbers, whatever. +*/ +template +class eoAtomRandom: public eoAtomMutator { +public: + + /// + eoAtomRandom( eoRnd& _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& rng; + +}; + + +#endif diff --git a/eo/src/eoData.h b/eo/src/eoData.h index a90445d04..f760ea369 100644 --- a/eo/src/eoData.h +++ b/eo/src/eoData.h @@ -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::max() #else #include - #include + #include +#ifndef _WIN32 // should be the define for UN*X flavours: _POSIX?? #include +#endif #ifndef MAXFLOAT #define MAXFLOAT (float)1e127 #define MAXDOUBLE (double)1.79769313486231570e+308 diff --git a/eo/src/eoDistance.h b/eo/src/eoDistance.h new file mode 100644 index 000000000..13ca197e0 --- /dev/null +++ b/eo/src/eoDistance.h @@ -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 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 diff --git a/eo/src/eoEasyEA.h b/eo/src/eoEasyEA.h index 13f9e5367..49a905ebf 100644 --- a/eo/src/eoEasyEA.h +++ b/eo/src/eoEasyEA.h @@ -57,7 +57,7 @@ template class eoEasyEA: public eoAlgo /// Apply one generation of evolution to the population. virtual void operator()(eoPop& pop) { - while ( terminator( pop ) ){ + do { try { step(pop); @@ -68,7 +68,7 @@ template class eoEasyEA: public eoAlgo s.append( " in eoEasyEA "); throw runtime_error( s ); } - } + } while ( terminator( pop ) ); } /// Class name. diff --git a/eo/src/eoEvalFuncPtr.h b/eo/src/eoEvalFuncPtr.h index 882f4b6da..1c40eecf2 100644 --- a/eo/src/eoEvalFuncPtr.h +++ b/eo/src/eoEvalFuncPtr.h @@ -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 - -/** 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 { - - eoEvalFuncPtr( void (* _eval)( EOT& ) ) - : eoEvalFunc(), 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 + +/** 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 { + + /** 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(), 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 diff --git a/eo/src/eoEvalFuncPtrCnt.h b/eo/src/eoEvalFuncPtrCnt.h new file mode 100644 index 000000000..ffa998590 --- /dev/null +++ b/eo/src/eoEvalFuncPtrCnt.h @@ -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 + +/** 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 { + + /** 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( _eval ), numOfEvaluations( 0 ) {}; + + /// Effectively applies the evaluation function to an EO + virtual void operator() ( EOT & _eo ) const { + eoEvalFuncPtr::operator()( _eo ); + numOfEvaluations++; + }; + + /// + unsigned getNumOfEvaluations() const { return numOfEvaluations; }; + +private: + mutable unsigned numOfEvaluations; +}; + +#endif diff --git a/eo/src/eoGOpSelector.h b/eo/src/eoGOpSelector.h new file mode 100644 index 000000000..f33b6bb1a --- /dev/null +++ b/eo/src/eoGOpSelector.h @@ -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 +#include +#include // eoUniform +#include // eoOp, eoMonOp, eoBinOp +#include // eoPop +#include // eoTransform +#include // eoOpSelector +#include +#include "eoRNG.h" + +using namespace std; + +/** Base class for alternative selectors, which use the generalized operator + interface */ + +template +class eoGOpSelector: public eoOpSelector, public vector*> +{ +public: + + /// Dtor + virtual ~eoGOpSelector() { + for ( list< eoGeneralOp* >::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& _op, float _arg ) { + eoGeneralOp* op = dynamic_cast*>(&_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(static_cast&>(_op)); + break; + case binary : + op = new eoWrappedBinOp(static_cast&>(_op)); + break; + } + ownOpList.push_back( op ); + } + + iterator result = find(begin(), end(), (eoGeneralOp*) 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& 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* Op() + { + return &selectOp(); + } + + /// + virtual eoGeneralOp& 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 rates; + list< eoGeneralOp* > ownOpList; +}; + +#endif eoGOpSelector_h diff --git a/eo/src/eoGeneralOp.h b/eo/src/eoGeneralOp.h new file mode 100644 index 000000000..e24b6541e --- /dev/null +++ b/eo/src/eoGeneralOp.h @@ -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 +#include +#include // eoUniform +#include // eoOp, eoMonOp, eoBinOp +#include // eoPop +#include // eoTransform +#include // eoOpSelector +#include +#include "eoRNG.h" + +using namespace std; + +/** + * eGeneralOp: General genetic operator; for objects used to transform sets + of EOs +*/ +template +class eoGeneralOp: public eoOp +{ +public: + + /// Ctor that honors its superclass + eoGeneralOp(): eoOp( 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::iterator _in, + insert_iterator< eoPop > _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 eoWrappedMonOp : public eoGeneralOp +{ +public : + /// + eoWrappedMonOp(const eoMonOp& _op) : eoGeneralOp( 1, 1), op(_op) {}; + + /// + virtual ~eoWrappedMonOp() {} + + /// Instantiates the abstract method + void operator()( eoPop::iterator _in, + insert_iterator< eoPop< EOT> > _out ) const { + EOT result = *_in; + op( result ); + *_out = result; + } + + /// + virtual string className() const {return "eoWrappedMonOp";}; + + +private : + const eoMonOp& op; +}; + + +/// Wraps binary operators +template +class eoWrappedBinOp : public eoGeneralOp +{ +public : + /// + eoWrappedBinOp(const eoBinOp& _op) : eoGeneralOp(2, 2), op(_op) {} + + /// + virtual ~eoWrappedBinOp() {} + + /// Instantiates the abstract method. EOT should have copy ctor. + void operator()(eoPop::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& op; +}; + +/// Combines several ops +template +class eoCombinedOp : public eoGeneralOp +{ +public : + + /// + eoCombinedOp() : eoGeneralOp() {} + + /// + virtual ~eoCombinedOp() {} + + /// Adds a new operator to the combined Op + void addOp(eoGeneralOp* _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::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 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* > ops; +}; + +#endif eoGeneral_h diff --git a/eo/src/eoGeneration.h b/eo/src/eoGeneration.h index 5db81e726..9da4ae67a 100644 --- a/eo/src/eoGeneration.h +++ b/eo/src/eoGeneration.h @@ -71,9 +71,9 @@ template class eoGeneration: public eoAlgo string className() const { return "eoGeneration"; } private: - eoBinPopOp& select; + eoBinPopOp& select; eoMonPopOp& transform; - eoBinPopOp& replace; + eoBinPopOp& replace; eoEvalFunc& evaluator; }; diff --git a/eo/src/eoLottery.h b/eo/src/eoLottery.h index 60e8bc7a4..252b16459 100644 --- a/eo/src/eoLottery.h +++ b/eo/src/eoLottery.h @@ -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 // 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 eoLottery: public eoBinPopOp +template class eoLottery: public eoBinPopOp { public: /// (Default) Constructor. eoLottery(const float& _rate = 1.0): rate(_rate) {} - /// - void operator()( eoPop& pop, eoPop& 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& pop, eoPop& breeders) { // scores of chromosomes vector 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(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(), sum)); - partial_sum(score.begin(), score.end(), score.begin()); - - // generates random numbers - vector random(rint(rate * pop.size())); - generate(random.begin(), random.end(), eoUniform(0,1)); - sort(random.begin(), random.end(), less()); - // 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 >(breeders), - random.size() - breeders.size(), pop.back()); - } + while (breeders.size() < target) { + unsigned indloc = rng.roulette_wheel(score, total); + breeders.push_back(pop[indloc]); + } } private: diff --git a/eo/src/eoNegExp.h b/eo/src/eoNegExp.h index beb63479f..63c9203ed 100644 --- a/eo/src/eoNegExp.h +++ b/eo/src/eoNegExp.h @@ -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 public: /** * Default constructor. - * @param _mean Dsitribution mean + * @param _mean Distribution mean */ eoNegExp(T _mean): eoRnd(), mean(_mean) {}; diff --git a/eo/src/eoObject.h b/eo/src/eoObject.h index 8bf2e1372..e1b2d617c 100644 --- a/eo/src/eoObject.h +++ b/eo/src/eoObject.h @@ -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 // For limits definition -#include // istream, ostream -#include // 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 // For limits definition +#include // istream, ostream +#include // 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 diff --git a/eo/src/eoOp.h b/eo/src/eoOp.h index e046824a6..609cf8c34 100644 --- a/eo/src/eoOp.h +++ b/eo/src/eoOp.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 diff --git a/eo/src/eoOpSelector.h b/eo/src/eoOpSelector.h index 8d6286259..3000c9b6f 100644 --- a/eo/src/eoOpSelector.h +++ b/eo/src/eoOpSelector.h @@ -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 // runtime_error - -#include -#include -#include - -//----------------------------------------------------------------------------- -/** 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 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& _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& 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* 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 // runtime_error + +#include +#include +#include + +//----------------------------------------------------------------------------- +/** 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 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& _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& 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* 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 diff --git a/eo/src/eoPop.h b/eo/src/eoPop.h index 363ee0059..e6cf0aef9 100644 --- a/eo/src/eoPop.h +++ b/eo/src/eoPop.h @@ -49,87 +49,76 @@ to the population. template class eoPop: public vector, 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() {}; - - - /** 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 & _geneRnd ) - :vector() { - 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 & _sizeRnd, eoRnd & _geneRnd ) - :vector() { - 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() { - 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() {}; + + + /** 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 & _geneRnd ) + :vector() { + 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 & _sizeRnd, eoRnd & _geneRnd ) + :vector() { + 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() { + 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( _os, "\n") ); }; - + /** Inherited from eoObject. Returns the class name. @see eoObject */ virtual string className() const {return "eoPop";}; - //@} - -protected: - + //@} + + protected: + }; #endif diff --git a/eo/src/eoPopOps.h b/eo/src/eoPopOps.h index 6f2eb3b87..7324f6ee7 100644 --- a/eo/src/eoPopOps.h +++ b/eo/src/eoPopOps.h @@ -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 eoSelectOne: public eoObject{ diff --git a/eo/src/eoProportionalGOpSel.h b/eo/src/eoProportionalGOpSel.h new file mode 100644 index 000000000..bc7d1c083 --- /dev/null +++ b/eo/src/eoProportionalGOpSel.h @@ -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 // eoOpSelector + +template +class eoProportionalGOpSel : public eoGOpSelector +{ +public : + eoProportionalGOpSel() : eoGOpSelector() {} + + /** Returns the operator proportionally selected */ + virtual eoGeneralOp& selectOp() + { + unsigned what = rng.roulette_wheel(rates); + return *operator[](what); + } + + /// + virtual string className() const { return "eoGOpSelector"; }; + +}; + +#endif eoProportionalGOpSel_h diff --git a/eo/src/eoRNG.h b/eo/src/eoRNG.h index 6356ef935..ab107e690 100644 --- a/eo/src/eoRNG.h +++ b/eo/src/eoRNG.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]; } diff --git a/eo/src/eoRnd.h b/eo/src/eoRnd.h index 76e40324e..93b61c2ff 100644 --- a/eo/src/eoRnd.h +++ b/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 - -//----------------------------------------------------------------------------- -// Class eoRnd -//----------------------------------------------------------------------------- - -#include // srand -#include // time -#include // runtime_error - -//----------------------------------------------------------------------------- - -#include - -//----------------------------------------------------------------------------- -/** - * 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 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 bool eoRnd::started = false; - - -//-------------------------------------------------------------------------- - -/** - * Read object. - * @param is A istream. - * @throw runtime_exception If a valid object can't be read. - */ -template -void eoRnd::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 + +//----------------------------------------------------------------------------- +// Class eoRnd +//----------------------------------------------------------------------------- + +#include // srand +#include // time +#include // runtime_error + +//----------------------------------------------------------------------------- + +#include + +//----------------------------------------------------------------------------- +/** + * 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 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 bool eoRnd::started = false; + + +//-------------------------------------------------------------------------- + +/** + * Read object. + * @param is A istream. + * @throw runtime_exception If a valid object can't be read. + */ +template +void eoRnd::readFrom(istream& _is) { + if (!_is) + throw runtime_error("Problems reading from stream in eoRnd"); + long seed; + _is >> seed; + srand(seed); +} + +#endif diff --git a/eo/src/eoString.h b/eo/src/eoString.h index 548d4c354..ff515c70d 100644 --- a/eo/src/eoString.h +++ b/eo/src/eoString.h @@ -60,6 +60,14 @@ public: *this += _rnd(); } }; + + /** Ctor from a stream + @param _s input stream + */ + eoString( istream & _s ) + : eo1d(){ + _s >> *this; + }; /// copy ctor eoString( const eoString& _eoStr ) diff --git a/eo/src/eoUniform.h b/eo/src/eoUniform.h index b825d9ab1..c824673f8 100644 --- a/eo/src/eoUniform.h +++ b/eo/src/eoUniform.h @@ -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 -#include - -//----------------------------------------------------------------------------- -// Class eoUniform -//----------------------------------------------------------------------------- - -/// Generates uniform random number over the interval [min, max) -template -class eoUniform: public eoRnd -{ - 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(), min(_min), diff(_max - _min) {} - - /** - * copy constructor. - * @param _rnd the other rnd - */ - eoUniform( const eoUniform& _rnd) - : eoRnd( _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 +#include + +//----------------------------------------------------------------------------- +// Class eoUniform +//----------------------------------------------------------------------------- + +/// Generates uniform random number over the interval [min, max) +template +class eoUniform: public eoRnd +{ + 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(), min(_min), diff(_max - _min) {} + + /** + * copy constructor. + * @param _rnd the other rnd + */ + eoUniform( const eoUniform& _rnd) + : eoRnd( _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 diff --git a/eo/src/eoVector.h b/eo/src/eoVector.h index 4a0a7e6f7..d9a24dc8a 100644 --- a/eo/src/eoVector.h +++ b/eo/src/eoVector.h @@ -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 // For vector -#include -#include - -#include -#include - -/** 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 eoVector: public eo1d, public vector { -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(), vector( _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& _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( _eo ), vector( _eo ){ }; - - /// Assignment operator - const eoVector& operator =( const eoVector & _eo ) { - if ( this != &_eo ){ - eo1d::operator=( _eo ); - vector::operator=( _eo ); - } - return *this; - } - - /// dtor - virtual ~eoVector() {}; - - //@} - - /** methods that implement the eo1d protocol - @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 protocol - @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 protocol - @exception out_of_range if _i is larger than EOīs size - */ - virtual void insertGene( unsigned _i, T _val ) { - if (_i <= size() ) { - vector::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::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 protocol - 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 -eoVector::eoVector( unsigned _size, eoRnd& _rnd ) - : eo1d(), vector( _size ){ - for ( iterator i = begin(); i != end(); i ++ ) { - *i = _rnd(); - } -}; - -//____________________________________________________________________________________ -template -eoVector::eoVector( istream& _is) - : eo1d(), vector( ){ - 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 // For vector +#include +#include + +#include +#include + +/** 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 eoVector: public eo1d, public vector { +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(), vector( _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& _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( _eo ), vector( _eo ){ }; + + /// Assignment operator + const eoVector& operator =( const eoVector & _eo ) { + if ( this != &_eo ){ + eo1d::operator=( _eo ); + vector::operator=( _eo ); + } + return *this; + } + + /// dtor + virtual ~eoVector() {}; + + //@} + + /** methods that implement the eo1d protocol + @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 protocol + @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 protocol + @exception out_of_range if _i is larger than EOīs size + */ + virtual void insertGene( unsigned _i, T _val ) { + if (_i <= size() ) { + vector::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::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 protocol + 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 +eoVector::eoVector( unsigned _size, eoRnd& _rnd ) + : eo1d(), vector( _size ){ + for ( iterator i = begin(); i != end(); i ++ ) { + *i = _rnd(); + } +}; + +//____________________________________________________________________________________ +template +eoVector::eoVector( istream& _is) + : eo1d(), vector( ){ + while (_is ) { + T tmp; + _is >> tmp; + push_back( tmp ); + } + +}; + +#endif diff --git a/eo/test/Makefile.am b/eo/test/Makefile.am index d922e2fa6..4f27af5ae 100644 --- a/eo/test/Makefile.am +++ b/eo/test/Makefile.am @@ -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) ############################################################################### diff --git a/eo/test/Makefile.in b/eo/test/Makefile.in index a10890d4a..577d6fedb 100644 --- a/eo/test/Makefile.in +++ b/eo/test/Makefile.in @@ -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: diff --git a/eo/test/binary_value.h b/eo/test/binary_value.h index f3e05e771..a450a1176 100644 --- a/eo/test/binary_value.h +++ b/eo/test/binary_value.h @@ -1,18 +1,18 @@ -#include - -//----------------------------------------------------------------------------- - -typedef eoBin Chrom; - -/** Just a simple function that takes binary value of a chromosome and sets - the fitnes. - @param _chrom A binary chromosome -*/ -void binary_value(Chrom& _chrom) -{ - float sum = 0; - for (unsigned i = 0; i < _chrom.size(); i++) - if (_chrom[i]) +#include + +//----------------------------------------------------------------------------- + +typedef eoBin Chrom; + +/** Just a simple function that takes binary value of a chromosome and sets + the fitnes. + @param _chrom A binary chromosome +*/ +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; +} diff --git a/eo/test/real_value.h b/eo/test/real_value.h index 1822f2902..68415519e 100644 --- a/eo/test/real_value.h +++ b/eo/test/real_value.h @@ -1,23 +1,20 @@ -#include - -//----------------------------------------------------------------------------- - -typedef vector Vec; - -/** Just a simple function that takes an eoVector and sets the fitnes - to -sphere (we'll see later how to minimize rather than maximize!) - @param _ind A floatingpoint vector -*/ -float the_real_value(Vec& _ind) -{ - double sum = 0; /* compute in double format, even if return a float */ - for (unsigned i = 0; i < _ind.size(); i++) - sum += _ind[i] * _ind[i]; - return -sum; -} - -typedef eoESFullChrom Ind; - -void real_value(Ind & _ind) { - _ind.fitness( the_real_value(_ind) ); -} +#include + +//----------------------------------------------------------------------------- + +typedef vector Vec; + +/** Just a simple function that takes an eoVector and sets the fitnes + to -sphere (we'll see later how to minimize rather than maximize!) + @param _ind A floatingpoint vector +*/ +float real_value(const eoESFullChrom& _ind) +{ + double sum = 0; /* compute in double format, even if return a float */ + for (unsigned i = 0; i < _ind.size(); i++) + sum += _ind[i] * _ind[i]; + return -sum; +} + + + diff --git a/eo/test/t-eoAtomOps.cpp b/eo/test/t-eoAtomOps.cpp index 03bb367d1..715fffc5e 100644 --- a/eo/test/t-eoAtomOps.cpp +++ b/eo/test/t-eoAtomOps.cpp @@ -1,33 +1,66 @@ -// Program to test several EO-ES features - -#ifdef _MSC_VER -#pragma warning(disable:4786) -#endif - -#include -#include -#include - -using namespace std; - -// Operators we are going to test -#include -#include -#include -#include - -// Several EOs -#include - -main(int argc, char *argv[]) { - eoString aString("123456"); - eoAtomCreep creeper; - eoAtomMutation< eoString > mutator( creeper, 0.5 ); - - cout << "Before aString " << aString; - mutator( aString); - cout << " after mutator " << aString; - - return 0; // to avoid VC++ complaints -} - +/* -*- 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) +#endif + +#include +#include +#include + +using namespace std; + +// Operators we are going to test +#include +#include +#include +#include + +// Several EOs +#include + +// RNGs +#include + +main(int argc, char *argv[]) { + eoString aString("123456"); + eoAtomCreep creeper; + eoAtomMutation< eoString > mutator( creeper, 0.5 ); + + eoNegExp charNE( 2 ); + eoAtomRandom randomer( charNE ); + eoAtomMutation< eoString > 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 +} + diff --git a/eo/test/t-eoGOpSel.cpp b/eo/test/t-eoGOpSel.cpp new file mode 100644 index 000000000..3f7e41110 --- /dev/null +++ b/eo/test/t-eoGOpSel.cpp @@ -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 +#include +#include +//#include + + +// Fitness evaluation +#include "binary_value.h" + +//----------------------------------------------------------------------------- + +typedef eoBin Chrom; + +//----------------------------------------------------------------------------- + +main() +{ + const unsigned POP_SIZE = 8, CHROM_SIZE = 4; + unsigned i; + + eoUniform uniform(false, true); + eoBinRandom random; + eoPop 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 bitflip; + eoBinCrossover xover; + + //Create the proportional operator selector and add the + // two operators creatd above to it. + + eoProportionalGOpSel propSel; + propSel.addOp(bitflip, 0.5); + propSel.addOp(xover, 0.5); + for ( i = 0; i < POP_SIZE; i ++ ) { + eoGeneralOp& foo = propSel.selectOp(); + cout << foo.nInputs() << " " + << foo.nOutputs() << endl; + } + + // eoAltBreeder breeder( propSel ); + + + +// breeder(pop); + +// eoSequentialOpSelector::outIt > seqSel; + +// eoAltBreeder 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; +} + +//----------------------------------------------------------------------------- diff --git a/eo/test/t-eoGeneralOps.cpp b/eo/test/t-eoGeneralOps.cpp new file mode 100644 index 000000000..a14612125 --- /dev/null +++ b/eo/test/t-eoGeneralOps.cpp @@ -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 +#include +#include + +using namespace std; + +// Operators we are going to test +#include +#include +#include +#include + +// Several EOs +#include + +// generalOp we are testing +#include + +main(int argc, char *argv[]) { + eoString aString("123456"); + eoAtomCreep creeper; + eoAtomMutation< eoString > mutator( creeper, 0.5 ); + + eoWrappedMonOp< eoString > wCreeper( mutator ); + cout << "Before aString " << aString; + mutator( aString); + cout << " after mutator " << aString; + + // Test now the alternative interface + eoPop< eoString > vIn, vOut; + insert_iterator > > 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 +} + diff --git a/eo/test/t-eoRandom.cpp b/eo/test/t-eoRandom.cpp index c0be81b10..fefcc6c65 100644 --- a/eo/test/t-eoRandom.cpp +++ b/eo/test/t-eoRandom.cpp @@ -1,31 +1,30 @@ -// -*- 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 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 library is distributed in the hope that it will be useful, + 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 */ //----------------------------------------------------------------------------- - #include // cout #include // ostrstream, istrstream #include // eoBin diff --git a/eo/test/t-eoVector.cpp b/eo/test/t-eoVector.cpp new file mode 100644 index 000000000..d0a19f797 --- /dev/null +++ b/eo/test/t-eoVector.cpp @@ -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 // cout +#include // ostrstream, istrstream + +#include +#include // eoVector +#include + +//----------------------------------------------------------------------------- + +typedef eoVector Chrom; + +//----------------------------------------------------------------------------- + +main() +{ + const unsigned SIZE = 4; + unsigned i, j; + eoUniform 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; +} + +//----------------------------------------------------------------------------- diff --git a/eo/test/t-eoaltbreeder.cpp b/eo/test/t-eoaltbreeder.cpp new file mode 100644 index 000000000..1c090cfd3 --- /dev/null +++ b/eo/test/t-eoaltbreeder.cpp @@ -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 +#include +#include +#include + + +// Fitness evaluation +#include "binary_value.h" + +//----------------------------------------------------------------------------- + +typedef eoBin Chrom; + +//----------------------------------------------------------------------------- + +main() +{ + const unsigned POP_SIZE = 8, CHROM_SIZE = 4; + unsigned i; + + eoUniform uniform(false, true); + eoBinRandom random; + eoPop 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 bitflip; + eoBinCrossover xover; + + eoProportionalOpSelector::outIt > propSel; + + eoAltBreeder breeder( propSel ); + + propSel.addOp(bitflip, 0.25); + propSel.addOp(xover, 0.75); + + breeder(pop); + + eoSequentialOpSelector::outIt > seqSel; + + eoAltBreeder 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; +} + +//----------------------------------------------------------------------------- diff --git a/eo/test/t-eobin.cpp b/eo/test/t-eobin.cpp index 9ad0eed30..55043ff06 100644 --- a/eo/test/t-eobin.cpp +++ b/eo/test/t-eobin.cpp @@ -1,24 +1,23 @@ -// -*- 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 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 library is distributed in the hope that it will be useful, + 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 */ diff --git a/eo/test/t-eogeneration.cpp b/eo/test/t-eogeneration.cpp index 1bf8db25b..ab5843720 100644 --- a/eo/test/t-eogeneration.cpp +++ b/eo/test/t-eogeneration.cpp @@ -1,82 +1,145 @@ -//----------------------------------------------------------------------------- -// t-eogeneration.cpp -//----------------------------------------------------------------------------- - -// to avoid long name warnings -#pragma warning(disable:4786) - -#include - -#include "binary_value.h" - -//----------------------------------------------------------------------------- - -typedef eoBin Chrom; - -//----------------------------------------------------------------------------- - -main() -{ - const unsigned POP_SIZE = 8, CHROM_SIZE = 16; - unsigned i; - - eoUniform uniform(false, true); - eoBinRandom random; - eoPop 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 << "\t" << pop[i] << " " << pop[i].fitness() << endl; - - - // selection - eoLottery lottery; - - // breeder - eoBinBitFlip bitflip; - eoBinCrossover xover; - eoProportionalOpSel propSel; - eoBreeder breeder( propSel ); - propSel.addOp(bitflip, 0.25); - propSel.addOp(xover, 0.75); - - // replacement - eoInclusion inclusion; - - // Evaluation - eoEvalFuncPtr eval( binary_value ); - - // GA generation - eoGeneration generation(lottery, breeder, inclusion, eval); - - // evolution - unsigned g = 0; - do { - try - { - generation(pop); - } - catch (exception& e) - { - cout << "exception: " << e.what() << endl;; - exit(EXIT_FAILURE); - } - - cout << "pop[" << ++g << "]" << endl; - for (i = 0; i < pop.size(); ++i) - cout << "\t" << pop[i] << " " << pop[i].fitness() << endl; - - } while (pop[0].fitness() < pow(2.0, CHROM_SIZE) - 1); - - return 0; -} - -//----------------------------------------------------------------------------- +/* -*- 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 +#include + +#include "binary_value.h" + +//----------------------------------------------------------------------------- + +typedef eoBin Chrom; + +//----------------------------------------------------------------------------- + +main() +{ + const unsigned POP_SIZE = 8, CHROM_SIZE = 16; + unsigned i; + + eoUniform uniform(false, true); + eoBinRandom random; + eoPop pop; + // Evaluation + eoEvalFuncPtr eval( binary_value ); + + for (i = 0; i < POP_SIZE; ++i) + { + Chrom chrom(CHROM_SIZE); + random(chrom); + eval(chrom); + pop.push_back(chrom); + } + + cout << "population:" << endl; + for (i = 0; i < pop.size(); ++i) + cout << "\t" << pop[i] << " " << pop[i].fitness() << endl; + + + // selection + eoLottery lottery; + + // breeder + eoBinBitFlip bitflip; + eoBinCrossover xover; + eoProportionalOpSel propSel; + eoBreeder breeder( propSel ); + propSel.addOp(bitflip, 0.25); + propSel.addOp(xover, 0.75); + + // replacement + eoInclusion inclusion; + + + + // GA generation + eoGeneration generation(lottery, breeder, inclusion, eval); + + // evolution + unsigned g = 0; + do { + try + { + generation(pop); + } + catch (exception& e) + { + cout << "exception: " << e.what() << endl;; + exit(EXIT_FAILURE); + } + + cout << "pop[" << ++g << "]" << endl; + for (i = 0; i < pop.size(); ++i) + cout << "\t" << pop[i] << " " << pop[i].fitness() << endl; + + } while (pop[0].fitness() < pow(2.0, CHROM_SIZE) - 1); + + // Try again, with a "counted" evaluation function + // GA generation + // Evaluation + eoEvalFuncPtrCnt eval2( binary_value ); + eoPop pop2; + + for (i = 0; i < POP_SIZE; ++i) + { + Chrom chrom(CHROM_SIZE); + random(chrom); + binary_value(chrom); + eval2(chrom); + pop2.push_back(chrom); + } + eoGeneration 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; +} + +//----------------------------------------------------------------------------- diff --git a/eo/win/Makefile.am b/eo/win/Makefile.am index 81189d33b..c68285de4 100644 --- a/eo/win/Makefile.am +++ b/eo/win/Makefile.am @@ -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\