nojhan/paradiseo
Watch
1
0
Fork
You've already forked paradiseo
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

New style for MO

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@787 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
canape 2007-11-16 11:25:54 +00:00
commit 7161febf9c
80 changed files with 2014 additions and 2038 deletions
Download patch file Download diff file Expand all files Collapse all files

2
trunk/paradiseo-mo/src/index.h
View file

@ -53,7 +53,7 @@ It contains classes for almost any kind of one solution based heuristics.
@section Installation
The installation procedure of the package is detailed in the
The installation procedure of the package is detailed in the
<a href="../../README">README</a> file in the top-directory of the source-tree.
*/

2
trunk/paradiseo-mo/src/mo.h
View file

@ -1,4 +1,4 @@
/*
/*
* <mo.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007

6
trunk/paradiseo-mo/src/moAlgo.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moAlgo.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,8 +44,6 @@
moHC, moTS and moSA are 3 examples of algorithm of the paradiseo-mo library.
*/
template < class EOT > class moAlgo:public eoMonOp < EOT >
{
};
{};
#endif

24
trunk/paradiseo-mo/src/moAspirCrit.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moAspirCrit.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,18 +45,18 @@
See moNoAspriCrit for example.
*/
template < class M > class moAspirCrit:public eoBF < const M &, const typename
M::EOType::Fitness &,
bool >
{
M::EOType::Fitness &,
bool >
{
public:
//! Procedure which initialises all that needs a aspiration criterion.
/*!
It can be possible that this procedure do nothing...
*/
virtual void
init () = 0;
public:
//! Procedure which initialises all that needs a aspiration criterion.
/*!
It can be possible that this procedure do nothing...
*/
virtual void
init () = 0;
};
};
#endif

108
trunk/paradiseo-mo/src/moBestImprSelect.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moBestImprSelect.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,74 +45,74 @@
which enables the best improvement is selected.
*/
template < class M > class moBestImprSelect:public moMoveSelect < M >
{
public:
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
//! Procedure which initialise the exploration
void init (const Fitness & __fit)
{
first_time = true;
}
public:
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
//! Procedure which initialise the exploration
void init (const Fitness & __fit)
{
first_time = true;
}
//!Function that indicates if the current move has not improved the fitness.
/*!
If the given fitness enables an improvment,
the move (moMove) and the fitness linked to this move are saved.
//!Function that indicates if the current move has not improved the fitness.
/*!
If the given fitness enables an improvment,
the move (moMove) and the fitness linked to this move are saved.
\param __move a move.
\param __fit a fitness linked to the move.
\return TRUE if the move does not improve the fitness.
*/
bool update (const M & __move, const Fitness & __fit)
{
\param __move a move.
\param __fit a fitness linked to the move.
\return TRUE if the move does not improve the fitness.
*/
bool update (const M & __move, const Fitness & __fit)
{
if (first_time || __fit > best_fit)
{
if (first_time || __fit > best_fit)
{
best_fit = __fit;
best_move = __move;
best_fit = __fit;
best_move = __move;
first_time = false;
}
first_time = false;
}
return true;
}
return true;
}
//! Procedure which saved the best move and fitness.
/*!
\param __move the current move (result of the procedure).
\param __fit the current fitness (result of the procedure).
\throws EmptySelection if no move has improved the fitness.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
//! Procedure which saved the best move and fitness.
/*!
\param __move the current move (result of the procedure).
\param __fit the current fitness (result of the procedure).
\throws EmptySelection if no move has improved the fitness.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
if (!first_time)
{
__move = best_move;
__fit = best_fit;
}
else
throw EmptySelection ();
}
if (!first_time)
{
__move = best_move;
__fit = best_fit;
}
else
throw EmptySelection ();
}
private:
private:
//! Allowing to know if at least one move has been generated.
bool first_time;
//! Allowing to know if at least one move has been generated.
bool first_time;
//! The best move.
M best_move;
//! The best move.
M best_move;
//! The best fitness.
Fitness best_fit;
//! The best fitness.
Fitness best_fit;
};
};
#endif

7
trunk/paradiseo-mo/src/moComparator.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moComparator.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,13 +38,12 @@
#define __moComparator_h
//! Template for classes which need to compare two EOT and indicate if the first is "better" than the second.
//! Template for classes which need to compare two EOT and indicate if the first is "better" than the second.
/*!
The objects that extend this template describe how an EOT is "better" than an other.
*/
template<class EOT>
class moComparator: public eoBF<const EOT&, const EOT&, bool>
{
};
{};
#endif

6
trunk/paradiseo-mo/src/moCoolingSchedule.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moCoolingSchedule.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,8 +45,6 @@
See moExponentialCoolingSchedule or moLinearCoolingSchedule for example.
*/
class moCoolingSchedule:public eoUF < double &, bool >
{
};
{};
#endif

56
trunk/paradiseo-mo/src/moExponentialCoolingSchedule.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moExponentialCoolingSchedule.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,36 +45,36 @@
the temperature is greater than a given threshold.
*/
class moExponentialCoolingSchedule: public moCoolingSchedule
{
public:
//! Simple constructor
/*!
\param __threshold the threshold.
\param __ratio the ratio used to descrease the temperature.
*/
moExponentialCoolingSchedule (double __threshold, double __ratio):threshold (__threshold), ratio (__ratio)
{}
//! Function which proceeds to the cooling.
/*!
It decreases the temperature and indicates if it is greater than the threshold.
\param __temp the current temperature.
\return if the new temperature (current temperature * ratio) is greater than the threshold.
*/
bool operator() (double &__temp)
{
return (__temp *= ratio) > threshold;
}
private:
public:
//! Simple constructor
/*!
\param __threshold the threshold.
\param __ratio the ratio used to descrease the temperature.
*/
moExponentialCoolingSchedule (double __threshold, double __ratio):threshold (__threshold), ratio (__ratio)
{}
//! The temperature threhold.
double threshold;
//! Function which proceeds to the cooling.
/*!
It decreases the temperature and indicates if it is greater than the threshold.
//! The decreasing factor of the temperature.
double ratio;
};
\param __temp the current temperature.
\return if the new temperature (current temperature * ratio) is greater than the threshold.
*/
bool operator() (double &__temp)
{
return (__temp *= ratio) > threshold;
}
private:
//! The temperature threhold.
double threshold;
//! The decreasing factor of the temperature.
double ratio;
};
#endif

128
trunk/paradiseo-mo/src/moFirstImprSelect.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moFirstImprSelect.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -46,84 +46,84 @@
current solution.
*/
template < class M > class moFirstImprSelect:public moMoveSelect < M >
{
public:
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
//! Procedure which initialise the exploration.
/*!
It save the current fitness as the initial value for the fitness.
*/
virtual void init (const Fitness & __fit)
{
valid = false;
init_fit = __fit;
}
public:
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
//! Procedure which initialise the exploration.
/*!
It save the current fitness as the initial value for the fitness.
*/
virtual void init (const Fitness & __fit)
{
valid = false;
init_fit = __fit;
}
//!Function that indicates if the current move has not improved the fitness.
/*!
If the given fitness enables an improvment,
the move (moMove) should be applied to the current solution.
//!Function that indicates if the current move has not improved the fitness.
/*!
If the given fitness enables an improvment,
the move (moMove) should be applied to the current solution.
\param __move a move.
\param __fit a fitness linked to the move.
\return TRUE if the move does not improve the fitness.
*/
bool update (const M & __move, const typename M::EOType::Fitness & __fit)
{
\param __move a move.
\param __fit a fitness linked to the move.
\return TRUE if the move does not improve the fitness.
*/
bool update (const M & __move, const typename M::EOType::Fitness & __fit)
{
if (__fit > init_fit)
{
if (__fit > init_fit)
{
best_fit = __fit;
best_move = __move;
valid = true;
best_fit = __fit;
best_move = __move;
valid = true;
return false;
}
else
{
return true;
}
}
return false;
}
else
{
return true;
}
}
//! Procedure which saved the best move and fitness.
/*!
\param __move the current move (result of the procedure).
\param __fit the current fitness (result of the procedure).
\throws EmptySelection if no move has improved the fitness.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
//! Procedure which saved the best move and fitness.
/*!
\param __move the current move (result of the procedure).
\param __fit the current fitness (result of the procedure).
\throws EmptySelection if no move has improved the fitness.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
if (valid)
{
__move = best_move;
__fit = best_fit;
}
else
throw EmptySelection ();
}
if (valid)
{
__move = best_move;
__fit = best_fit;
}
else
throw EmptySelection ();
}
private:
private:
//! Allow to know if at least one move has improved the solution.
bool valid;
//! Allow to know if at least one move has improved the solution.
bool valid;
//! Best stored movement.
M best_move;
//! Best stored movement.
M best_move;
//! Initial fitness.
Fitness init_fit;
//! Initial fitness.
Fitness init_fit;
//! Best stored fitness.
Fitness best_fit;
//! Best stored fitness.
Fitness best_fit;
};
};
#endif

30
trunk/paradiseo-mo/src/moFitComparator.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moFitComparator.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,25 +37,25 @@
#ifndef __moFitComparator_h
#define __moFitComparator_h
//! Comparison according to the fitness.
//! Comparison according to the fitness.
/*!
An EOT is better than an other if its fitness is better.
*/
template<class EOT>
class moFitComparator: public moComparator<EOT>
{
public:
//! Function which makes the comparison and gives the result.
/*!
\param _solution1 The first solution.
\param _solution2 The second solution.
\return true if the fitness of the first solution is better than the second solution, false else.
*/
bool operator()(const EOT& _solution1, const EOT& _solution2)
{
return _solution1.fitness()>_solution2.fitness();
}
};
public:
//! Function which makes the comparison and gives the result.
/*!
\param _solution1 The first solution.
\param _solution2 The second solution.
\return true if the fitness of the first solution is better than the second solution, false else.
*/
bool operator()(const EOT& _solution1, const EOT& _solution2)
{
return _solution1.fitness()>_solution2.fitness();
}
};
#endif

78
trunk/paradiseo-mo/src/moFitSolContinue.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moFitSolContinue.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,48 +44,48 @@
The stop criterion corresponds to a fitness threshold gained.
*/
template < class EOT > class moFitSolContinue:public moSolContinue < EOT >
{
public:
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
//! Basic constructor.
/*!
\param __fitness The fitness to reach.
*/
moFitSolContinue (Fitness __fitness): fitness (__fitness)
{}
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness threshold has not yet been reached.
\param __sol the current solution.
\return true or false according to the value of the fitness.
*/
bool operator () (const EOT & __sol)
{
if(__sol.invalid())
{
return true;
}
return __sol.fitness() < fitness;
}
public:
//! Procedure which allows to initialise all the stuff needed.
/*!
It can be also used to reinitialize all the needed things.
*/
void init ()
{}
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
private:
//! Basic constructor.
/*!
\param __fitness The fitness to reach.
*/
moFitSolContinue (Fitness __fitness): fitness (__fitness)
{}
//! Fitness target.
Fitness fitness;
};
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness threshold has not yet been reached.
\param __sol the current solution.
\return true or false according to the value of the fitness.
*/
bool operator () (const EOT & __sol)
{
if (__sol.invalid())
{
return true;
}
return __sol.fitness() < fitness;
}
//! Procedure which allows to initialise all the stuff needed.
/*!
It can be also used to reinitialize all the needed things.
*/
void init ()
{}
private:
//! Fitness target.
Fitness fitness;
};
#endif

72
trunk/paradiseo-mo/src/moGenSolContinue.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moGenSolContinue.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,51 +44,49 @@
The stop criterion corresponds to a maximum number of iteration.
*/
template < class EOT > class moGenSolContinue:public moSolContinue < EOT >
{
public:
//! Simple constructor.
/*!
\param __maxNumGen the maximum number of generation.
*/
moGenSolContinue (unsigned int __maxNumGen):maxNumGen (__maxNumGen), numGen (0)
{
}
public:
//! Function that activates the stop criterion.
/*!
Increments the counter and returns TRUE if the
current number of iteration is lower than the given
maximum number of iterations.
//! Simple constructor.
/*!
\param __maxNumGen the maximum number of generation.
*/
moGenSolContinue (unsigned int __maxNumGen):maxNumGen (__maxNumGen), numGen (0)
{}
\param __sol the current solution.
\return TRUE or FALSE according to the current generation number.
*/
bool operator () (const EOT & __sol)
{
//! Function that activates the stop criterion.
/*!
Increments the counter and returns TRUE if the
current number of iteration is lower than the given
maximum number of iterations.
return (++numGen < maxNumGen);
}
\param __sol the current solution.
\return TRUE or FALSE according to the current generation number.
*/
bool operator () (const EOT & __sol)
{
//! Procedure which allows to initialise the generation counter.
/*!
It can also be used to reset the iteration counter.
*/
void init ()
{
return (++numGen < maxNumGen);
}
numGen = 0;
}
//! Procedure which allows to initialise the generation counter.
/*!
It can also be used to reset the iteration counter.
*/
void init ()
{
private:
numGen = 0;
}
//! Iteration maximum number.
unsigned int maxNumGen;
private:
//! Iteration current number.
unsigned int numGen;
};
//! Iteration maximum number.
unsigned int maxNumGen;
//! Iteration current number.
unsigned int numGen;
};
#endif

150
trunk/paradiseo-mo/src/moHC.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moHC.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -48,110 +48,106 @@
Class which describes the algorithm for a hill climbing.
*/
template < class M > class moHC:public moAlgo < typename M::EOType >
{
{
//! Alias for the type.
typedef
//! Alias for the type.
typedef
typename
M::EOType
EOT;
//! Alias for the fitness.
typedef
//! Alias for the fitness.
typedef
typename
EOT::Fitness
Fitness;
public:
public:
//! Full constructor.
/*!
All the boxes are given in order the HC to use a moHCMoveLoopExpl.
//! Full constructor.
/*!
All the boxes are given in order the HC to use a moHCMoveLoopExpl.
\param __move_init a move initialiser.
\param __next_move a neighborhood explorer.
\param __incr_eval a (generally) efficient evaluation function.
\param __move_select a move selector.
\param __full_eval a full evaluation function.
*/
moHC (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moMoveSelect < M > &__move_select, eoEvalFunc < EOT > &__full_eval):move_expl (*new moHCMoveLoopExpl < M >
(__move_init, __next_move, __incr_eval, __move_select)),
full_eval (__full_eval)
{
\param __move_init a move initialiser.
\param __next_move a neighborhood explorer.
\param __incr_eval a (generally) efficient evaluation function.
\param __move_select a move selector.
\param __full_eval a full evaluation function.
*/
moHC (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moMoveSelect < M > &__move_select, eoEvalFunc < EOT > &__full_eval):move_expl (*new moHCMoveLoopExpl < M >
(__move_init, __next_move, __incr_eval, __move_select)),
full_eval (__full_eval)
{}
}
//! Light constructor.
/*!
This constructor allow to use another moMoveExpl (generally not a moHCMoveLoopExpl).
//! Light constructor.
/*!
This constructor allow to use another moMoveExpl (generally not a moHCMoveLoopExpl).
\param __move_expl a complete explorer.
\param __full_eval a full evaluation function.
*/
moHC (moMoveExpl < M > &__move_expl, eoEvalFunc < EOT > &__full_eval):move_expl (__move_expl),
full_eval
(__full_eval)
{}
\param __move_expl a complete explorer.
\param __full_eval a full evaluation function.
*/
moHC (moMoveExpl < M > &__move_expl, eoEvalFunc < EOT > &__full_eval):move_expl (__move_expl),
full_eval
(__full_eval)
{
//! Function which launches the HC
/*!
The HC has to improve a current solution.
As the moSA and the mo TS, it can be used for HYBRIDATION in an evolutionnary algorithm.
}
\param __sol a current solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
//! Function which launches the HC
/*!
The HC has to improve a current solution.
As the moSA and the mo TS, it can be used for HYBRIDATION in an evolutionnary algorithm.
if (__sol.invalid ())
{
full_eval (__sol);
}
\param __sol a current solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
EOT new_sol;
if (__sol.invalid ())
{
full_eval (__sol);
}
do
{
EOT new_sol;
new_sol = __sol;
do
{
try
{
new_sol = __sol;
move_expl (__sol, new_sol);
try
{
}
catch (EmptySelection & __ex)
{
move_expl (__sol, new_sol);
break;
}
}
catch (EmptySelection & __ex)
{
if (new_sol.fitness () > __sol.fitness ())
{
__sol = new_sol;
}
else
{
break;
}
break;
}
}
while (true);
if (new_sol.fitness () > __sol.fitness ())
{
__sol = new_sol;
}
else
{
break;
}
return true;
}
}
while (true);
private:
return true;
}
//! Complete exploration of the neighborhood.
moMoveExpl < M > &move_expl;
private:
//! Complete exploration of the neighborhood.
moMoveExpl < M > &move_expl;
//! A full evaluation function.
eoEvalFunc < EOT > &full_eval;
};
//! A full evaluation function.
eoEvalFunc < EOT > &full_eval;
};
#endif

124
trunk/paradiseo-mo/src/moHCMoveLoopExpl.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moHCMoveLoopExpl.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -46,88 +46,86 @@
//! Iterative explorer used by a moHC.
template < class M > class moHCMoveLoopExpl:public moMoveLoopExpl < M >
{
//! Alias for the type.
typedef typename M::EOType EOT;
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
public:
//! Constructor.
/*!
All the boxes have to be specified.
\param __move_init the move initialiser.
\param __next_move the neighborhood explorer.
\param __incr_eval (generally) efficient evaluation function.
\param __move_select the move selector.
*/
moHCMoveLoopExpl (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moMoveSelect < M > &__move_select):
move_init (__move_init),
next_move (__next_move),
incr_eval (__incr_eval), move_select (__move_select)
{
}
//! Alias for the type.
typedef typename M::EOType EOT;
//! Procedure which launches the explorer.
/*!
The exploration starts from an old solution and provides a new solution.
//! Alias for the fitness.
typedef typename M::EOType::Fitness Fitness;
\param __old_sol the current solution.
\param __new_sol the new_sol (result of the procedure).
*/
void operator () (const EOT & __old_sol, EOT & __new_sol)
{
public:
M move;
//! Constructor.
/*!
All the boxes have to be specified.
//
move_init (move, __old_sol); /* Restarting the exploration of
of the neighborhood ! */
\param __move_init the move initialiser.
\param __next_move the neighborhood explorer.
\param __incr_eval (generally) efficient evaluation function.
\param __move_select the move selector.
*/
moHCMoveLoopExpl (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moMoveSelect < M > &__move_select):
move_select.init (__old_sol.fitness ());
move_init (__move_init),
next_move (__next_move),
incr_eval (__incr_eval), move_select (__move_select)
{}
while (move_select.update (move, incr_eval (move, __old_sol))
&& next_move (move, __old_sol));
//! Procedure which launches the explorer.
/*!
The exploration starts from an old solution and provides a new solution.
try
\param __old_sol the current solution.
\param __new_sol the new_sol (result of the procedure).
*/
void operator () (const EOT & __old_sol, EOT & __new_sol)
{
M best_move;
M move;
Fitness best_move_fit;
//
move_init (move, __old_sol); /* Restarting the exploration of
of the neighborhood ! */
move_select (best_move, best_move_fit);
__new_sol.fitness (best_move_fit);
best_move (__new_sol);
move_select.init (__old_sol.fitness ());
while (move_select.update (move, incr_eval (move, __old_sol))
&& next_move (move, __old_sol));
try
{
M best_move;
Fitness best_move_fit;
move_select (best_move, best_move_fit);
__new_sol.fitness (best_move_fit);
best_move (__new_sol);
}
catch (EmptySelection & __ex)
{
// ?
}
}
catch (EmptySelection & __ex)
{
// ?
}
}
private:
private:
//! Move initialiser.
moMoveInit < M > &move_init;
//! Move initialiser.
moMoveInit < M > &move_init;
//! Neighborhood explorer.
moNextMove < M > &next_move;
//! Neighborhood explorer.
moNextMove < M > &next_move;
//! (generally) Efficient evaluation.
moMoveIncrEval < M > &incr_eval;
//! (generally) Efficient evaluation.
moMoveIncrEval < M > &incr_eval;
//! Move selector.
moMoveSelect < M > &move_select;
//! Move selector.
moMoveSelect < M > &move_select;
};
};
#endif

280
trunk/paradiseo-mo/src/moILS.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moILS.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -48,156 +48,156 @@
Class which describes the algorithm for a iterated local search.
*/
template < class M > class moILS:public moAlgo < typename M::EOType >
{
//! Alias for the type.
typedef typename M::EOType EOT;
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
public:
//! Generic constructor
/*!
Generic constructor using a moAlgo
\param __algo The solution based heuristic to use.
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moAlgo<EOT> &__algo, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation,
eoEvalFunc<EOT> &__full_eval):
algo(__algo), cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moHC for the moAlgo
/*!
\param __move_init The move initialisation (for the moHC).
\param __next_move The move generator (for the moHC).
\param __incr_eval The partial evaluation function (for the moHC).
\param __move_select The move selection strategy (for the moHC).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval,
moMoveSelect < M > &__move_select, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion,
eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
algo(*new moHC<M>(__move_init, __next_move, __incr_eval, __move_select, __full_eval)), cont(__continue),
acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moTS for the moAlgo
/*!
\param __move_init The move initialisation (for the moTS).
\param __next_move The move generator (for the moTS).
\param __incr_eval The partial evaluation function (for the moTS).
\param __tabu_list The tabu list (for the moTS !!!!).
\param __aspir_crit The aspiration criterion (for the moTS).
\param __moTS_continue The stopping criterion (for the moTS).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moMoveInit <M> &__move_init, moNextMove <M> &__next_move, moMoveIncrEval <M> &__incr_eval,
moTabuList <M> &__tabu_list, moAspirCrit <M> &__aspir_crit, moSolContinue <EOT> &__moTS_continue,
moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation,
eoEvalFunc<EOT> &__full_eval):
algo(*new moTS<M>(__move_init, __next_move, __incr_eval, __tabu_list, __aspir_crit, __moTS_continue, __full_eval)),
cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moSA for the moAlgo
/*!
\param __move_rand The random move generator (for the moSA).
\param __incr_eval The partial evaluation function (for the moSA).
\param __moSA_continue The stopping criterion (for the moSA).
\param __init_temp The initial temperature (for the moSA).
\param __cool_sched The cooling scheduler (for the moSA).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moRandMove<M> &__move_rand, moMoveIncrEval <M> &__incr_eval, moSolContinue <EOT> &__moSA_continue, double __init_temp,
moCoolingSchedule & __cool_sched, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion,
eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
algo(*new moSA<M>(__move_rand, __incr_eval, __moSA_continue, __init_temp, __cool_sched, __full_eval)),
cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Function which launches the ILS
/*!
The ILS has to improve a current solution.
As the moSA, the moTS and the moHC, it can be used for HYBRIDATION in an evolutionnary algorithm.
\param __sol a current solution to improve.
\return TRUE.
*/
bool operator()(EOT & __sol)
{
EOT __sol_saved=__sol;
cont.init ();
//some code has been duplicated in order to avoid one perturbation and one evaluation without adding a test in the loop.
// better than a do {} while; with a test in the loop.
//! Alias for the type.
typedef typename M::EOType EOT;
algo(__sol);
if(acceptance_criterion(__sol, __sol_saved))
{
__sol_saved=__sol;
}
else
{
__sol=__sol_saved;
}
while (cont (__sol))
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
public:
//! Generic constructor
/*!
Generic constructor using a moAlgo
\param __algo The solution based heuristic to use.
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moAlgo<EOT> &__algo, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation,
eoEvalFunc<EOT> &__full_eval):
algo(__algo), cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moHC for the moAlgo
/*!
\param __move_init The move initialisation (for the moHC).
\param __next_move The move generator (for the moHC).
\param __incr_eval The partial evaluation function (for the moHC).
\param __move_select The move selection strategy (for the moHC).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval,
moMoveSelect < M > &__move_select, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion,
eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
algo(*new moHC<M>(__move_init, __next_move, __incr_eval, __move_select, __full_eval)), cont(__continue),
acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moTS for the moAlgo
/*!
\param __move_init The move initialisation (for the moTS).
\param __next_move The move generator (for the moTS).
\param __incr_eval The partial evaluation function (for the moTS).
\param __tabu_list The tabu list (for the moTS !!!!).
\param __aspir_crit The aspiration criterion (for the moTS).
\param __moTS_continue The stopping criterion (for the moTS).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moMoveInit <M> &__move_init, moNextMove <M> &__next_move, moMoveIncrEval <M> &__incr_eval,
moTabuList <M> &__tabu_list, moAspirCrit <M> &__aspir_crit, moSolContinue <EOT> &__moTS_continue,
moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion, eoMonOp<EOT> &__perturbation,
eoEvalFunc<EOT> &__full_eval):
algo(*new moTS<M>(__move_init, __next_move, __incr_eval, __tabu_list, __aspir_crit, __moTS_continue, __full_eval)),
cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Constructor for using a moSA for the moAlgo
/*!
\param __move_rand The random move generator (for the moSA).
\param __incr_eval The partial evaluation function (for the moSA).
\param __moSA_continue The stopping criterion (for the moSA).
\param __init_temp The initial temperature (for the moSA).
\param __cool_sched The cooling scheduler (for the moSA).
\param __continue The stopping criterion.
\param __acceptance_criterion The acceptance criterion.
\param __perturbation The pertubation generator.
\param __full_eval The evaluation function.
*/
moILS (moRandMove<M> &__move_rand, moMoveIncrEval <M> &__incr_eval, moSolContinue <EOT> &__moSA_continue, double __init_temp,
moCoolingSchedule & __cool_sched, moSolContinue <EOT> &__continue, moComparator<EOT> &__acceptance_criterion,
eoMonOp<EOT> &__perturbation, eoEvalFunc<EOT> &__full_eval):
algo(*new moSA<M>(__move_rand, __incr_eval, __moSA_continue, __init_temp, __cool_sched, __full_eval)),
cont(__continue), acceptance_criterion(__acceptance_criterion), perturbation(__perturbation), full_eval(__full_eval)
{}
//! Function which launches the ILS
/*!
The ILS has to improve a current solution.
As the moSA, the moTS and the moHC, it can be used for HYBRIDATION in an evolutionnary algorithm.
\param __sol a current solution to improve.
\return TRUE.
*/
bool operator()(EOT & __sol)
{
perturbation(__sol);
full_eval(__sol);
EOT __sol_saved=__sol;
cont.init ();
//some code has been duplicated in order to avoid one perturbation and one evaluation without adding a test in the loop.
// better than a do {} while; with a test in the loop.
algo(__sol);
if(acceptance_criterion(__sol, __sol_saved))
{
__sol_saved=__sol;
}
if (acceptance_criterion(__sol, __sol_saved))
{
__sol_saved=__sol;
}
else
{
__sol=__sol_saved;
}
{
__sol=__sol_saved;
}
while (cont (__sol))
{
perturbation(__sol);
full_eval(__sol);
algo(__sol);
if (acceptance_criterion(__sol, __sol_saved))
{
__sol_saved=__sol;
}
else
{
__sol=__sol_saved;
}
}
return true;
}
return true;
}
private:
private:
//! The solution based heuristic.
moAlgo<EOT> &algo;
//! The solution based heuristic.
moAlgo<EOT> &algo;
//! The stopping criterion.
moSolContinue<EOT> &cont;
//! The stopping criterion.
moSolContinue<EOT> &cont;
//! The acceptance criterion.
moComparator<EOT> &acceptance_criterion;
//! The acceptance criterion.
moComparator<EOT> &acceptance_criterion;
//! The perturbation generator
eoMonOp<EOT> &perturbation;
//! The full evaluation function
eoEvalFunc<EOT> &full_eval;
};
//! The perturbation generator
eoMonOp<EOT> &perturbation;
//! The full evaluation function
eoEvalFunc<EOT> &full_eval;
};
#endif

92
trunk/paradiseo-mo/src/moImprBestFitAspirCrit.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moImprBestFitAspirCrit.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,65 +45,65 @@
is the best ever considered.
*/
template < class M > class moImprBestFitAspirCrit:public moAspirCrit < M >
{
public:
//! Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
//! Contructor
moImprBestFitAspirCrit ()
{
first_time = true;
}
public:
//! Initialisation procedure
void init ()
{
//! Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
first_time = true;
}
//! Contructor
moImprBestFitAspirCrit ()
{
//! Function that indicates if the fit is better that the already saved fit
/*!
The first time, the function only saved the current move and fitness.
first_time = true;
}
\param __move a move.
\param __fit a fitnes linked to the move.
\return TRUE the first time and if __fit > best_fit, else FALSE.
*/
bool operator () (const M & __move, const Fitness & __fit)
{
//! Initialisation procedure
void init ()
{
if (first_time)
{
first_time = true;
}
best_fit = __fit;
first_time = false;
//! Function that indicates if the fit is better that the already saved fit
/*!
The first time, the function only saved the current move and fitness.
return true;
}
else if (__fit < best_fit)
return false;
\param __move a move.
\param __fit a fitnes linked to the move.
\return TRUE the first time and if __fit > best_fit, else FALSE.
*/
bool operator () (const M & __move, const Fitness & __fit)
{
else
{
if (first_time)
{
best_fit = __fit;
best_fit = __fit;
first_time = false;
return true;
}
}
return true;
}
else if (__fit < best_fit)
return false;
private:
else
{
//! Best fitness found until now
Fitness best_fit;
best_fit = __fit;
//! Indicates that a fitness has been already saved or not
bool first_time;
};
return true;
}
}
private:
//! Best fitness found until now
Fitness best_fit;
//! Indicates that a fitness has been already saved or not
bool first_time;
};
#endif

96
trunk/paradiseo-mo/src/moItRandNextMove.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moItRandNextMove.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,65 +45,63 @@
This class is a move (moMove) generator with a bound for the maximum number of iterations.
*/
template < class M > class moItRandNextMove:public moNextMove < M >
{
//! Alias for the type.
typedef typename M::EOType EOT;
public:
//! The constructor.
/*!
Parameters only for initialising the attributes.
\param __rand_move the random move generator.
\param __max_iter the iteration maximum number.
*/
moItRandNextMove (moRandMove < M > &__rand_move,
unsigned int __max_iter):rand_move (__rand_move),
max_iter (__max_iter), num_iter (0)
{
}
//! Alias for the type.
typedef typename M::EOType EOT;
//! Generation of a new move
/*!
If the maximum number is not already reached, the current move is forgotten and remplaced by another one.
public:
\param __move the current move.
\param __sol the current solution.
\return FALSE if the maximum number of iteration is reached, else TRUE.
*/
bool operator () (M & __move, const EOT & __sol)
{
//! The constructor.
/*!
Parameters only for initialising the attributes.
if (num_iter++ > max_iter)
{
\param __rand_move the random move generator.
\param __max_iter the iteration maximum number.
*/
moItRandNextMove (moRandMove < M > &__rand_move,
unsigned int __max_iter):rand_move (__rand_move),
max_iter (__max_iter), num_iter (0)
{}
num_iter = 0;
return false;
}
else
{
//! Generation of a new move
/*!
If the maximum number is not already reached, the current move is forgotten and remplaced by another one.
/* The given solution is discarded here */
rand_move (__move);
num_iter++;
return true;
}
}
\param __move the current move.
\param __sol the current solution.
\return FALSE if the maximum number of iteration is reached, else TRUE.
*/
bool operator () (M & __move, const EOT & __sol)
{
private:
if (num_iter++ > max_iter)
{
//! A move generator (generally randomly).
moRandMove < M > &rand_move;
num_iter = 0;
return false;
}
else
{
//! Iteration maximum number.
unsigned int max_iter;
/* The given solution is discarded here */
rand_move (__move);
num_iter++;
return true;
}
}
//! Iteration current number.
unsigned int num_iter;
private:
};
//! A move generator (generally randomly).
moRandMove < M > &rand_move;
//! Iteration maximum number.
unsigned int max_iter;
//! Iteration current number.
unsigned int num_iter;
};
#endif

68
trunk/paradiseo-mo/src/moLSCheckPoint.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moLSCheckPoint.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,48 +44,48 @@
Thanks to this class, at each iteration, additionnal function can be used (and not only one).
*/
template < class M > class moLSCheckPoint:public eoBF < const M &, const typename
M::EOType &, void >
{
public:
//! Function which launches the checkpointing
/*!
Each saved function is used on the current move and the current solution.
\param __move a move.
\param __sol a solution.
*/
void
operator () (const M & __move, const typename M::EOType & __sol)
M::EOType &, void >
{
for (unsigned int i = 0; i < func.size (); i++)
public:
//! Function which launches the checkpointing
/*!
Each saved function is used on the current move and the current solution.
\param __move a move.
\param __sol a solution.
*/
void
operator () (const M & __move, const typename M::EOType & __sol)
{
for (unsigned int i = 0; i < func.size (); i++)
{
func[i]->operator ()(__move, __sol);
}
}
//! Procedure which add a new function to the function vector
/*!
The new function is added at the end of the vector.
\param __f a new function to add.
*/
void
add (eoBF < const M &, const typename M::EOType &, void >&__f)
{
func[i]->operator ()(__move, __sol);
func.push_back (&__f);
}
}
//! Procedure which add a new function to the function vector
/*!
The new function is added at the end of the vector.
\param __f a new function to add.
*/
void
add (eoBF < const M &, const typename M::EOType &, void >&__f)
{
private:
func.push_back (&__f);
}
private:
//! vector of function
std::vector < eoBF < const
//! vector of function
std::vector < eoBF < const
M &, const
typename
M::EOType &, void >*>
M::EOType &, void >*>
func;
};
};
#endif

56
trunk/paradiseo-mo/src/moLinearCoolingSchedule.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moLinearCoolingSchedule.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,36 +45,36 @@
the temperature is greater than a threshold.
*/
class moLinearCoolingSchedule: public moCoolingSchedule
{
public:
//! Simple constructor
/*!
\param __threshold the threshold.
\param __quantity the quantity used to descrease the temperature.
*/
moLinearCoolingSchedule (double __threshold, double __quantity):threshold (__threshold), quantity (__quantity)
{}
//! Function which proceeds to the cooling.
/*!
It decreases the temperature and indicates if it is greater than the threshold.
\param __temp the current temperature.
\return if the new temperature (current temperature - quantity) is greater than the threshold.
*/
bool operator() (double &__temp)
{
return (__temp -= quantity) > threshold;
}
private:
public:
//! Simple constructor
/*!
\param __threshold the threshold.
\param __quantity the quantity used to descrease the temperature.
*/
moLinearCoolingSchedule (double __threshold, double __quantity):threshold (__threshold), quantity (__quantity)
{}
//! The temperature threhold.
double threshold;
//! Function which proceeds to the cooling.
/*!
It decreases the temperature and indicates if it is greater than the threshold.
//! The quantity that allows the temperature to decrease.
double quantity;
};
\param __temp the current temperature.
\return if the new temperature (current temperature - quantity) is greater than the threshold.
*/
bool operator() (double &__temp)
{
return (__temp -= quantity) > threshold;
}
private:
//! The temperature threhold.
double threshold;
//! The quantity that allows the temperature to decrease.
double quantity;
};
#endif

12
trunk/paradiseo-mo/src/moMove.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moMove.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -46,12 +46,12 @@
It describes how a solution can be modified to another one.
*/
template < class EOT > class moMove:public eoUF < EOT &, void >
{
{
public:
//! Alias for the type
typedef EOT EOType;
public:
//! Alias for the type
typedef EOT EOType;
};
};
#endif

Some files were not shown because too many files have changed in this diff Show more