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

move paradiseo/eo to deprecated/ before merge with eodev

Browse source
This commit is contained in:
Johann Dreo 2012-10-05 15:12:12 +02:00
commit 0c5120f675
717 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

189
deprecated/eo/src/eoOp.h Normal file
View file

@ -0,0 +1,189 @@
// -*- 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
CVS Info: $Date: 2004-08-10 17:19:46 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoOp.h,v 1.29 2004-08-10 17:19:46 jmerelo Exp $ $Author: jmerelo $
*/
//-----------------------------------------------------------------------------
#ifndef _eoOp_H
#define _eoOp_H
#include <eoObject.h>
#include <eoPrintable.h>
#include <eoFunctor.h>
#include <utils/eoRNG.h>
/**
@defgroup Operators Evolutionary Operators
in EO, an operator is any functors that modifies objects and inherits from an eoOp.
Typically, a mutation is an operator that modifies an individual, and an algorithm is an operator that modifies a population.
In EO, there is a genetic operator hierarchy, with eoOp as father and
eoMonOp (monary or unary operator), eoBinOp and eoQuadOp (binary operators)
and eoGenOp (any number of inputs and outputs, see eoGenOp.h)
as subclasses.
Nobody should subclass eoOp, you should subclass eoGenOp, eoBinOp, eoQuadOp
or eoMonOp, those are the ones actually used here.
#eoOp#s are only printable objects, so if you want to build them
from a file, it has to be done in another class, namely factories.
Each hierarchy of #eoOp#s should have its own factory, which know
how to build them from a description in a file.
@author GeNeura Team, Marten Keijzer and Marc Schoenauer
@version 0.9
@see eoGenOp.h eoOpFactory
*/
//@{
/**
@defgroup Variators Variation operators
Variators are operators that modify individuals.
@defgroup Selectors Selection operators
Selectors are operators that select a subset of a population.
Example:
@include t-eoSelect.cpp
@defgroup Replacors Replacement operators
Replacors are operators that replace a subset of a population by another set of individuals.
Here is an example with several replacement operators:
@include t-eoReplacement.cpp
*/
/** Abstract data types for EO operators.
Genetic operators act on chromosomes, changing them.
The type to use them on is problem specific. If your genotype
is a std::vector<bool>, there are operators that work specifically
on std::vector<bool>, but you might also find that generic operators
working on std::vector<T> are what you need.
*/
template<class EOType>
class eoOp
{
public:
//@{
enum OpType { unary = 0, binary = 1, quadratic = 2, general = 3};
///
/// Ctor
eoOp(OpType _type)
:opType( _type ) {};
/// Copy Ctor
eoOp( const eoOp& _eop )
:opType( _eop.opType ) {};
/// Needed virtual destructor
virtual ~eoOp(){};
/// getType: number of operands it takes and individuals it produces
OpType getType() const {return opType;};
private:
/// OpType is the type of the operator: how many operands it takes and how many it produces
OpType opType;
};
/**
eoMonOp is the monary operator: genetic operator that takes only one EO.
When defining your own, make sure that you return a boolean value
indicating that you have changed the content.
*/
template <class EOType>
class eoMonOp: public eoOp<EOType>, public eoUF<EOType&, bool>
{
public:
/// Ctor
eoMonOp()
: eoOp<EOType>( eoOp<EOType>::unary ) {};
virtual std::string className() const {return "eoMonOp";};
};
/** Binary genetic operator: subclasses eoOp, and defines basically the
* operator() with two operands, only the first one can be modified
When defining your own, make sure that you return a boolean value
indicating that you have changed the content.
*/
template<class EOType>
class eoBinOp: public eoOp<EOType>, public eoBF<EOType&, const EOType&, bool>
{
public:
/// Ctor
eoBinOp()
:eoOp<EOType>( eoOp<EOType>::binary ) {};
virtual std::string className() const {return "eoBinOp";};
};
/** Quad genetic operator: subclasses eoOp, and defines basically the
operator() with two operands, both can be modified.
When defining your own, make sure that you return a boolean value
indicating that you have changed the content.
*/
template<class EOType>
class eoQuadOp: public eoOp<EOType>, public eoBF<EOType&, EOType&, bool> {
public:
/// Ctor
eoQuadOp()
:eoOp<EOType>( eoOp<EOType>::quadratic ) {};
virtual std::string className() const {return "eoQuadOp";};
};
/** Turning an eoQuadOp into an eoBinOp: simply don't touch the second arg!
*/
template <class EOT>
class eoQuad2BinOp: public eoBinOp<EOT>
{
public:
/** Ctor
* @param _quadOp the eoQuadOp to be transformed
*/
eoQuad2BinOp(eoQuadOp<EOT> & _quadOp) : quadOp(_quadOp) {}
/** Operator() simply calls embedded quadOp operator() with dummy second arg
*/
bool operator()(EOT & _eo1, const EOT & _eo2)
{
EOT eoTmp = _eo2; // a copy that can be modified
// if the embedded eoQuadOp is not symmetrical,
// the result might be biased - hence the flip ...
if (eo::rng.flip(0.5))
return quadOp(_eo1, eoTmp); // both are modified - that's all
else
return quadOp(eoTmp, _eo1); // both are modified - that's all
}
private:
eoQuadOp<EOT> & quadOp;
};
#endif
//@}