271 lines
8.5 KiB
C++
271 lines
8.5 KiB
C++
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// eoESInd.h
|
||
// (c) GeNeura Team, 1998 - EEAAX 1999
|
||
/*
|
||
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
|
||
Marc.Schoenauer@polytechnique.fr
|
||
*/
|
||
//-----------------------------------------------------------------------------
|
||
|
||
#ifndef _EOESFULLCHROM_H
|
||
#define _EOESFULLCHROM_H
|
||
|
||
// STL libraries
|
||
#include <vector> // For vector<>
|
||
#include <stdexcept>
|
||
#include <strstream>
|
||
#include <iostream> // for ostream
|
||
|
||
// EO includes
|
||
#include <eoVector.h>
|
||
#include <eoRNG.h>
|
||
/**@name Chromosomes for evolution strategies
|
||
Each chromosome in an evolution strategies is composed of a vector of floating point
|
||
values plus a vector of sigmas, that are added to them during mutation and a vector of correlations
|
||
*/
|
||
//@{
|
||
|
||
|
||
/**@name individuals for evolution strategies -MS- 22/10/99
|
||
Each individual in an evolution strategy is composed of
|
||
a vector of floating point values
|
||
a vector of std deviations
|
||
a vector of rotation angles (for correlated mutations)
|
||
|
||
THese individuals CANNOT BE IMPLEMENTED as vectors of anything
|
||
at least in the case of correlated mutations
|
||
*/
|
||
//@{
|
||
|
||
template <typename fitT = float >
|
||
class eoESFullChrom : public eoVector<double, fitT> {
|
||
public:
|
||
/// constructor
|
||
eoESFullChrom( unsigned _num_genes = 1,
|
||
unsigned _num_sigma = 1, unsigned _num_correl = 0,
|
||
bool _verbose = false,
|
||
double _ObjMin = 0, double _ObjMax = 1,
|
||
double _StdDevInit = 0.3 ):
|
||
eoVector<double, fitT>(_num_genes),
|
||
// ObjVar( _num_genes ), now an eoVector<double>
|
||
StdDev( _num_sigma ),
|
||
CorCff( _num_correl ),
|
||
verbose( _verbose ),
|
||
ObjMin( _ObjMin ),
|
||
ObjMax(_ObjMax ),
|
||
StdDevInit( _StdDevInit ) {}
|
||
|
||
/// copy constructor
|
||
eoESFullChrom( const eoESFullChrom& _eo ):
|
||
eoVector<double, fitT> ( _eo ), // ObjVar ( _eo.ObjVar ),
|
||
StdDev ( _eo.StdDev ), CorCff( _eo.CorCff ), verbose( _eo.verbose ),
|
||
ObjMin( _eo.ObjMin ), ObjMax(_eo.ObjMax ), StdDevInit( _eo.StdDevInit ) {}
|
||
|
||
|
||
/* another constructor, for compatibility reasons */
|
||
eoESFullChrom(istream& _s) {cout << "Not Yet implemented\n";exit(1);};
|
||
|
||
/* And now the useful constructor: from a parser (should be in the
|
||
factory, if such a thing exists one day for eoESFullChrom
|
||
*/
|
||
eoESFullChrom(Parser & parser) : StdDev(0), CorCff(0) {
|
||
parser.AddTitle("Description of ES individuals");
|
||
int num_genes, num_sigma;
|
||
bool correlated_mutations;
|
||
try {
|
||
num_genes = parser.getInt("-Io", "--NbObjVar", "2",
|
||
"Number of Object Variables" );
|
||
num_sigma = parser.getInt("-Is", "--NbSigma", "1",
|
||
"Number of Standard Deviations" );
|
||
correlated_mutations = parser.getBool("-Ic", "--Correlated",
|
||
"Correlated mutation?" );
|
||
ObjMin = parser.getFloat("-Im", "--min", "0",
|
||
"Minimum value for object variables" );
|
||
ObjMax = parser.getFloat("-IM", "--max", "1",
|
||
"Maximum value for object variables" );
|
||
StdDevInit = parser.getFloat("-II", "--SigmaInit", "0.3",
|
||
"Initial value for std. dev. (scaled by range)" );
|
||
verbose = parser.getBool("-Iv", "--verbose",
|
||
"Verbose listing of ES individuals (mutation parameters");
|
||
}
|
||
catch (exception & e)
|
||
{
|
||
cout << e.what() << endl;
|
||
parser.printHelp();
|
||
exit(1);
|
||
}
|
||
|
||
// consistency tests
|
||
if (! num_sigma) { // no std dev??? EXCEPTION
|
||
throw invalid_argument( "No standard deviation: choose another representation please" );
|
||
}
|
||
if (num_sigma > num_genes) {
|
||
cout << "WARNING, Number of Standard Deviations > Number of Object Variables\nAdjusted!\n";
|
||
num_sigma = num_genes;
|
||
// modify the Param value - so .status is OK
|
||
ostrstream sloc;
|
||
sloc << num_genes;
|
||
parser.setParamValue("--NbSigma", sloc.str());
|
||
}
|
||
// adjust the sizes!!!
|
||
resize(num_genes);
|
||
if (num_sigma)
|
||
StdDev.resize(num_sigma);
|
||
if (correlated_mutations) {
|
||
if (num_sigma < num_genes) {
|
||
cout << "WARNING less Std Dev. than number of variables + Correlated mutations\n";
|
||
cout << "Though possible, this is a strange setting" << endl;
|
||
}
|
||
// nb of rotation angles: N*(N-1)/2 (in general!)
|
||
CorCff.resize ( (2*num_genes - num_sigma)*(num_sigma - 1) / 2 );
|
||
}
|
||
};
|
||
|
||
|
||
/// Operator =
|
||
const eoESFullChrom& operator = ( const eoESFullChrom& _eo ) {
|
||
if ( this != &_eo ) {
|
||
// Change EO part
|
||
eoVector<double, fitT>::operator = (_eo);
|
||
|
||
// Change this part
|
||
// ObjVar = _eo.ObjVar;
|
||
StdDev = _eo.StdDev;
|
||
CorCff = _eo.CorCff;
|
||
verbose = _eo.verbose;
|
||
ObjMin = _eo.ObjMin;
|
||
ObjMax = _eo.ObjMax;
|
||
StdDevInit = _eo.StdDevInit;
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
/// destructor
|
||
virtual ~eoESFullChrom() {}
|
||
|
||
///
|
||
double getStdDev( unsigned _i ) const {
|
||
if ( _i >= length() )
|
||
throw out_of_range( "out_of_range when reading StdDev");
|
||
return StdDev[ _i ];
|
||
}
|
||
|
||
///
|
||
void setStdDev( unsigned _i, double _val ) {
|
||
if ( _i < length() ) {
|
||
StdDev[_i] = _val;
|
||
} else
|
||
throw out_of_range( "out_of_range when writing StdDev");
|
||
}
|
||
|
||
///
|
||
double getCorCff( unsigned _i ) const {
|
||
if ( _i >= length() )
|
||
throw out_of_range( "out_of_range when reading CorCff");
|
||
return CorCff[ _i ];
|
||
}
|
||
|
||
///
|
||
void setCorCff( unsigned _i, double _val ) {
|
||
if ( _i < length() ) {
|
||
CorCff[_i] = _val;
|
||
} else
|
||
throw out_of_range( "out_of_range when writing CorCff");
|
||
}
|
||
|
||
///
|
||
void insertGene( unsigned _i, double _val ) {
|
||
throw FixedLengthChromosome();
|
||
};
|
||
|
||
///
|
||
void deleteGene( unsigned _i ) {
|
||
throw FixedLengthChromosome();
|
||
};
|
||
|
||
///
|
||
unsigned length() const { return size();}/* formerly ObjVar.size() */
|
||
unsigned StdDevLength() const { return StdDev.size();}
|
||
unsigned CorCffLength() const { return CorCff.size();}
|
||
|
||
|
||
/** Print itself: inherited from eoObject implementation.
|
||
Instance from base classes are processed in
|
||
base classes, so you don<6F>t have to worry about, for instance, fitness.
|
||
@param _s the ostream in which things are written*/
|
||
virtual void printOn( ostream& _s ) const{
|
||
copy( begin(), end(), ostream_iterator<double>( _s, " ") );
|
||
// The formatting instructinos shoudl be left to the caller
|
||
// _s << "\n";
|
||
if (verbose) {
|
||
_s << "\n\tStd Dev. " ;
|
||
copy( StdDev.begin(), StdDev.end(), ostream_iterator<double>( _s, " ") );
|
||
if (CorCff.size()) {
|
||
_s << "\n\t";
|
||
copy( CorCff.begin(), CorCff.end(), ostream_iterator<double>( _s, " ") );
|
||
}
|
||
}
|
||
};
|
||
|
||
/** This exception should be thrown when trying to insert or delete a gene
|
||
in a fixed length chromosome
|
||
*/
|
||
class FixedLengthChromosome : public exception {
|
||
|
||
public:
|
||
/**
|
||
* Constructor
|
||
*/
|
||
FixedLengthChromosome()
|
||
: exception() { };
|
||
|
||
~FixedLengthChromosome() {};
|
||
};
|
||
|
||
// accessors
|
||
double getObjMin() const {return ObjMin;}
|
||
double getObjMax() const {return ObjMax;}
|
||
double getStdDevInit () const {return StdDevInit;}
|
||
|
||
/** Inherited from eoObject
|
||
@see eoObject
|
||
*/
|
||
virtual string className() const {return "eoESFullChrom";};
|
||
|
||
private:
|
||
// vector<double> ObjVar; /* object variable vector */
|
||
// or shoudl the class be subclass of EOVector<double> ???
|
||
|
||
vector<double> StdDev; /* standard deviation vector */
|
||
vector<double> CorCff; /* correlation coefficient vector */
|
||
|
||
bool verbose; /* Print std deviations or not */
|
||
|
||
/** the range is used for mutation AND random initialization,
|
||
* while the StdDevInit is used only for random initialization
|
||
* this in a little inconsistent!
|
||
*/
|
||
double ObjMin, ObjMax; /* Range for Object variables */
|
||
double StdDevInit; /* Initial value of Standard Deviations */
|
||
|
||
};
|
||
|
||
#endif
|
||
|
||
|