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

some reviews

Browse source
This commit is contained in:
gustavo 2000-01-24 21:13:21 +00:00
commit 96f618f88f
6 changed files with 508 additions and 554 deletions
Download patch file Download diff file Expand all files Collapse all files

74
eo/src/EO.h
View file

@ -27,18 +27,19 @@
//-----------------------------------------------------------------------------
#include <stdexcept> // runtime_error
#include <eoObject.h>
#include <eoPersistent.h>
#include <stdexcept> // runtime_error
#include <eoObject.h> //
#include <eoPersistent.h> //
//-----------------------------------------------------------------------------
/** EO is a base class for evolvable objects, that is, the subjects of evolution.
EOs have only got a fitness, which at the same time needs to be only an object with the
operation less than (<) defined. Fitness says how good is the object; evolution or change
of these objects is left to the genetic operators. A fitness less than another means a
worse fitness, in whatever the context; thus, fitness is always maximized; although
it can be minimized with a proper definition of the < operator.\\
The fitness object must have, besides an void ctor, a copy ctor.
/** EO is a base class for evolvable objects, that is, the subjects of
evolution. EOs have only got a fitness, which at the same time needs to be
only an object with the operation less than (<) defined. Fitness says how
good is the object; evolution or change of these objects is left to the
genetic operators. A fitness less than another means a worse fitness, in
whatever the context; thus, fitness is always maximized; although it can
be minimized with a proper definition of the < operator. The fitness
object must have, besides an void ctor, a copy ctor.
*/
template<class F> class EO: public eoObject, public eoPersistent
{
@ -46,33 +47,26 @@ public:
typedef F Fitness;
/** Default constructor.
Fitness must have a ctor which takes 0 as a value; we can not use void ctors here
since default types like float have no void initializer. VC++ allows it, but gcc does not
Fitness must have a ctor which takes 0 as a value; we can not use void
ctors here since default types like float have no void initializer.
VC++ allows it, but gcc does not
*/
EO(): repFitness(0), invalidFitness(true) {}
/** Ctor from stream.
Fitness must have defined the lecture from an istream.
*/
EO( istream& _is ) {
_is >> repFitness;
invalidFitness = false;
};
/// Copy ctor
EO( const EO& _eo ): repFitness( _eo.repFitness ), invalidFitness( _eo.invalidFitness ) {};
EO( istream& _is ) { readFrom(_is); }
/// Virtual dtor
virtual ~EO() {};
/// Return fitness value.
Fitness fitness() const
{
if (invalid())
//throw runtime_error("invalid fitness");
cout << "invalid fitness" << endl;
return repFitness;
}
Fitness fitness() const {
if (invalid())
throw runtime_error("invalid fitness");
return repFitness;
}
// Set fitness as invalid.
void invalidate() { invalidFitness = true; }
@ -81,10 +75,10 @@ public:
* @param _fitness New fitness value.
*/
void fitness(const Fitness& _fitness)
{
repFitness = _fitness;
invalidFitness = false;
}
{
repFitness = _fitness;
invalidFitness = false;
}
/** Return true If fitness value is invalid, false otherwise.
* @return true If fitness is invalid.
@ -93,8 +87,8 @@ public:
/** Returns true if
@return true if the fitness is higher
*/
bool operator<(const EO& _eo2) const { return fitness() < _eo2.fitness();}
*/
bool operator<(const EO& _eo2) const { return fitness() < _eo2.fitness(); }
/// Methods inherited from eoObject
//@{
@ -102,23 +96,26 @@ public:
/** Return the class id.
* @return the class name as a string
*/
virtual string className() const { return "EO"; };
virtual string className() const { return "EO"; }
/**
* Read object.\\
* Calls base class, just in case that one had something to do. The read and print
* methods should be compatible and have the same format. In principle, format is
* "plain": they just print a number
* Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format.
* In principle, format is "plain": they just print a number
* @param _is a istream.
* @throw runtime_exception If a valid object can't be read.
*/
virtual void readFrom(istream& _is) {
_is >> repFitness;
invalidFitness = false;
if (is)
invalidFitness = false;
else
throw runtime_error("EO(istream&): can't read valid eo from istream");
}
/**
* Write object. It's called printOn since it prints the object _on_ a stream.
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A ostream.
*/
virtual void printOn(ostream& _os) const {
@ -135,3 +132,4 @@ private:
//-----------------------------------------------------------------------------
#endif EO_H

41
eo/src/UException.h
View file

@ -1,41 +0,0 @@
//-----------------------------------------------------------------------------
// UException.h
//-----------------------------------------------------------------------------
#ifndef _UEXCEPTION_H
#define _UEXCEPTION_H
#include <string>
#if defined (__BCPLUSPLUS__)
#include <stdexcept>
#else
#include <exception>
#endif
using namespace std;
//-----------------------------------------------------------------------------
// Class UException
//-----------------------------------------------------------------------------
//@{
/**
* This class manages exceptions. It´s barely an extension of the standard exception,
* but it can be initialized with an STL string. Called UException (utils-exception)+
* to avoid conflicts with other classes.
*/
class UException: public exception {
public:
///
UException( const string& _msg ): msg( _msg ) { };
///
virtual const char* what() const { return msg.c_str(); };
private:
string msg;
};
//@}
#endif

15
eo/src/eo1d.h
View file

@ -34,14 +34,13 @@
using namespace std;
/** @name eo1d class
* Randomly accesible evolvable object with one dimension, with
variable length.
* Use this if you want to evolve "linear" things, like bitstrings, or
floating-point arrays. If you don't, subclass directly from EO
* @see EO
* @author GeNeura
* @version 0.2
*/
* Randomly accesible evolvable object with one dimension, with variable
* length. Use this if you want to evolve "linear" things, like bitstrings,
* or floating-point arrays. If you don't, subclass directly from EO
* @see EO
* @author GeNeura
* @version 0.2
*/
//@{

21
eo/src/eo2dVector.h
View file

@ -51,8 +51,8 @@ QUEDA: Operador de asignaci
#include <eoRnd.h>
/** Adaptor that turns an STL vector of vectror into an EO
with the same gene type as the type with which
the vector of vector has been instantiated.
with the same gene type as the type with which
the vector of vector has been instantiated.
*/
template <class T, class fitnessT>
class eo2dVector: public eo2d<T, fitnessT>, public vector< vector<T> > {
@ -84,7 +84,7 @@ public:
eoRnd<T>& _rnd );
/** Ctor from a istream. The T class should accept reading from a istream. It doesn't read fitness,
which is supposed to be dynamic and dependent on environment.
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
*/
//eo2dVector( istream& _is);
@ -96,26 +96,26 @@ which is supposed to be dynamic and dependent on environment.
/// Assignment operator
/*
const eo2dVector& operator =( const eo2dVector & _eo ) {
const eo2dVector& operator =( const eo2dVector & _eo ) {
if ( this != &_eo ){
eo2d<T, fitnessT>::operator=( _eo );
vector< <vector<T> >::operator=( _eo );
eo2d<T, fitnessT>::operator=( _eo );
vector< <vector<T> >::operator=( _eo );
}
return *this;
}
}
*/
/// dtor
virtual ~eo2dVector() {};
//@}
/** Reads and returns a copy of the gene in position _r,_c.\
/** Reads and returns a copy of the gene in position _r,_c.\
This implies that T must have a copy ctor .
@param _r Index for rows. Must be an unsigned less than #numOfRows()#
@param _c Index for columns. Must be an unsigned less than #numOfCols()#
@return what's inside the gene, with the correct type
@exception out_of_range if _r >=numOfRows()
@exception out_of_range if _c >=numOfCols()
*/
*/
virtual T getGene( const unsigned _r,
const unsigned _c ) const {
if ( _r >= numOfRows() ) {
@ -132,7 +132,7 @@ which is supposed to be dynamic and dependent on environment.
}
return (*this)[_r][_c];
};
/** Overwrites the gene placed in position _r,_c with a
/** Overwrites the gene placed in position _r,_c with a
* new value. This means that the assignment operator
* for T must be defined .
@param _r Index for rows. Must be an unsigned less than #numOfRows()#
@ -331,3 +331,4 @@ ostream& operator<<( ostream& _os, const eo2dVector<T,fitnessT>& _eo) {
};
#endif

23
eo/src/eoBin.h
View file

@ -1,6 +1,23 @@
//-----------------------------------------------------------------------------
// eoBin.h
//-----------------------------------------------------------------------------
/*
eoBin.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 eoBin_h
#define eoBin_h

44
eo/src/eoParser.h
View file

@ -40,28 +40,8 @@
#include <strstream>
#include <ctime>
//-----------------------------------------------------------------------------
// Class UExceptions - probably useless ???
//-----------------------------------------------------------------------------
/**
* This class manages exceptions. It´s barely an extension of the standard except
ion,
* but it can be initialized with an STL string. Called UException (utils-except
ion)+
* to avoid conflicts with other classes.
*/
class UException: public exception {
public:
///
UException( const string& _msg ): msg( _msg ) { };
///
virtual const char* what() const { return msg.c_str(); };
private:
string msg;
};
// include for exceptions
include <stdecept> // logic_error
//-----------------------------------------------------------------------------
// Class Param
@ -747,20 +727,20 @@ public:
/**
* This class managges unknown argument exceptions.
*/
class UnknownArg : public UException {
class UnknownArg : public logic_error {
public:
/**
* Constructor
* @param _arg string to be shown when the exception occurs
*/
UnknownArg( const string& _arg): UException( "Invalid argument: "+_arg ) { };
UnknownArg( const string& _arg): logic_error( "Invalid argument: "+_arg ) { };
};
/**
* This class managges bad param types.
*/
class BadType : public UException {
class BadType : public logic_error {
public:
/**
@ -769,39 +749,39 @@ public:
* @param _value The value of the param
*/
BadType(const string& _param, const string& _value, const string& _correctType)
: UException("The value '" + _value + "' assigned to the argument " + _param + " isn't a correct "+_correctType) { };
: logic_error("The value '" + _value + "' assigned to the argument " + _param + " isn't a correct "+_correctType) { };
};
/**
* This class managges exceptions produced when there isn't a value for a parameter.
*/
class MissingVal : public UException {
class MissingVal : public logic_error {
public:
/**
* Constructor
* @param _param The param
*/
MissingVal(const string& _param) : UException("Missing value for parameter " + _param) {};
MissingVal(const string& _param) : logic_error("Missing value for parameter " + _param) {};
};
/**
* This class managges exceptions produced when the user forgot a required parameter.
*/
class MissingReqParam : public UException {
class MissingReqParam : public logic_error {
public:
/**
* Constructor
* @param _shortName The param's short name
*/
MissingReqParam(const string& _shortName) : UException("Missing required parameter " + _shortName) {};
MissingReqParam(const string& _shortName) : logic_error("Missing required parameter " + _shortName) {};
};
/**
* This class managges exceptions du to < without a > in array value
*/
class BadArrayParam : public UException {
class BadArrayParam : public logic_error {
public:
/**
@ -810,7 +790,7 @@ public:
* @param _first_word The first word read after the "<"
*/
BadArrayParam(const string& _param, const string &_first_word) :
UException("Array parameter " + _param + ": No matching > (" + _first_word
logic_error("Array parameter " + _param + ": No matching > (" + _first_word
+ "... )") {};
};