nojhan/paradiseo
1
0
Fork 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

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

@ -1,4 +1,4 @@
/*
/*
* <moMoveExpl.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,11 +44,9 @@
Only a description...See moMoveLoopExpl.
*/
template < class M > class moMoveExpl:public eoBF < const typename
M::EOType &,
typename
M::EOType &, void >
{
};
M::EOType &,
typename
M::EOType &, void >
{};
#endif

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

@ -1,4 +1,4 @@
/*
/*
* <moMoveIncrEval.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -47,11 +47,9 @@
the solution if this one is updated.
*/
template < class M > class moMoveIncrEval:public eoBF < const M &, const typename
M::EOType &,
typename
M::EOType::Fitness >
{
};
M::EOType &,
typename
M::EOType::Fitness >
{};
#endif

8
trunk/paradiseo-mo/src/moMoveInit.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moMoveInit.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,9 +45,7 @@
Only a description... An object that herits from this class needs to be designed to be used.
*/
template < class M > class moMoveInit:public eoBF < M &, const typename
M::EOType &, void >
{
};
M::EOType &, void >
{};
#endif

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

@ -1,4 +1,4 @@
/*
/*
* <moMoveLoopExpl.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,8 +44,6 @@
Only a description... moHCMoveLoopExpl and moTSMoveLoopExpl are exemples of class that are a moMoveLoopExpl.
*/
template < class M > class moMoveLoopExpl:public moMoveExpl < M >
{
};
{};
#endif

54
trunk/paradiseo-mo/src/moMoveSelect.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moMoveSelect.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,47 +44,45 @@
This class is used as an exception that can be thrown if a solution selector has completly failed.
*/
class EmptySelection
{
};
{};
//! Class that describes a move selector (moMove).
/*!
/*!
It iteratively considers some moves (moMove) and their
associated fitnesses. The best move is so regularly updated.
At any time, it could be accessed.
*/
template < class M > class moMoveSelect:public eoBF < M &, typename M::EOType::Fitness &,
void >
{
public:
//! Alias for the fitness
typedef
void >
{
public:
//! Alias for the fitness
typedef
typename
M::EOType::Fitness
Fitness;
//! Procedure which initialises all that the move selector needs including the initial fitness.
/*!
In order to know the fitness of the solution,
for which the neighborhood will
be soon explored
//! Procedure which initialises all that the move selector needs including the initial fitness.
/*!
In order to know the fitness of the solution,
for which the neighborhood will
be soon explored
\param __fit the current fitness.
*/
virtual void
init (const Fitness & __fit) = 0;
\param __fit the current fitness.
*/
virtual void
init (const Fitness & __fit) = 0;
//! Function which updates the best solutions.
/*!
\param __move a new move.
\param __fit a fitness linked to the new move.
\return a boolean that expresses the need to resume the exploration.
*/
virtual
//! Function which updates the best solutions.
/*!
\param __move a new move.
\param __fit a fitness linked to the new move.
\return a boolean that expresses the need to resume the exploration.
*/
virtual
bool
update (const M & __move, const Fitness & __fit) = 0;
update (const M & __move, const Fitness & __fit) = 0;
};
};
#endif

10
trunk/paradiseo-mo/src/moNextMove.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moNextMove.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,10 +45,8 @@
Does nothing... An object that herits from this class needs to be designed for being used.
*/
template < class M > class moNextMove:public eoBF < M &, const typename
M::EOType &,
bool >
{
};
M::EOType &,
bool >
{};
#endif

45
trunk/paradiseo-mo/src/moNoAspirCrit.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moNoAspirCrit.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,30 +44,29 @@
The simplest : never satisfied.
*/
template < class M > class moNoAspirCrit:public moAspirCrit < M >
{
//! Function which describes the aspiration criterion behaviour
/*!
Does nothing.
\param __move a move.
\param __sol a fitness.
\return FALSE.
*/
bool operator () (const M & __move,
const typename M::EOType::Fitness & __sol)
{
return false;
}
//! Function which describes the aspiration criterion behaviour
/*!
Does nothing.
//! Procedure which initialises all that needs a moNoAspirCrit
/*!
Nothing...
*/
void init ()
{
}
};
\param __move a move.
\param __sol a fitness.
\return FALSE.
*/
bool operator () (const M & __move,
const typename M::EOType::Fitness & __sol)
{
return false;
}
//! Procedure which initialises all that needs a moNoAspirCrit
/*!
Nothing...
*/
void init ()
{}
};
#endif

134
trunk/paradiseo-mo/src/moNoFitImprSolContinue.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moNoFitImprSolContinue.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,80 +44,80 @@
The stop criterion corresponds to a maximum number of iterations without improvement.
*/
template < class EOT > class moNoFitImprSolContinue:public moSolContinue < EOT >
{
public:
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
//! Basic constructor.
/*!
\param __maxNumberOfIterationWithoutImprovement The number of iterations without fitness improvement to reach for stop.
*/
moNoFitImprSolContinue (unsigned int __maxNumberOfIterationWithoutImprovement)
: maxNumberOfIterationsWithoutImprovement(__maxNumberOfIterationWithoutImprovement), firstFitnessSaved(true), counter(0)
{}
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness has not been improved since a given number of iterations (after a minimum of iterations).
\param __sol the current solution.
\return true or false.
*/
bool operator () (const EOT & __sol)
{
if(__sol.invalid())
{
return true;
}
if(firstFitnessSaved)
{
fitness=__sol.fitness();
counter=0;
firstFitnessSaved=false;
return true;
}
counter++;
public:
if( __sol.fitness() > fitness)
{
fitness=__sol.fitness();
counter=0;
}
if(counter==maxNumberOfIterationsWithoutImprovement)
{
std::cout << "moNoFitImrpSolContinue: Done [" << counter << "] iterations without improvement." << std::endl;
}
return counter!=maxNumberOfIterationsWithoutImprovement;
}
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
//! Procedure which allows to initialise all the stuff needed.
/*!
It can be also used to reinitialize all the needed things.
*/
void init ()
{
firstFitnessSaved=true;
counter=0;
}
//! Basic constructor.
/*!
\param __maxNumberOfIterationWithoutImprovement The number of iterations without fitness improvement to reach for stop.
*/
moNoFitImprSolContinue (unsigned int __maxNumberOfIterationWithoutImprovement)
: maxNumberOfIterationsWithoutImprovement(__maxNumberOfIterationWithoutImprovement), firstFitnessSaved(true), counter(0)
{}
private:
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness has not been improved since a given number of iterations (after a minimum of iterations).
\param __sol the current solution.
\return true or false.
*/
bool operator () (const EOT & __sol)
{
if (__sol.invalid())
{
return true;
}
//! Maximum number of iterations without improvement allowed.
unsigned int maxNumberOfIterationsWithoutImprovement;
if (firstFitnessSaved)
{
fitness=__sol.fitness();
counter=0;
firstFitnessSaved=false;
return true;
}
//! Flag that this is the first time that the fitness is used.
bool firstFitnessSaved;
counter++;
//! Current Fitness.
Fitness fitness;
if ( __sol.fitness() > fitness)
{
fitness=__sol.fitness();
counter=0;
}
//! The iteration couter.
unsigned int counter;
};
if (counter==maxNumberOfIterationsWithoutImprovement)
{
std::cout << "moNoFitImrpSolContinue: Done [" << counter << "] iterations without improvement." << std::endl;
}
return counter!=maxNumberOfIterationsWithoutImprovement;
}
//! Procedure which allows to initialise all the stuff needed.
/*!
It can be also used to reinitialize all the needed things.
*/
void init ()
{
firstFitnessSaved=true;
counter=0;
}
private:
//! Maximum number of iterations without improvement allowed.
unsigned int maxNumberOfIterationsWithoutImprovement;
//! Flag that this is the first time that the fitness is used.
bool firstFitnessSaved;
//! Current Fitness.
Fitness fitness;
//! The iteration couter.
unsigned int counter;
};
#endif

132
trunk/paradiseo-mo/src/moRandImprSelect.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moRandImprSelect.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,86 +44,86 @@
//! One of the possible moMove selector (moMoveSelect)
/*!
All the neighbors are considered.
All the neighbors are considered.
One of them that enables an improvment of the objective function is choosen.
*/
template < class M > class moRandImprSelect:public moMoveSelect < M >
{
public:
//! Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
//!Procedure which all that needs a moRandImprSelect
/*!
Give a value to the initialise fitness.
Clean the move and fitness vectors.
\param __fit the current best fitness
*/
void init (const Fitness & __fit)
{
init_fit = __fit;
vect_better_fit.clear ();
vect_better_moves.clear ();
}
//! Function that updates the fitness and move vectors
/*!
if a move give a better fitness than the initial fitness,
it is saved and the fitness too.
\param __move a new move.
\param __fit a new fitness associated to the new move.
\return TRUE.
*/
bool update (const M & __move, const Fitness & __fit)
{
if (__fit > init_fit)
{
public:
vect_better_fit.push_back (__fit);
vect_better_moves.push_back (__move);
}
//! Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
return true;
}
//!Procedure which all that needs a moRandImprSelect
/*!
Give a value to the initialise fitness.
Clean the move and fitness vectors.
//! The move selection
/*!
One the saved move is randomly chosen.
\param __fit the current best fitness
*/
void init (const Fitness & __fit)
{
init_fit = __fit;
vect_better_fit.clear ();
vect_better_moves.clear ();
}
\param __move the reference of the move that can be initialised by the function.
\param __fit the reference of the fitness that can be initialised by the function.
\throws EmptySelection If no move which improves the current fitness are found.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
//! Function that updates the fitness and move vectors
/*!
if a move give a better fitness than the initial fitness,
it is saved and the fitness too.
if (!vect_better_fit.empty ())
{
\param __move a new move.
\param __fit a new fitness associated to the new move.
\return TRUE.
*/
bool update (const M & __move, const Fitness & __fit)
{
unsigned n = rng.random (vect_better_fit.size ());
if (__fit > init_fit)
{
__move = vect_better_moves[n];
__fit = vect_better_fit[n];
}
else
throw EmptySelection ();
}
vect_better_fit.push_back (__fit);
vect_better_moves.push_back (__move);
}
private:
return true;
}
//! Fitness of the current solution.
Fitness init_fit;
//! The move selection
/*!
One the saved move is randomly chosen.
//! Candidate fitnesse vector.
std::vector < Fitness > vect_better_fit;
\param __move the reference of the move that can be initialised by the function.
\param __fit the reference of the fitness that can be initialised by the function.
\throws EmptySelection If no move which improves the current fitness are found.
*/
void operator () (M & __move, Fitness & __fit) throw (EmptySelection)
{
//! Candidate move vector.
std::vector < M > vect_better_moves;
};
if (!vect_better_fit.empty ())
{
unsigned n = rng.random (vect_better_fit.size ());
__move = vect_better_moves[n];
__fit = vect_better_fit[n];
}
else
throw EmptySelection ();
}
private:
//! Fitness of the current solution.
Fitness init_fit;
//! Candidate fitnesse vector.
std::vector < Fitness > vect_better_fit;
//! Candidate move vector.
std::vector < M > vect_better_moves;
};
#endif

8
trunk/paradiseo-mo/src/moRandMove.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moRandMove.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,11 +41,9 @@
//! Random move generator
/*!
Only a description... An object that herits from this class needs to be designed in order to use a moSA.
Only a description... An object that herits from this class needs to be designed in order to use a moSA.
*/
template < class M > class moRandMove:public eoUF < M &, void >
{
};
{};
#endif

164
trunk/paradiseo-mo/src/moSA.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moSA.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -53,122 +53,120 @@
Class that describes a Simulated Annealing algorithm.
*/
template < class M > class moSA: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:
//! SA constructor
/*!
All the boxes used by a SA need to be given.
//! SA constructor
/*!
All the boxes used by a SA need to be given.
\param __move_rand a move generator (generally randomly).
\param __incr_eval a (generaly) efficient evaluation function
\param __cont a stopping criterion.
\param __init_temp the initial temperature.
\param __cool_sched a cooling schedule, describes how the temperature is modified.
\param __full_eval a full evaluation function.
*/
moSA (moRandMove < M > &__move_rand,
moMoveIncrEval < M > &__incr_eval,
moSolContinue < EOT > &__cont,
double __init_temp,
moCoolingSchedule & __cool_sched, eoEvalFunc < EOT > &__full_eval):
move_rand (__move_rand),
incr_eval (__incr_eval),
cont (__cont),
init_temp (__init_temp),
cool_sched (__cool_sched),
full_eval (__full_eval)
{
\param __move_rand a move generator (generally randomly).
\param __incr_eval a (generaly) efficient evaluation function
\param __cont a stopping criterion.
\param __init_temp the initial temperature.
\param __cool_sched a cooling schedule, describes how the temperature is modified.
\param __full_eval a full evaluation function.
*/
moSA (moRandMove < M > &__move_rand,
moMoveIncrEval < M > &__incr_eval,
moSolContinue < EOT > &__cont,
double __init_temp,
moCoolingSchedule & __cool_sched, eoEvalFunc < EOT > &__full_eval):
move_rand (__move_rand),
incr_eval (__incr_eval),
cont (__cont),
init_temp (__init_temp),
cool_sched (__cool_sched),
full_eval (__full_eval)
{}
}
//! function that launches the SA algorithm.
/*!
As a moTS or a moHC, the SA can be used for HYBRIDATION in an evolutionary algorithm.
//! function that launches the SA algorithm.
/*!
As a moTS or a moHC, the SA can be used for HYBRIDATION in an evolutionary algorithm.
\param __sol a solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
\param __sol a solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
if (__sol.invalid ())
{
full_eval (__sol);
}
if (__sol.invalid ())
{
full_eval (__sol);
}
double temp = init_temp;
double temp = init_temp;
M move;
M move;
EOT best_sol = __sol;
EOT best_sol = __sol;
do
{
do
{
cont.init ();
do
{
cont.init ();
do
{
move_rand (move);
move_rand (move);
Fitness delta_fit = incr_eval (move, __sol) - __sol.fitness ();
Fitness delta_fit = incr_eval (move, __sol) - __sol.fitness ();
if (delta_fit > 0 || rng.uniform () < exp (delta_fit / temp))
{
if (delta_fit > 0 || rng.uniform () < exp (delta_fit / temp))
{
__sol.fitness (incr_eval (move, __sol));
move (__sol);
__sol.fitness (incr_eval (move, __sol));
move (__sol);
/* Updating the best solution found
until now ? */
if (__sol.fitness () > best_sol.fitness ())
best_sol = __sol;
}
/* Updating the best solution found
until now ? */
if (__sol.fitness () > best_sol.fitness ())
best_sol = __sol;
}
}
while (cont (__sol));
}
while (cont (__sol));
}
while (cool_sched (temp));
}
while (cool_sched (temp));
__sol = best_sol;
__sol = best_sol;
return true;
}
return true;
}
private:
private:
//! A move generator (generally randomly)
moRandMove < M > &move_rand;
//! A move generator (generally randomly)
moRandMove < M > &move_rand;
//! A (generally) efficient evaluation function.
moMoveIncrEval < M > &incr_eval;
//! A (generally) efficient evaluation function.
moMoveIncrEval < M > &incr_eval;
//! Stopping criterion before temperature update
moSolContinue < EOT > &cont;
//! Stopping criterion before temperature update
moSolContinue < EOT > &cont;
//! Initial temperature
double init_temp;
//! Initial temperature
double init_temp;
//! The cooling schedule
moCoolingSchedule & cool_sched;
//! The cooling schedule
moCoolingSchedule & cool_sched;
//! A full evaluation function.
eoEvalFunc < EOT > &full_eval; // Full evaluator.
};
//! A full evaluation function.
eoEvalFunc < EOT > &full_eval; // Full evaluator.
};
#endif

186
trunk/paradiseo-mo/src/moSimpleMoveTabuList.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moSimpleMoveTabuList.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,107 +45,107 @@
//! Class describing a move tabu list with a limited memory.
template <class M>
class moSimpleMoveTabuList: public moTabuList < M >
{
public:
//! Alias for the type
typedef typename M::EOType EOT;
{
//! Constructor
/*
\param __size The maximum size of the move tabu list.
*/
moSimpleMoveTabuList(unsigned int __size): maxSize(__size)
{
currentSize=0;
}
public:
//! Function that indicates if, in a given state, the _move is tabu or not.
/*!
\param __move A given moMove.
\param __sol A solution.
\return true or false.
*/
bool
operator () (const M & __move, const EOT & __sol)
{
typename std::list<M>::iterator it;
it=tabuList.begin();
while(it!=tabuList.end()&&(!((*it)==__move)))
//! Alias for the type
typedef typename M::EOType EOT;
//! Constructor
/*
\param __size The maximum size of the move tabu list.
*/
moSimpleMoveTabuList(unsigned int __size): maxSize(__size)
{
currentSize=0;
}
//! Function that indicates if, in a given state, the _move is tabu or not.
/*!
\param __move A given moMove.
\param __sol A solution.
\return true or false.
*/
bool
operator () (const M & __move, const EOT & __sol)
{
typename std::list<M>::iterator it;
it=tabuList.begin();
while (it!=tabuList.end()&&(!((*it)==__move)))
{
it++;
}
return it!=tabuList.end();
}
void
add (const M & __move, const EOT & __sol)
{
it++;
}
return it!=tabuList.end();
}
void
add (const M & __move, const EOT & __sol)
{
if(currentSize!=0)
{
// Useful in the case of a move has been kept thanks to the moAspirCrit.
// In this case, the move can already be in the tabuList.
removeMove(__move);
if (currentSize!=0)
{
// Useful in the case of a move has been kept thanks to the moAspirCrit.
// In this case, the move can already be in the tabuList.
removeMove(__move);
}
tabuList.push_back(__move);
if (currentSize==maxSize)
{
tabuList.erase(tabuList.begin());
}
else
{
currentSize++;
}
}
tabuList.push_back(__move);
if(currentSize==maxSize)
{
tabuList.erase(tabuList.begin());
}
else
{
currentSize++;
}
}
void
update ()
{
//nothing to do
}
void
update ()
{
//nothing to do
}
void
init ()
{
//nothing to do
}
void
init ()
{
//nothing to do
}
private:
//! Procedure that removes a given move from the tabu list (if it is into, else do nothing).
/*!
\param __move A given moMove.
*/
void
removeMove(const M & __move)
{
typename std::list<M>::iterator it;
it=tabuList.begin();
while(it!=tabuList.end()&&(!((*it)==__move)))
{
it++;
}
private:
if(it!=tabuList.end())
{
tabuList.erase(it);
}
}
//! Procedure that removes a given move from the tabu list (if it is into, else do nothing).
/*!
\param __move A given moMove.
*/
void
removeMove(const M & __move)
{
typename std::list<M>::iterator it;
//! The maximum size of the tabu list.
unsigned int maxSize;
it=tabuList.begin();
while (it!=tabuList.end()&&(!((*it)==__move)))
{
it++;
}
//! The current size of the tabu list.
unsigned int currentSize;
//! The move tabu list.
std::list<M> tabuList;
};
if (it!=tabuList.end())
{
tabuList.erase(it);
}
}
//! The maximum size of the tabu list.
unsigned int maxSize;
//! The current size of the tabu list.
unsigned int currentSize;
//! The move tabu list.
std::list<M> tabuList;
};
#endif

204
trunk/paradiseo-mo/src/moSimpleSolutionTabuList.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moSimpleSolutionTabuList.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,116 +45,116 @@
//! Class describing a solution tabu list with limited length.
template <class M>
class moSimpleSolutionTabuList: public moTabuList < M >
{
public:
//! Alias for the type
typedef typename M::EOType EOT;
//! Constructor
/*!
\param __size The maximum size of the solution tabu list.
*/
moSimpleSolutionTabuList(unsigned int __size): maxSize(__size)
{
currentSize=0;
}
//! Function that indicates if, in a given state, the _move is tabu or not.
/*!
\param __move A given moMove.
\param __sol A solution.
\return true or false.
*/
bool operator () (const M & __move, const EOT & __sol)
{
typename std::list<EOT>::iterator it;
M _move=(M)__move;
EOT _sol=(EOT) __sol;
_move(_sol);
it=tabuList.begin();
while(it!=tabuList.end()&&(!((*it)==_sol)))
public:
//! Alias for the type
typedef typename M::EOType EOT;
//! Constructor
/*!
\param __size The maximum size of the solution tabu list.
*/
moSimpleSolutionTabuList(unsigned int __size): maxSize(__size)
{
currentSize=0;
}
//! Function that indicates if, in a given state, the _move is tabu or not.
/*!
\param __move A given moMove.
\param __sol A solution.
\return true or false.
*/
bool operator () (const M & __move, const EOT & __sol)
{
typename std::list<EOT>::iterator it;
M _move=(M)__move;
EOT _sol=(EOT) __sol;
_move(_sol);
it=tabuList.begin();
while (it!=tabuList.end()&&(!((*it)==_sol)))
{
it++;
}
return it!=tabuList.end();
}
void
add (const M & __move, const EOT & __sol)
{
it++;
}
return it!=tabuList.end();
}
void
add (const M & __move, const EOT & __sol)
{
M _move=(M)__move;
EOT _sol=(EOT) _sol;
_move(_sol);
M _move=(M)__move;
EOT _sol=(EOT) _sol;
if(currentSize!=0)
{
// Useful in the case of a solution has been kept thanks to the moAspirCrit.
// In this case, the solution can already be in the tabuList.
removeSolution(_sol);
}
tabuList.push_back(_sol);
if(currentSize==maxSize)
{
tabuList.erase(tabuList.begin());
}
else
{
currentSize++;
}
}
_move(_sol);
void
update ()
{
//nothing to do
}
if (currentSize!=0)
{
// Useful in the case of a solution has been kept thanks to the moAspirCrit.
// In this case, the solution can already be in the tabuList.
removeSolution(_sol);
}
void
init ()
{
//nothing to do
}
tabuList.push_back(_sol);
private:
//! Procedure that removes a given solution from the tabu list (if it is into, else does nothing).
/*!
\param __sol A given solution.
*/
void
removeSolution(const EOT & __sol)
{
typename std::list<EOT>::iterator it;
it=tabuList.begin();
while(it!=tabuList.end()&&(!((*it)==__sol)))
{
it++;
if (currentSize==maxSize)
{
tabuList.erase(tabuList.begin());
}
else
{
currentSize++;
}
}
if(it!=tabuList.end())
{
tabuList.erase(it);
}
}
//! The maximum size of the tabu list.
unsigned int maxSize;
void
update ()
{
//nothing to do
}
//! The current size of the tabu list.
unsigned int currentSize;
//! The solution tabu list.
std::list<EOT> tabuList;
};
void
init ()
{
//nothing to do
}
private:
//! Procedure that removes a given solution from the tabu list (if it is into, else does nothing).
/*!
\param __sol A given solution.
*/
void
removeSolution(const EOT & __sol)
{
typename std::list<EOT>::iterator it;
it=tabuList.begin();
while (it!=tabuList.end()&&(!((*it)==__sol)))
{
it++;
}
if (it!=tabuList.end())
{
tabuList.erase(it);
}
}
//! The maximum size of the tabu list.
unsigned int maxSize;
//! The current size of the tabu list.
unsigned int currentSize;
//! The solution tabu list.
std::list<EOT> tabuList;
};
#endif

20
trunk/paradiseo-mo/src/moSolContinue.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moSolContinue.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,18 +41,18 @@
//! Class that describes a stop criterion for a solution-based heuristic
/*!
/*!
It allows to add an initialisation procedure to an object that is a unary function (eoUF).
*/
template < class EOT > class moSolContinue:public eoUF < const EOT &, bool >
{
{
public:
//! Procedure which initialises all that the stop criterion needs
/*!
Generally, it allocates some data structures or initialises some counters.
*/
virtual void init () = 0;
};
public:
//! Procedure which initialises all that the stop criterion needs
/*!
Generally, it allocates some data structures or initialises some counters.
*/
virtual void init () = 0;
};
#endif

168
trunk/paradiseo-mo/src/moSteadyFitSolContinue.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moSteadyFitSolContinue.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,100 +44,100 @@
The stop criterion corresponds to a maximum number of iterations without improvement (after a minimum number of iterations).
*/
template < class EOT > class moSteadyFitSolContinue:public moSolContinue < EOT >
{
public:
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
//! Basic constructor.
/*!
\param __maxNumberOfIterations The number of iterations to reach before looking for the fitness.
\param __maxNumberOfIterationWithoutImprovement The number of iterations without fitness improvement to reach for stop.
*/
moSteadyFitSolContinue (unsigned int __maxNumberOfIterations, unsigned int __maxNumberOfIterationWithoutImprovement)
: maxNumberOfIterations (__maxNumberOfIterations), maxNumberOfIterationsWithoutImprovement(__maxNumberOfIterationWithoutImprovement),
maxNumberOfIterationsReached(false), firstFitnessSaved(true), counter(0)
{}
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness has not been improved since a number of iterations (after a minimum of iterations).
\param __sol the current solution.
\return true or false.
*/
bool operator () (const EOT & __sol)
{
if(!maxNumberOfIterationsReached)
{
maxNumberOfIterationsReached=((++counter)==maxNumberOfIterations);
if(maxNumberOfIterationsReached)
{
std::cout << "moSteadyFitSolContinue: Done the minimum number of iterations [" << counter << "]." << std::endl;
}
return true;
}
if(__sol.invalid())
{
return true;
}
public:
if(firstFitnessSaved)
{
fitness=__sol.fitness();
counter=0;
firstFitnessSaved=false;
return true;
}
counter++;
//! Alias for the fitness.
typedef typename EOT::Fitness Fitness;
if( __sol.fitness() > fitness )
{
fitness=__sol.fitness();
counter=0;
}
if(counter==maxNumberOfIterationsWithoutImprovement)
{
std::cout << "moSteadyFitSolContinue: Done [" << counter << "] iterations without improvement." << std::endl;
}
return counter!=maxNumberOfIterationsWithoutImprovement;
}
//! Basic constructor.
/*!
\param __maxNumberOfIterations The number of iterations to reach before looking for the fitness.
\param __maxNumberOfIterationWithoutImprovement The number of iterations without fitness improvement to reach for stop.
*/
moSteadyFitSolContinue (unsigned int __maxNumberOfIterations, unsigned int __maxNumberOfIterationWithoutImprovement)
: maxNumberOfIterations (__maxNumberOfIterations), maxNumberOfIterationsWithoutImprovement(__maxNumberOfIterationWithoutImprovement),
maxNumberOfIterationsReached(false), firstFitnessSaved(true), counter(0)
{}
//! Procedure which allows to initialise the stuff needed.
/*!
It can be also used to reinitialize the counter all the needed things.
*/
void init ()
{
maxNumberOfIterationsReached=false;
counter=0;
firstFitnessSaved=true;
}
//! Function that activates the stopping criterion.
/*!
Indicates if the fitness has not been improved since a number of iterations (after a minimum of iterations).
private:
\param __sol the current solution.
\return true or false.
*/
bool operator () (const EOT & __sol)
{
if (!maxNumberOfIterationsReached)
{
maxNumberOfIterationsReached=((++counter)==maxNumberOfIterations);
if (maxNumberOfIterationsReached)
{
std::cout << "moSteadyFitSolContinue: Done the minimum number of iterations [" << counter << "]." << std::endl;
}
return true;
}
//! Maximum number of iterations before considering the fitness.
unsigned int maxNumberOfIterations;
if (__sol.invalid())
{
return true;
}
//! Maximum number of iterations without improvement allowed.
unsigned int maxNumberOfIterationsWithoutImprovement;
if (firstFitnessSaved)
{
fitness=__sol.fitness();
counter=0;
firstFitnessSaved=false;
return true;
}
//! Flag that indicates that the maxNumberIteration have been reached.
bool maxNumberOfIterationsReached;
counter++;
//! Flag that this is the first time that the fitness is used.
bool firstFitnessSaved;
if ( __sol.fitness() > fitness )
{
fitness=__sol.fitness();
counter=0;
}
//! Current Fitness.
Fitness fitness;
if (counter==maxNumberOfIterationsWithoutImprovement)
{
std::cout << "moSteadyFitSolContinue: Done [" << counter << "] iterations without improvement." << std::endl;
}
return counter!=maxNumberOfIterationsWithoutImprovement;
}
//! The iteration couter.
unsigned int counter;
};
//! Procedure which allows to initialise the stuff needed.
/*!
It can be also used to reinitialize the counter all the needed things.
*/
void init ()
{
maxNumberOfIterationsReached=false;
counter=0;
firstFitnessSaved=true;
}
private:
//! Maximum number of iterations before considering the fitness.
unsigned int maxNumberOfIterations;
//! Maximum number of iterations without improvement allowed.
unsigned int maxNumberOfIterationsWithoutImprovement;
//! Flag that indicates that the maxNumberIteration have been reached.
bool maxNumberOfIterationsReached;
//! Flag that this is the first time that the fitness is used.
bool firstFitnessSaved;
//! Current Fitness.
Fitness fitness;
//! The iteration couter.
unsigned int counter;
};
#endif

166
trunk/paradiseo-mo/src/moTS.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moTS.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -52,118 +52,118 @@
Generic algorithm that describes a tabu search.
*/
template < class M > class moTS: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:
//!Constructor of a moTS specifying all the boxes
/*!
In this constructor, a moTSMoveLoopExpl is instanciated.
//!Constructor of a moTS specifying all the boxes
/*!
In this constructor, a moTSMoveLoopExpl is instanciated.
\param __move_init move initialisation
\param __next_move neighborhood explorer
\param __incr_eval efficient evaluation
\param __tabu_list tabu list
\param __aspir_crit aspiration criterion
\param __cont stop criterion
\param __full_eval full evaluation function
*/
moTS (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moTabuList < M > &__tabu_list, moAspirCrit < M > &__aspir_crit, moSolContinue < EOT > &__cont, eoEvalFunc < EOT > &__full_eval):move_expl (*new moTSMoveLoopExpl < M >
(__move_init, __next_move, __incr_eval, __tabu_list,
__aspir_crit)), cont (__cont), full_eval (__full_eval)
{}
//! Constructor with less parameters
/*!
The explorer is given in the parameters.
\param __move_expl the explorer (generally different that a moTSMoveLoopExpl)
\param __cont stop criterion
\param __full_eval full evaluation function
*/
moTS (moMoveExpl < M > &__move_expl, moSolContinue < EOT > &__cont, eoEvalFunc < EOT > &__full_eval):move_expl (__move_expl),
cont (__cont),
full_eval (__full_eval)
\param __move_init move initialisation
\param __next_move neighborhood explorer
\param __incr_eval efficient evaluation
\param __tabu_list tabu list
\param __aspir_crit aspiration criterion
\param __cont stop criterion
\param __full_eval full evaluation function
*/
moTS (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moTabuList < M > &__tabu_list, moAspirCrit < M > &__aspir_crit, moSolContinue < EOT > &__cont, eoEvalFunc < EOT > &__full_eval):move_expl (*new moTSMoveLoopExpl < M >
(__move_init, __next_move, __incr_eval, __tabu_list,
__aspir_crit)), cont (__cont), full_eval (__full_eval)
{}
//! Function which launchs the Tabu Search
/*!
Algorithm of the tabu search.
As a moSA or a moHC, it can be used for HYBRIDATION in an evolutionary algorithm.
For security a lock (pthread_mutex_t) is closed during the algorithm.
//! Constructor with less parameters
/*!
The explorer is given in the parameters.
\param __sol a solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
if (__sol.invalid ())
{
full_eval (__sol);
}
\param __move_expl the explorer (generally different that a moTSMoveLoopExpl)
\param __cont stop criterion
\param __full_eval full evaluation function
*/
moTS (moMoveExpl < M > &__move_expl, moSolContinue < EOT > &__cont, eoEvalFunc < EOT > &__full_eval):move_expl (__move_expl),
cont (__cont),
full_eval (__full_eval)
{}
M move;
//! Function which launchs the Tabu Search
/*!
Algorithm of the tabu search.
As a moSA or a moHC, it can be used for HYBRIDATION in an evolutionary algorithm.
For security a lock (pthread_mutex_t) is closed during the algorithm.
EOT best_sol = __sol, new_sol;
\param __sol a solution to improve.
\return TRUE.
*/
bool operator ()(EOT & __sol)
{
if (__sol.invalid ())
{
full_eval (__sol);
}
cont.init ();
M move;
do
{
EOT best_sol = __sol, new_sol;
new_sol = __sol;
cont.init ();
try
{
do
{
move_expl (__sol, new_sol);
new_sol = __sol;
}
catch (EmptySelection & __ex)
{
try
{
break;
}
move_expl (__sol, new_sol);
/* Updating the best solution
found until now ? */
if (new_sol.fitness () > __sol.fitness ())
{
best_sol = new_sol;
}
}
catch (EmptySelection & __ex)
{
__sol = new_sol;
break;
}
}
while (cont (__sol));
/* Updating the best solution
found until now ? */
if (new_sol.fitness () > __sol.fitness ())
{
best_sol = new_sol;
}
__sol = best_sol;
return true;
}
__sol = new_sol;
private:
}
while (cont (__sol));
//! Neighborhood explorer
moMoveExpl < M > &move_expl;
__sol = best_sol;
//! Stop criterion
moSolContinue < EOT > &cont;
return true;
}
//! Full evaluation function
eoEvalFunc < EOT > &full_eval;
};
private:
//! Neighborhood explorer
moMoveExpl < M > &move_expl;
//! Stop criterion
moSolContinue < EOT > &cont;
//! Full evaluation function
eoEvalFunc < EOT > &full_eval;
};
#endif

152
trunk/paradiseo-mo/src/moTSMoveLoopExpl.h
View file

@ -1,4 +1,4 @@
/*
/*
* <moTSMoveLoopExpl.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -53,105 +53,105 @@
It is used by a moTS.
*/
template < class M > class moTSMoveLoopExpl:public moMoveLoopExpl < M >
{
//!Alias for the type
typedef typename M::EOType EOT;
//!Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
public:
//!Constructor
/*!
\param __move_init move initialisation
\param __next_move neighborhood explorer
\param __incr_eval efficient evaluation
\param __tabu_list tabu list
\param __aspir_crit aspiration criterion
*/
moTSMoveLoopExpl (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moTabuList < M > &__tabu_list, moAspirCrit < M > &__aspir_crit):
move_init (__move_init),
next_move (__next_move),
incr_eval (__incr_eval),
tabu_list (__tabu_list), aspir_crit (__aspir_crit)
{
tabu_list.init ();
aspir_crit.init ();
}
//!Alias for the type
typedef typename M::EOType EOT;
//!Procedure which lauches the exploration
/*!
The exploration continues while the chosen move is not in the tabu list
or the aspiration criterion is true. If these 2 conditions are not true, the
exploration stops if the move selector update function returns false.
//!Alias for the fitness
typedef typename M::EOType::Fitness Fitness;
\param __old_sol the initial solution
\param __new_sol the new solution
*/
void operator () (const EOT & __old_sol, EOT & __new_sol)
{
public:
M move;
//!Constructor
/*!
\param __move_init move initialisation
\param __next_move neighborhood explorer
\param __incr_eval efficient evaluation
\param __tabu_list tabu list
\param __aspir_crit aspiration criterion
*/
moTSMoveLoopExpl (moMoveInit < M > &__move_init, moNextMove < M > &__next_move, moMoveIncrEval < M > &__incr_eval, moTabuList < M > &__tabu_list, moAspirCrit < M > &__aspir_crit):
move_init (__move_init),
next_move (__next_move),
incr_eval (__incr_eval),
tabu_list (__tabu_list), aspir_crit (__aspir_crit)
{
tabu_list.init ();
aspir_crit.init ();
}
//!Procedure which lauches the exploration
/*!
The exploration continues while the chosen move is not in the tabu list
or the aspiration criterion is true. If these 2 conditions are not true, the
exploration stops if the move selector update function returns false.
\param __old_sol the initial solution
\param __new_sol the new solution
*/
void operator () (const EOT & __old_sol, EOT & __new_sol)
{
M move;
move_init (move, __old_sol); /* Restarting the exploration of
of the neighborhood ! */
move_init (move, __old_sol); /* Restarting the exploration of
of the neighborhood ! */
move_select.init (__old_sol.fitness ());
move_select.init (__old_sol.fitness ());
do
{
do
{
Fitness fit = incr_eval (move, __old_sol);
Fitness fit = incr_eval (move, __old_sol);
if (!tabu_list (move, __old_sol) || aspir_crit (move, fit))
{
if (!move_select.update (move, fit))
break;
}
if (!tabu_list (move, __old_sol) || aspir_crit (move, fit))
{
if (!move_select.update (move, fit))
break;
}
}
while (next_move (move, __old_sol));
}
while (next_move (move, __old_sol));
M best_move;
M best_move;
Fitness best_move_fit;
Fitness best_move_fit;
move_select (best_move, best_move_fit);
move_select (best_move, best_move_fit);
__new_sol.fitness (best_move_fit);
best_move (__new_sol);
__new_sol.fitness (best_move_fit);
best_move (__new_sol);
/* Removing moves that are
no more tabu */
tabu_list.update ();
/* Removing moves that are
no more tabu */
tabu_list.update ();
// Updating the tabu list
tabu_list.add (best_move, __new_sol);
}
// Updating the tabu list
tabu_list.add (best_move, __new_sol);
}
private:
private:
//!Move initialisation
moMoveInit < M > &move_init;
//!Move initialisation
moMoveInit < M > &move_init;
//!Neighborhood explorer
moNextMove < M > &next_move;
//!Neighborhood explorer
moNextMove < M > &next_move;
//!Efficient evaluation
moMoveIncrEval < M > &incr_eval;
//!Efficient evaluation
moMoveIncrEval < M > &incr_eval;
//!Move selector
moBestImprSelect < M > move_select;
//!Move selector
moBestImprSelect < M > move_select;
//!Tabu list
moTabuList < M > &tabu_list;
//!Tabu list
moTabuList < M > &tabu_list;
//!Aspiration criterion
moAspirCrit < M > &aspir_crit;
};
//!Aspiration criterion
moAspirCrit < M > &aspir_crit;
};
#endif

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

@ -1,4 +1,4 @@
/*
/*
* <moTabuList.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,37 +45,37 @@
to be used in a moTS.
*/
template < class M > class moTabuList:public eoBF < const M &, const typename
M::EOType &,
bool >
{
M::EOType &,
bool >
{
public:
//! Alias for the type
typedef typename M::EOType EOT;
public:
//! Alias for the type
typedef typename M::EOType EOT;
//! Procedure to add a move in the tabu list
/*!
The two parameters have not to be modified so they are constant parameters.
//! Procedure to add a move in the tabu list
/*!
The two parameters have not to be modified so they are constant parameters.
\param __move a new tabu move.
\param __sol the origianl solution associated to this move.
*/
virtual void
add (const M & __move, const EOT & __sol) = 0;
\param __move a new tabu move.
\param __sol the origianl solution associated to this move.
*/
virtual void
add (const M & __move, const EOT & __sol) = 0;
//! Procedure that updates the tabu list content.
/*!
Generally, a counter associated to each saved move is decreased by one.
*/
virtual void
update () = 0;
//! Procedure that updates the tabu list content.
/*!
Generally, a counter associated to each saved move is decreased by one.
*/
virtual void
update () = 0;
//! Procedure which initialises the tabu list.
/*!
Can be useful if the data structure needs to be allocated before being used.
*/
virtual void
init () = 0;
};
//! Procedure which initialises the tabu list.
/*!
Can be useful if the data structure needs to be allocated before being used.
*/
virtual void
init () = 0;
};
#endif

4
trunk/paradiseo-mo/test/t-mo.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <t-mo.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -51,7 +51,7 @@ int main()
Chrom chrom1, chrom2;
std::cout << "chrom1 = " << chrom1 << std::endl
<< "chrom2 = " << chrom2 << std::endl;
<< "chrom2 = " << chrom2 << std::endl;
return 0;
}

27
trunk/paradiseo-mo/tutorial/Lesson1/hill_climbing.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <hill_climbing.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,37 +38,38 @@
#include <tsp>
int
main (int __argc, char * __argv [])
main (int __argc, char * __argv [])
{
if (__argc != 2) {
std :: cerr << "Usage : ./hill_climbing [instance]" << std :: endl ;
return 1 ;
}
if (__argc != 2)
{
std :: cerr << "Usage : ./hill_climbing [instance]" << std :: endl ;
return 1 ;
}
srand (1000) ;
Graph :: load (__argv [1]) ; // Instance
Route route ; // Solution
RouteInit init ; // Sol. Random Init.
init (route) ;
RouteEval full_eval ; // Full. Eval.
full_eval (route) ;
std :: cout << "[From] " << route << std :: endl ;
/* Tools for an efficient (? :-))
local search ! */
TwoOptInit two_opt_init ; // Init.
TwoOptNext two_opt_next ; // Explorer.
TwoOptIncrEval two_opt_incr_eval ; // Eff. eval.
//moFirstImprSelect <TwoOpt> two_opt_select ;
moBestImprSelect <TwoOpt> two_opt_select ;
//moRandImprSelect <TwoOpt> two_opt_select ;

26
trunk/paradiseo-mo/tutorial/Lesson2/tabu_search.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <tabu_search.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,33 +38,33 @@
#include <tsp>
int
main (int __argc, char * __argv [])
main (int __argc, char * __argv [])
{
if (__argc != 2)
if (__argc != 2)
{
std :: cerr << "Usage : ./tabu_search [instance]" << std :: endl ;
return 1 ;
}
Graph :: load (__argv [1]) ; // Instance
Route route ; // Solution
RouteInit init ; // Sol. Random Init.
init (route) ;
RouteEval full_eval ; // Full. Eval.
full_eval (route) ;
std :: cout << "[From] " << route << std :: endl ;
/* Tools for an efficient (? :-))
local search ! */
TwoOptInit two_opt_init ; // Init.
TwoOptNext two_opt_next ; // Explorer.
TwoOptIncrEval two_opt_incr_eval ; // Eff. eval.
TwoOptTabuList tabu_list ; // Tabu List
@ -77,9 +77,9 @@ main (int __argc, char * __argv [])
moTS <TwoOpt> tabu_search (two_opt_init, two_opt_next, two_opt_incr_eval, tabu_list, aspir_crit, cont, full_eval) ;
tabu_search (route) ;
std :: cout << "[To] " << route << std :: endl ;
return 0 ;
}

36
trunk/paradiseo-mo/tutorial/Lesson3/simulated_annealing.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <simulated_annealing.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,47 +38,47 @@
#include <tsp>
int
main (int __argc, char * __argv [])
main (int __argc, char * __argv [])
{
if (__argc != 2)
if (__argc != 2)
{
std :: cerr << "Usage : ./simulated_annealing [instance]" << std :: endl ;
return 1 ;
}
Graph :: load (__argv [1]) ; // Instance
Route route ; // Solution
RouteInit init ; // Sol. Random Init.
init (route) ;
RouteEval full_eval ; // Full. Eval.
full_eval (route) ;
std :: cout << "[From] " << route << std :: endl ;
/* Tools for an efficient (? :-))
local search ! */
TwoOptRand two_opt_rand ; // Route Random. Gen.
TwoOptIncrEval two_opt_incr_eval ; // Eff. eval.
TwoOpt move ;
moExponentialCoolingSchedule cool_sched (0.1, 0.98) ; // Exponential Cooling Schedule
//moLinearCoolingSchedule cool_sched (0.1, 0.5) ; // Linear Cooling Schedule
moExponentialCoolingSchedule cool_sched (0.1, 0.98) ; // Exponential Cooling Schedule
//moLinearCoolingSchedule cool_sched (0.1, 0.5) ; // Linear Cooling Schedule
moGenSolContinue <Route> cont (1000) ; /* Temperature Descreasing
will occur each 1000
iterations */
will occur each 1000
iterations */
moSA <TwoOpt> simulated_annealing (two_opt_rand, two_opt_incr_eval, cont, 1000, cool_sched, full_eval) ;
simulated_annealing (route) ;
std :: cout << "[To] " << route << std :: endl ;
return 0 ;
}

28
trunk/paradiseo-mo/tutorial/Lesson4/iterated_local_search.cpp
View file

@ -13,46 +13,46 @@
#include <tsp>
int
main (int __argc, char * __argv [])
main (int __argc, char * __argv [])
{
if (__argc != 2)
if (__argc != 2)
{
std :: cerr << "Usage : ./iterated_local_search [instance]" << std :: endl ;
return 1 ;
}
Graph :: load (__argv [1]) ; // Instance
Route route ; // Solution
RouteInit init ; // Sol. Random Init.
init (route) ;
RouteEval full_eval ; // Full. Eval.
full_eval (route) ;
std :: cout << "[From] " << route << std :: endl ;
TwoOptInit two_opt_init ; // Init.
TwoOptNext two_opt_next ; // Explorer.
TwoOptIncrEval two_opt_incr_eval ; // Eff. eval.
moBestImprSelect <TwoOpt> two_opt_select ; //Move selection
moGenSolContinue <Route> cont (1000) ; //Stopping criterion
moFitComparator<Route> comparator; // Route comparator
CitySwap perturbation; // Route perturbation
moILS<TwoOpt> iterated_local_search (two_opt_init, two_opt_next, two_opt_incr_eval, two_opt_select,
cont, comparator, perturbation, full_eval) ;
moILS<TwoOpt> iterated_local_search (two_opt_init, two_opt_next, two_opt_incr_eval, two_opt_select,
cont, comparator, perturbation, full_eval) ;
iterated_local_search(route) ;
std :: cout << "[To] " << route << std :: endl ;
return 0 ;
}

13
trunk/paradiseo-mo/tutorial/examples/tsp/city_swap.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <city_swap.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,12 +38,13 @@
#include "city_swap.h"
bool CitySwap :: operator () (Route & __route) {
bool CitySwap :: operator () (Route & __route)
{
std :: swap (__route [rng.random (__route.size ())],
__route [rng.random (__route.size ())]) ;
__route [rng.random (__route.size ())]) ;
__route.invalidate () ;
return true ;
}

17
trunk/paradiseo-mo/tutorial/examples/tsp/city_swap.h
View file

@ -1,4 +1,4 @@
/*
/*
* <city_swap.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -43,12 +43,13 @@
/** Its swaps two vertices
randomly choosen */
class CitySwap : public eoMonOp <Route> {
public :
bool operator () (Route & __route) ;
} ;
class CitySwap : public eoMonOp <Route>
{
public :
bool operator () (Route & __route) ;
} ;
#endif

148
trunk/paradiseo-mo/tutorial/examples/tsp/edge_xover.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <edge_xover.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,119 +44,121 @@
#define MAXINT 1000000
void
EdgeXover :: build_map (const Route & __par1, const Route & __par2)
EdgeXover :: build_map (const Route & __par1, const Route & __par2)
{
unsigned int len = __par1.size () ;
/* Initialization */
_map.clear () ;
_map.resize (len) ;
for (unsigned int i = 0 ; i < len ; i ++)
for (unsigned int i = 0 ; i < len ; i ++)
{
_map [__par1 [i]].insert (__par1 [(i + 1) % len]) ;
_map [__par2 [i]].insert (__par2 [(i + 1) % len]) ;
_map [__par1 [i]].insert (__par1 [(i - 1 + len) % len]) ;
_map [__par2 [i]].insert (__par2 [(i - 1 + len) % len]) ;
}
visited.clear () ;
visited.resize (len, false) ;
}
void
EdgeXover :: remove_entry (unsigned int __vertex, std :: vector <std :: set <unsigned int> > & __map)
{
std :: set <unsigned int> & neigh = __map [__vertex] ;
EdgeXover :: remove_entry (unsigned int __vertex, std :: vector <std :: set <unsigned int> > & __map)
{
for (std :: set <unsigned int> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
__map [* it].erase (__vertex) ;
}
}
std :: set <unsigned int> & neigh = __map [__vertex] ;
for (std :: set <unsigned int> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
__map [* it].erase (__vertex) ;
}
}
void
EdgeXover :: add_vertex (unsigned int __vertex, Route & __child)
EdgeXover :: add_vertex (unsigned int __vertex, Route & __child)
{
visited [__vertex] = true ;
__child.push_back (__vertex) ;
remove_entry (__vertex, _map) ; /* Removing entries */
__child.push_back (__vertex) ;
remove_entry (__vertex, _map) ; /* Removing entries */
}
void
EdgeXover :: cross (const Route & __par1, const Route & __par2, Route & __child) {
EdgeXover :: cross (const Route & __par1, const Route & __par2, Route & __child)
{
build_map (__par1, __par2) ;
unsigned int len = __par1.size () ;
/* Go ! */
__child.clear () ;
unsigned int cur_vertex = rng.random (len) ;
add_vertex (cur_vertex, __child) ;
for (unsigned int i = 1 ; i < len ; i ++) {
unsigned int len_min_entry = MAXINT ;
std :: set <unsigned int> & neigh = _map [cur_vertex] ;
for (std :: set <unsigned int> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
unsigned int l = _map [* it].size () ;
if (len_min_entry > l)
{
len_min_entry = l ;
}
}
std :: vector <unsigned int> cand ; /* Candidates */
for (std :: set <unsigned> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
unsigned int l = _map [* it].size () ;
if (len_min_entry == l)
{
cand.push_back (* it) ;
}
}
if (! cand.size ())
{
/* Oh no ! Implicit mutation */
for (unsigned int j = 0 ; j < len ; j ++)
{
if (! visited [j])
{
cand.push_back (j) ;
}
}
}
cur_vertex = cand [rng.random (cand.size ())] ;
add_vertex (cur_vertex, __child) ;
}
for (unsigned int i = 1 ; i < len ; i ++)
{
unsigned int len_min_entry = MAXINT ;
std :: set <unsigned int> & neigh = _map [cur_vertex] ;
for (std :: set <unsigned int> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
unsigned int l = _map [* it].size () ;
if (len_min_entry > l)
{
len_min_entry = l ;
}
}
std :: vector <unsigned int> cand ; /* Candidates */
for (std :: set <unsigned> :: iterator it = neigh.begin () ; it != neigh.end () ; it ++)
{
unsigned int l = _map [* it].size () ;
if (len_min_entry == l)
{
cand.push_back (* it) ;
}
}
if (! cand.size ())
{
/* Oh no ! Implicit mutation */
for (unsigned int j = 0 ; j < len ; j ++)
{
if (! visited [j])
{
cand.push_back (j) ;
}
}
}
cur_vertex = cand [rng.random (cand.size ())] ;
add_vertex (cur_vertex, __child) ;
}
}
bool
EdgeXover :: operator () (Route & __route1, Route & __route2)
EdgeXover :: operator () (Route & __route1, Route & __route2)
{
// Init. copy
Route par [2] ;
par [0] = __route1 ;
par [1] = __route2 ;
cross (par [0], par [1], __route1) ;
cross (par [1], par [0], __route2) ;
assert (valid (__route1)) ;
assert (valid (__route2)) ;

34
trunk/paradiseo-mo/tutorial/examples/tsp/edge_xover.h
View file

@ -1,4 +1,4 @@
/*
/*
* <edge_xover.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -45,28 +45,28 @@
#include "route.h"
/** Edge Crossover */
class EdgeXover : public eoQuadOp <Route>
{
public :
bool operator () (Route & __route1, Route & __route2) ;
class EdgeXover : public eoQuadOp <Route>
{
private :
void cross (const Route & __par1, const Route & __par2, Route & __child) ; /* Binary */
public :
void remove_entry (unsigned int __vertex, std :: vector <std :: set <unsigned> > & __map) ;
/* Updating the map of entries */
bool operator () (Route & __route1, Route & __route2) ;
void build_map (const Route & __par1, const Route & __par2) ;
private :
void add_vertex (unsigned int __vertex, Route & __child) ;
void cross (const Route & __par1, const Route & __par2, Route & __child) ; /* Binary */
std :: vector <std :: set <unsigned int> > _map ; /* The handled map */
void remove_entry (unsigned int __vertex, std :: vector <std :: set <unsigned> > & __map) ;
/* Updating the map of entries */
std :: vector <bool> visited ; /* Vertices that are already visited */
void build_map (const Route & __par1, const Route & __par2) ;
} ;
void add_vertex (unsigned int __vertex, Route & __child) ;
std :: vector <std :: set <unsigned int> > _map ; /* The handled map */
std :: vector <bool> visited ; /* Vertices that are already visited */
} ;
#endif

79
trunk/paradiseo-mo/tutorial/examples/tsp/graph.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <graph.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -40,73 +40,74 @@
#include "graph.h"
namespace Graph {
namespace Graph
{
static std :: vector <std :: pair <double, double> > vectCoord ; // Coordinates
static std :: vector <std :: vector <unsigned int> > dist ; // Distances Mat.
unsigned size ()
unsigned size ()
{
return dist.size () ;
}
void computeDistances ()
void computeDistances ()
{
// Dim.
unsigned int numCities = vectCoord.size () ;
dist.resize (numCities) ;
for (unsigned int i = 0 ; i < dist.size () ; i ++)
{
dist [i].resize (numCities) ;
dist [i].resize (numCities) ;
}
// Computations.
for (unsigned int i = 0 ; i < dist.size () ; i ++)
{
for (unsigned int j = i + 1 ; j < dist.size () ; j ++)
{
double distX = (double)(vectCoord [i].first - vectCoord [j].first) ;
double distY = (double)(vectCoord [i].second - vectCoord [j].second) ;
dist [i] [j] = dist [j] [i] = (unsigned) (sqrt ((float) (distX * distX + distY * distY)) + 0.5) ;
}
for (unsigned int j = i + 1 ; j < dist.size () ; j ++)
{
double distX = (double)(vectCoord [i].first - vectCoord [j].first) ;
double distY = (double)(vectCoord [i].second - vectCoord [j].second) ;
dist [i] [j] = dist [j] [i] = (unsigned) (sqrt ((float) (distX * distX + distY * distY)) + 0.5) ;
}
}
}
void load (const char * __fileName)
void load (const char * __fileName)
{
std :: ifstream f (__fileName) ;
std :: cout << ">> Loading [" << __fileName << "]" << std :: endl ;
if (f)
if (f)
{
unsigned int num_vert ;
f >> num_vert ;
vectCoord.resize (num_vert) ;
for (unsigned int i = 0 ; i < num_vert ; i ++)
{
f >> vectCoord [i].first >> vectCoord [i].second ;
}
f.close () ;
computeDistances () ;
unsigned int num_vert ;
f >> num_vert ;
vectCoord.resize (num_vert) ;
for (unsigned int i = 0 ; i < num_vert ; i ++)
{
f >> vectCoord [i].first >> vectCoord [i].second ;
}
f.close () ;
computeDistances () ;
}
else
else
{
std :: cout << __fileName << " doesn't exist !!!" << std :: endl ;
// Bye !!!
exit (1) ;
std :: cout << __fileName << " doesn't exist !!!" << std :: endl ;
// Bye !!!
exit (1) ;
}
}
float distance (unsigned int __from, unsigned int __to)
float distance (unsigned int __from, unsigned int __to)
{
return (float)(dist [__from] [__to]) ;
}

10
trunk/paradiseo-mo/tutorial/examples/tsp/graph.h
View file

@ -1,4 +1,4 @@
/*
/*
* <graph.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -40,13 +40,13 @@
#include <vector>
#include <utility>
namespace Graph
{
namespace Graph
{
void load (const char * __file_name) ;
/* Loading cities
(expressed by their coordinates)
from the given file name */
from the given file name */
float distance (unsigned int __from, unsigned int __to) ;
unsigned int size () ; // How many cities ?

6
trunk/paradiseo-mo/tutorial/examples/tsp/mix.h
View file

@ -1,4 +1,4 @@
/*
/*
* <mix.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -39,9 +39,9 @@
#include <utils/eoRNG.h>
template <class T> void mix (std :: vector <T> & __vect)
template <class T> void mix (std :: vector <T> & __vect)
{
for (unsigned int i = 0 ; i < __vect.size () ; i ++)
for (unsigned int i = 0 ; i < __vect.size () ; i ++)
{
std :: swap (__vect [i], __vect [rng.random (__vect.size ())]) ;
}

60
trunk/paradiseo-mo/tutorial/examples/tsp/order_xover.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <order_xover.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,73 +42,73 @@
#include "order_xover.h"
#include "route_valid.h"
void OrderXover :: cross (const Route & __par1, const Route & __par2, Route & __child)
void OrderXover :: cross (const Route & __par1, const Route & __par2, Route & __child)
{
unsigned int cut = rng.random (__par1.size ()) ;
/* To store vertices that have
already been crossed */
std::vector<bool> v;
v.resize(__par1.size());
for (unsigned int i = 0 ; i < __par1.size () ; i ++)
{
v [i] = false ;
}
/* Copy of the left partial
route of the first parent */
for (unsigned int i = 0 ; i < cut ; i ++)
route of the first parent */
for (unsigned int i = 0 ; i < cut ; i ++)
{
__child [i] = __par1 [i] ;
__child [i] = __par1 [i] ;
v [__par1 [i]] = true ;
}
/* Searching the vertex of the second path, that ended
the previous first one */
unsigned int from = 0 ;
for (unsigned int i = 0 ; i < __par2.size () ; i ++)
{
if (__par2 [i] == __child [cut - 1])
{
from = i ;
break ;
}
if (__par2 [i] == __child [cut - 1])
{
from = i ;
break ;
}
}
/* Selecting a direction
Left or Right */
char direct = rng.flip () ? 1 : -1 ;
/* Copy of the left vertices from
the second parent path */
unsigned int l = cut ;
for (unsigned int i = 0 ; i < __par2.size () ; i ++)
for (unsigned int i = 0 ; i < __par2.size () ; i ++)
{
unsigned int bidule /* :-) */ = (direct * i + from + __par2.size ()) % __par2.size () ;
if (! v [__par2 [bidule]])
{
__child [l ++] = __par2 [bidule] ;
v [__par2 [bidule]] = true ;
}
if (! v [__par2 [bidule]])
{
__child [l ++] = __par2 [bidule] ;
v [__par2 [bidule]] = true ;
}
}
v.clear();
}
bool OrderXover :: operator () (Route & __route1, Route & __route2)
v.clear();
}
bool OrderXover :: operator () (Route & __route1, Route & __route2)
{
// Init. copy
Route par [2] ;
par [0] = __route1 ;
par [1] = __route2 ;
cross (par [0], par [1], __route1) ;
cross (par [1], par [0], __route2) ;
assert (valid (__route1)) ;
assert (valid (__route2)) ;

24
trunk/paradiseo-mo/tutorial/examples/tsp/order_xover.h
View file

@ -1,4 +1,4 @@
/*
/*
* <order_xover.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,16 +42,16 @@
#include "route.h"
/** Order Crossover */
class OrderXover : public eoQuadOp <Route>
{
public :
bool operator () (Route & __route1, Route & __route2) ;
private :
void cross (const Route & __par1, const Route & __par2, Route & __child) ;
} ;
class OrderXover : public eoQuadOp <Route>
{
public :
bool operator () (Route & __route1, Route & __route2) ;
private :
void cross (const Route & __par1, const Route & __par2, Route & __child) ;
} ;
#endif

11
trunk/paradiseo-mo/tutorial/examples/tsp/part_route_eval.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <part_route_eval.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,16 +37,17 @@
#include "part_route_eval.h"
#include "graph.h"
PartRouteEval :: PartRouteEval (float __from, float __to) : from (__from), to (__to) {}
PartRouteEval :: PartRouteEval (float __from, float __to) : from (__from), to (__to)
{}
void PartRouteEval :: operator () (Route & __route)
void PartRouteEval :: operator () (Route & __route)
{
float len = 0 ;
for (unsigned int i = (unsigned int) (__route.size () * from) ; i < (unsigned int ) (__route.size () * to) ; i ++)
{
len -= Graph :: distance (__route [i], __route [(i + 1) % Graph :: size ()]) ;
}
__route.fitness (len) ;
}

30
trunk/paradiseo-mo/tutorial/examples/tsp/part_route_eval.h
View file

@ -1,4 +1,4 @@
/*
/*
* <part_route_eval.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,21 +42,21 @@
#include "route.h"
/** Route Evaluator */
class PartRouteEval : public eoEvalFunc <Route>
{
public :
/** Constructor */
PartRouteEval (float __from, float __to) ;
void operator () (Route & __route) ;
private :
class PartRouteEval : public eoEvalFunc <Route>
{
float from, to ;
} ;
public :
/** Constructor */
PartRouteEval (float __from, float __to) ;
void operator () (Route & __route) ;
private :
float from, to ;
} ;
#endif

4
trunk/paradiseo-mo/tutorial/examples/tsp/part_two_opt_init.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <part_two_opt_init.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,7 +38,7 @@
#include "part_two_opt_init.h"
void PartTwoOptInit :: operator () (TwoOpt & __move, const Route & __route)
void PartTwoOptInit :: operator () (TwoOpt & __move, const Route & __route)
{
__move.first = rng.random (__route.size () - 6) ;
__move.second = __move.first + 2 ;

18
trunk/paradiseo-mo/tutorial/examples/tsp/part_two_opt_init.h
View file

@ -1,4 +1,4 @@
/*
/*
* <part_two_opt_init.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,13 +42,13 @@
#include "two_opt.h"
/** It sets the first couple of edges */
class PartTwoOptInit : public moMoveInit <TwoOpt>
{
public :
void operator () (TwoOpt & __move, const Route & __route) ;
} ;
class PartTwoOptInit : public moMoveInit <TwoOpt>
{
public :
void operator () (TwoOpt & __move, const Route & __route) ;
} ;
#endif

18
trunk/paradiseo-mo/tutorial/examples/tsp/part_two_opt_next.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <part_two_opt_next.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,21 +37,21 @@
#include "part_two_opt_next.h"
#include "graph.h"
bool TwoOptNext :: operator () (TwoOpt & __move, const Route & __route)
bool TwoOptNext :: operator () (TwoOpt & __move, const Route & __route)
{
if (__move.first == Graph :: size () - 4 && __move.second == __move.first + 2)
{
return false ;
}
else
else
{
__move.second ++ ;
if (__move.second == Graph :: size () - 1)
{
__move.first ++ ;
__move.second = __move.first + 2 ;
}
if (__move.second == Graph :: size () - 1)
{
__move.first ++ ;
__move.second = __move.first + 2 ;
}
return true ;
}
}

18
trunk/paradiseo-mo/tutorial/examples/tsp/part_two_opt_next.h
View file

@ -1,4 +1,4 @@
/*
/*
* <part_two_opt_next.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,13 +41,13 @@
#include "two_opt.h"
/** It updates a couple of edges */
class PartTwoOptNext : public moNextMove <TwoOpt>
{
public :
bool operator () (TwoOpt & __move, const Route & __route) ;
} ;
class PartTwoOptNext : public moNextMove <TwoOpt>
{
public :
bool operator () (TwoOpt & __move, const Route & __route) ;
} ;
#endif

50
trunk/paradiseo-mo/tutorial/examples/tsp/partial_mapped_xover.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <partial_mapped_xover.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,69 +44,69 @@
#include "route_valid.h"
#include "mix.h"
void PartialMappedXover :: repair (Route & __route, unsigned __cut1, unsigned __cut2)
void PartialMappedXover :: repair (Route & __route, unsigned __cut1, unsigned __cut2)
{
std::vector<unsigned int> v; // Number of times a cities are visited ...
v.resize(__route.size ());
v.resize(__route.size ());
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
v [i] = 0 ;
}
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
v [__route [i]] ++ ;
}
std :: vector <unsigned int> vert ;
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
if (! v [i])
{
vert.push_back (i) ;
}
{
vert.push_back (i) ;
}
}
mix (vert) ;
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
if (i < __cut1 || i >= __cut2)
{
if (v [__route [i]] > 1)
{
__route [i] = vert.back () ;
vert.pop_back () ;
}
}
}
{
if (v [__route [i]] > 1)
{
__route [i] = vert.back () ;
vert.pop_back () ;
}
}
}
v.clear();
}
bool PartialMappedXover :: operator () (Route & __route1, Route & __route2)
bool PartialMappedXover :: operator () (Route & __route1, Route & __route2)
{
unsigned int cut1 = rng.random (__route1.size ()), cut2 = rng.random (__route2.size ()) ;
if (cut2 < cut1)
{
std :: swap (cut1, cut2) ;
}
// Between the cuts
for (unsigned int i = cut1 ; i < cut2 ; i ++)
{
std :: swap (__route1 [i], __route2 [i]) ;
}
// Outside the cuts
repair (__route1, cut1, cut2) ;
repair (__route2, cut1, cut2) ;
// Debug
assert (valid (__route1)) ;
assert (valid (__route2)) ;

21
trunk/paradiseo-mo/tutorial/examples/tsp/partial_mapped_xover.h
View file

@ -1,4 +1,4 @@
/*
/*
* <partial_mapped_xover.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,15 +42,16 @@
#include "route.h"
/** Partial Mapped Crossover */
class PartialMappedXover : public eoQuadOp <Route> {
public :
bool operator () (Route & __route1, Route & __route2) ;
class PartialMappedXover : public eoQuadOp <Route>
{
private :
void repair (Route & __route, unsigned __cut1, unsigned __cut2) ;
} ;
public :
bool operator () (Route & __route1, Route & __route2) ;
private :
void repair (Route & __route, unsigned __cut1, unsigned __cut2) ;
} ;
#endif

2
trunk/paradiseo-mo/tutorial/examples/tsp/route.h
View file

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

12
trunk/paradiseo-mo/tutorial/examples/tsp/route_eval.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <route_eval.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,15 +37,15 @@
#include "route_eval.h"
#include "graph.h"
void RouteEval :: operator () (Route & __route)
void RouteEval :: operator () (Route & __route)
{
float len = 0 ;
for (unsigned int i = 0 ; i < Graph :: size () ; i ++)
{
len -= Graph :: distance (__route [i], __route [(i + 1) % Graph :: size ()]) ;
len -= Graph :: distance (__route [i], __route [(i + 1) % Graph :: size ()]) ;
}
__route.fitness (len) ;
}

18
trunk/paradiseo-mo/tutorial/examples/tsp/route_eval.h
View file

@ -1,4 +1,4 @@
/*
/*
* <route_eval.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,14 +42,14 @@
#include "route.h"
/** Route Evaluator */
class RouteEval : public eoEvalFunc <Route>
{
public :
void operator () (Route & __route) ;
} ;
class RouteEval : public eoEvalFunc <Route>
{
public :
void operator () (Route & __route) ;
} ;
#endif

14
trunk/paradiseo-mo/tutorial/examples/tsp/route_init.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <route_init.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -39,25 +39,25 @@
#include "route_init.h"
#include "graph.h"
void RouteInit :: operator () (Route & __route)
void RouteInit :: operator () (Route & __route)
{
// Init.
__route.clear () ;
for (unsigned int i = 0 ; i < Graph :: size () ; i ++)
{
__route.push_back (i) ;
}
// Swap. cities
for (unsigned int i = 0 ; i < Graph :: size () ; i ++)
for (unsigned int i = 0 ; i < Graph :: size () ; i ++)
{
//unsigned int j = rng.random (Graph :: size ()) ;
unsigned int j = (unsigned int) (Graph :: size () * (rand () / (RAND_MAX + 1.0))) ;
unsigned int city = __route [i] ;
__route [i] = __route [j] ;
__route [j] = city ;
}
}
}

18
trunk/paradiseo-mo/tutorial/examples/tsp/route_init.h
View file

@ -1,4 +1,4 @@
/*
/*
* <route_init.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,13 +41,13 @@
#include "route.h"
class RouteInit : public eoInit <Route>
{
public :
void operator () (Route & __route) ;
} ;
class RouteInit : public eoInit <Route>
{
public :
void operator () (Route & __route) ;
} ;
#endif

22
trunk/paradiseo-mo/tutorial/examples/tsp/route_valid.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <route_valid.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,31 +38,31 @@
#include <vector>
bool valid (Route & __route)
bool valid (Route & __route)
{
std::vector<unsigned int> t;
t.resize(__route.size());
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
t [i] = 0 ;
}
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
t [__route [i]] ++ ;
}
for (unsigned int i = 0 ; i < __route.size () ; i ++)
{
if (t [i] != 1)
{
t.clear();
return false ;
}
{
t.clear();
return false ;
}
}
t.clear();
return true ; // OK.
}

2
trunk/paradiseo-mo/tutorial/examples/tsp/route_valid.h
View file

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

2
trunk/paradiseo-mo/tutorial/examples/tsp/tsp.h
View file

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

34
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -36,24 +36,24 @@
#include "two_opt.h"
TwoOpt TwoOpt :: operator ! () const
{
TwoOpt move = * this ;
std :: swap (move.first, move.second) ;
return move ;
}
TwoOpt TwoOpt :: operator ! () const
{
TwoOpt move = * this ;
std :: swap (move.first, move.second) ;
void TwoOpt :: operator () (Route & __route)
return move ;
}
void TwoOpt :: operator () (Route & __route)
{
std :: vector <unsigned int> seq_cities ;
for (unsigned int i = second ; i > first ; i --)
{
seq_cities.push_back (__route [i]) ;
}
unsigned int j = 0 ;
for (unsigned int i = first + 1 ; i < second + 1 ; i ++)
{
@ -61,12 +61,12 @@ void TwoOpt :: operator () (Route & __route)
}
}
void TwoOpt :: readFrom (std :: istream & __is)
void TwoOpt :: readFrom (std :: istream & __is)
{
__is >> first >> second ;
}
void TwoOpt :: printOn (std :: ostream & __os) const
{
__os << first << ' ' << second ;
}
void TwoOpt :: printOn (std :: ostream & __os) const
{
__os << first << ' ' << second ;
}

28
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -44,18 +44,18 @@
#include "route.h"
class TwoOpt : public moMove <Route>, public std :: pair <unsigned, unsigned>, public eoPersistent
{
public :
TwoOpt operator ! () const ;
void operator () (Route & __route) ;
void readFrom (std :: istream & __is) ;
void printOn (std :: ostream & __os) const ;
} ;
class TwoOpt : public moMove <Route>, public std :: pair <unsigned, unsigned>, public eoPersistent
{
public :
TwoOpt operator ! () const ;
void operator () (Route & __route) ;
void readFrom (std :: istream & __is) ;
void printOn (std :: ostream & __os) const ;
} ;
#endif

16
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_incr_eval.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_incr_eval.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,17 +37,17 @@
#include "two_opt_incr_eval.h"
#include "graph.h"
float TwoOptIncrEval :: operator () (const TwoOpt & __move, const Route & __route)
float TwoOptIncrEval :: operator () (const TwoOpt & __move, const Route & __route)
{
// From
unsigned int v1 = __route [__move.first], v1_next = __route [__move.first + 1] ;
// To
unsigned int v2 = __route [__move.second], v2_next = __route [__move.second + 1] ;
return __route.fitness ()
- Graph :: distance (v1, v2)
- Graph :: distance (v1_next, v2_next)
+ Graph :: distance (v1, v1_next)
+ Graph :: distance (v2, v2_next) ;
- Graph :: distance (v1, v2)
- Graph :: distance (v1_next, v2_next)
+ Graph :: distance (v1, v1_next)
+ Graph :: distance (v2, v2_next) ;
}

16
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_incr_eval.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_incr_eval.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -40,13 +40,13 @@
#include <moMoveIncrEval.h>
#include "two_opt.h"
class TwoOptIncrEval : public moMoveIncrEval <TwoOpt>
{
public :
float operator () (const TwoOpt & __move, const Route & __route) ;
class TwoOptIncrEval : public moMoveIncrEval <TwoOpt>
{
} ;
public :
float operator () (const TwoOpt & __move, const Route & __route) ;
} ;
#endif

4
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_init.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_init.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -36,7 +36,7 @@
#include "two_opt_init.h"
void TwoOptInit :: operator () (TwoOpt & __move, const Route & __route)
void TwoOptInit :: operator () (TwoOpt & __move, const Route & __route)
{
__move.first = 0 ;
__move.second = 2 ;

18
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_init.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_init.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,13 +42,13 @@
#include "two_opt.h"
/** It sets the first couple of edges */
class TwoOptInit : public moMoveInit <TwoOpt>
{
public :
void operator () (TwoOpt & __move, const Route & __route) ;
} ;
class TwoOptInit : public moMoveInit <TwoOpt>
{
public :
void operator () (TwoOpt & __move, const Route & __route) ;
} ;
#endif

18
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_next.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_next.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -37,21 +37,21 @@
#include "two_opt_next.h"
#include "graph.h"
bool TwoOptNext :: operator () (TwoOpt & __move, const Route & __route)
bool TwoOptNext :: operator () (TwoOpt & __move, const Route & __route)
{
if (__move.first == Graph :: size () - 4 && __move.second == __move.first + 2)
{
return false ;
}
else
else
{
__move.second ++ ;
if (__move.second == Graph :: size () - 1)
{
__move.first ++ ;
__move.second = __move.first + 2 ;
}
if (__move.second == Graph :: size () - 1)
{
__move.first ++ ;
__move.second = __move.first + 2 ;
}
return true ;
}
}

18
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_next.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_next.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,13 +41,13 @@
#include "two_opt.h"
/** It updates a couple of edges */
class TwoOptNext : public moNextMove <TwoOpt>
{
public :
bool operator () (TwoOpt & __move, const Route & __route) ;
} ;
class TwoOptNext : public moNextMove <TwoOpt>
{
public :
bool operator () (TwoOpt & __move, const Route & __route) ;
} ;
#endif

4
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_rand.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_rand.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -38,7 +38,7 @@
#include "graph.h"
#include <utils/eoRNG.h>
void TwoOptRand :: operator () (TwoOpt & __move)
void TwoOptRand :: operator () (TwoOpt & __move)
{
__move.first = rng.random (Graph :: size () - 3) ;
__move.second = __move.first + 2 + rng.random (Graph :: size () - __move.first - 3) ;

18
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_rand.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_rand.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -41,13 +41,13 @@
#include "two_opt.h"
class TwoOptRand : public moRandMove <TwoOpt>
{
public :
void operator () (TwoOpt & __move) ;
} ;
class TwoOptRand : public moRandMove <TwoOpt>
{
public :
void operator () (TwoOpt & __move) ;
} ;
#endif

36
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_tabu_list.cpp
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_tabu_list.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -39,45 +39,45 @@
#define TABU_LENGTH 10
void TwoOptTabuList :: init ()
void TwoOptTabuList :: init ()
{
// Size (eventually)
tabu_span.resize (Graph :: size ()) ;
for (unsigned int i = 0 ; i < tabu_span.size () ; i ++)
{
tabu_span [i].resize (Graph :: size ()) ;
tabu_span [i].resize (Graph :: size ()) ;
}
// Clear
for (unsigned int i = 0 ; i < tabu_span.size () ; i ++)
{
for (unsigned int j = 0 ; j < tabu_span [i].size () ; j ++)
{
tabu_span [i] [j] = 0 ;
}
{
tabu_span [i] [j] = 0 ;
}
}
}
bool TwoOptTabuList :: operator () (const TwoOpt & __move, const Route & __sol)
bool TwoOptTabuList :: operator () (const TwoOpt & __move, const Route & __sol)
{
return tabu_span [__move.first] [__move.second] > 0 ;
}
void TwoOptTabuList :: add (const TwoOpt & __move, const Route & __sol)
{
tabu_span [__move.first] [__move.second] = tabu_span [__move.second] [__move.first] = TABU_LENGTH ;
}
void TwoOptTabuList :: add (const TwoOpt & __move, const Route & __sol)
{
tabu_span [__move.first] [__move.second] = tabu_span [__move.second] [__move.first] = TABU_LENGTH ;
}
void TwoOptTabuList :: update ()
void TwoOptTabuList :: update ()
{
for (unsigned int i = 0 ; i < tabu_span.size () ; i ++)
{
for (unsigned int j = 0 ; j < tabu_span [i].size () ; j ++)
{
if (tabu_span [i] [j] > 0)
{
tabu_span [i] [j] -- ;
}
}
{
if (tabu_span [i] [j] > 0)
{
tabu_span [i] [j] -- ;
}
}
}
}

36
trunk/paradiseo-mo/tutorial/examples/tsp/two_opt_tabu_list.h
View file

@ -1,4 +1,4 @@
/*
/*
* <two_opt_tabu_list.h>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2007
@ -42,22 +42,22 @@
#include "route.h"
/** The table of tabu movements, i.e. forbidden edges */
class TwoOptTabuList : public moTabuList <TwoOpt>
{
public :
bool operator () (const TwoOpt & __move, const Route & __sol) ;
void add (const TwoOpt & __move, const Route & __sol) ;
void update () ;
void init () ;
private :
std :: vector <std :: vector <unsigned> > tabu_span ;
} ;
class TwoOptTabuList : public moTabuList <TwoOpt>
{
public :
bool operator () (const TwoOpt & __move, const Route & __sol) ;
void add (const TwoOpt & __move, const Route & __sol) ;
void update () ;
void init () ;
private :
std :: vector <std :: vector <unsigned> > tabu_span ;
} ;
#endif