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

moFitSolContinue, moSteadyFitSolContinue and moNoFitImprSolContinue are added

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@582 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
jboisson 2007-07-31 11:48:12 +00:00
commit 0693358307
172 changed files with 3155 additions and 355 deletions
Download patch file Download diff file Expand all files Collapse all files

7
trunk/paradiseo-mo/doc/latex/annotated.tex
View file

@ -7,7 +7,8 @@ Here are the classes, structs, unions and interfaces with brief descriptions:\be
\item\contentsline{section}{{\bf moCoolingSchedule} (This class gives the description of a cooling schedule )}{\pageref{classmo_cooling_schedule}}{}
\item\contentsline{section}{{\bf moExponentialCoolingSchedule} (One of the possible \doxyref{moCoolingSchedule}{p.}{classmo_cooling_schedule} )}{\pageref{classmo_exponential_cooling_schedule}}{}
\item\contentsline{section}{{\bf moFirstImprSelect$<$ M $>$} (One possible \doxyref{moMoveSelect}{p.}{classmo_move_select} )}{\pageref{classmo_first_impr_select}}{}
\item\contentsline{section}{{\bf moGenSolContinue$<$ EOT $>$} (One possible stop criterion for a solution-based heuristic )}{\pageref{classmo_gen_sol_continue}}{}
\item\contentsline{section}{{\bf moFitSolContinue$<$ EOT $>$} (One possible stop criterion for a solution-based heuristic )}{\pageref{classmo_fit_sol_continue}}{}
\item\contentsline{section}{{\bf moGenSolContinue$<$ EOT $>$} (One possible stopping criterion for a solution-based heuristic )}{\pageref{classmo_gen_sol_continue}}{}
\item\contentsline{section}{{\bf moHC$<$ M $>$} (Hill Climbing (HC) )}{\pageref{classmo_h_c}}{}
\item\contentsline{section}{{\bf moHCMoveLoopExpl$<$ M $>$} (Iterative explorer used by a \doxyref{moHC}{p.}{classmo_h_c} )}{\pageref{classmo_h_c_move_loop_expl}}{}
\item\contentsline{section}{{\bf moImprBestFitAspirCrit$<$ M $>$} (One of the possible \doxyref{moAspirCrit}{p.}{classmo_aspir_crit} )}{\pageref{classmo_impr_best_fit_aspir_crit}}{}
@ -22,12 +23,14 @@ Here are the classes, structs, unions and interfaces with brief descriptions:\be
\item\contentsline{section}{{\bf moMoveSelect$<$ M $>$} (Class that describes a move selector (\doxyref{moMove}{p.}{classmo_move}) )}{\pageref{classmo_move_select}}{}
\item\contentsline{section}{{\bf moNextMove$<$ M $>$} (Class which allows to generate a new move (\doxyref{moMove}{p.}{classmo_move}) )}{\pageref{classmo_next_move}}{}
\item\contentsline{section}{{\bf moNoAspirCrit$<$ M $>$} (One of the possible aspiration criterion (\doxyref{moAspirCrit}{p.}{classmo_aspir_crit}) )}{\pageref{classmo_no_aspir_crit}}{}
\item\contentsline{section}{{\bf moNoFitImprSolContinue$<$ EOT $>$} (One possible stop criterion for a solution-based heuristic )}{\pageref{classmo_no_fit_impr_sol_continue}}{}
\item\contentsline{section}{{\bf moRandImprSelect$<$ M $>$} (One of the possible \doxyref{moMove}{p.}{classmo_move} selector (\doxyref{moMoveSelect}{p.}{classmo_move_select}) )}{\pageref{classmo_rand_impr_select}}{}
\item\contentsline{section}{{\bf moRandMove$<$ M $>$} (Random move generator )}{\pageref{classmo_rand_move}}{}
\item\contentsline{section}{{\bf moSA$<$ M $>$} (Simulated Annealing (SA) )}{\pageref{classmo_s_a}}{}
\item\contentsline{section}{{\bf moSimpleMoveTabuList$<$ M $>$} (Class describing a move tabu list with a limited memory )}{\pageref{classmo_simple_move_tabu_list}}{}
\item\contentsline{section}{{\bf moSimpleSolutionTabuList$<$ M $>$} (Class describing a solution tabu list with limited length )}{\pageref{classmo_simple_solution_tabu_list}}{}
\item\contentsline{section}{{\bf moSolContinue$<$ EOT $>$} (Class that describes a stop criterion for a solution-based heuristic )}{\pageref{classmo_sol_continue}}{}
\item\contentsline{section}{{\bf moSolContinue$<$ EOT $>$} (Class that describes a stopping criterion for a solution-based heuristic )}{\pageref{classmo_sol_continue}}{}
\item\contentsline{section}{{\bf moSteadyFitSolContinue$<$ EOT $>$} (One possible stopping criterion for a solution-based heuristic )}{\pageref{classmo_steady_fit_sol_continue}}{}
\item\contentsline{section}{{\bf moTabuList$<$ M $>$} (Class describing a tabu list that a \doxyref{moTS}{p.}{classmo_t_s} uses )}{\pageref{classmo_tabu_list}}{}
\item\contentsline{section}{{\bf moTS$<$ M $>$} (Tabu Search (TS) )}{\pageref{classmo_t_s}}{}
\item\contentsline{section}{{\bf moTSMoveLoopExpl$<$ M $>$} (Explorer for a Tabu Search algorithm )}{\pageref{classmo_t_s_move_loop_expl}}{}

209
trunk/paradiseo-mo/doc/latex/classmo_fit_sol_continue.eps Normal file
View file

@ -0,0 +1,209 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: ClassName
%%Creator: Doxygen
%%CreationDate: Time
%%For:
%Magnification: 1.00
%%Orientation: Portrait
%%BoundingBox: 0 0 500 441.989
%%Pages: 0
%%BeginSetup
%%EndSetup
%%EndComments
% ----- variables -----
/boxwidth 0 def
/boxheight 40 def
/fontheight 24 def
/marginwidth 10 def
/distx 20 def
/disty 40 def
/boundaspect 1.13125 def % aspect ratio of the BoundingBox (width/height)
/boundx 500 def
/boundy boundx boundaspect div def
/xspacing 0 def
/yspacing 0 def
/rows 4 def
/cols 1 def
/scalefactor 0 def
/boxfont /Times-Roman findfont fontheight scalefont def
% ----- procedures -----
/dotted { [1 4] 0 setdash } def
/dashed { [5] 0 setdash } def
/solid { [] 0 setdash } def
/max % result = MAX(arg1,arg2)
{
/a exch def
/b exch def
a b gt {a} {b} ifelse
} def
/xoffset % result = MAX(0,(scalefactor-(boxwidth*cols+distx*(cols-1)))/2)
{
0 scalefactor boxwidth cols mul distx cols 1 sub mul add sub 2 div max
} def
/cw % boxwidth = MAX(boxwidth, stringwidth(arg1))
{
/str exch def
/boxwidth boxwidth str stringwidth pop max def
} def
/box % draws a box with text `arg1' at grid pos (arg2,arg3)
{ gsave
2 setlinewidth
newpath
exch xspacing mul xoffset add
exch yspacing mul
moveto
boxwidth 0 rlineto
0 boxheight rlineto
boxwidth neg 0 rlineto
0 boxheight neg rlineto
closepath
dup stringwidth pop neg boxwidth add 2 div
boxheight fontheight 2 div sub 2 div
rmoveto show stroke
grestore
} def
/mark
{ newpath
exch xspacing mul xoffset add boxwidth add
exch yspacing mul
moveto
0 boxheight 4 div rlineto
boxheight neg 4 div boxheight neg 4 div rlineto
closepath
eofill
stroke
} def
/arrow
{ newpath
moveto
3 -8 rlineto
-6 0 rlineto
3 8 rlineto
closepath
eofill
stroke
} def
/out % draws an output connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight add
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/in % draws an input connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul disty 2 div sub
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/hedge
{
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight 2 div sub
/y exch def
/x exch def
newpath
x y moveto
boxwidth 2 div distx add 0 rlineto
stroke
1 eq
{ newpath x boxwidth 2 div distx add add y moveto
-8 3 rlineto
0 -6 rlineto
8 3 rlineto
closepath
eofill
stroke
} if
} def
/vedge
{
/ye exch def
/ys exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add dup
ys yspacing mul boxheight 2 div sub
moveto
ye yspacing mul boxheight 2 div sub
lineto
stroke
} def
/conn % connections the blocks from col `arg1' to `arg2' of row `arg3'
{
/ys exch def
/xe exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add
ys yspacing mul disty 2 div sub
moveto
xspacing xe xs sub mul 0
rlineto
stroke
} def
% ----- main ------
boxfont setfont
1 boundaspect scale
(moFitSolContinue< EOT >) cw
(moSolContinue< EOT >) cw
(eoUF< const EOT &, bool >) cw
(eoFunctorBase) cw
/boxwidth boxwidth marginwidth 2 mul add def
/xspacing boxwidth distx add def
/yspacing boxheight disty add def
/scalefactor
boxwidth cols mul distx cols 1 sub mul add
boxheight rows mul disty rows 1 sub mul add boundaspect mul
max def
boundx scalefactor div boundy scalefactor div scale
% ----- classes -----
(moFitSolContinue< EOT >) 0 0 box
(moSolContinue< EOT >) 0 1 box
(eoUF< const EOT &, bool >) 0 2 box
(eoFunctorBase) 0 3 box
% ----- relations -----
solid
0 0 0 out
solid
1 0 1 in
solid
0 0 1 out
solid
1 0 2 in
solid
0 0 2 out
solid
1 0 3 in

109
trunk/paradiseo-mo/doc/latex/classmo_fit_sol_continue.tex Normal file
View file

@ -0,0 +1,109 @@
\section{moFitSolContinue$<$ EOT $>$ Class Template Reference}
\label{classmo_fit_sol_continue}\index{moFitSolContinue@{moFitSolContinue}}
One possible stop criterion for a solution-based heuristic.
{\tt \#include $<$moFitSolContinue.h$>$}
Inheritance diagram for moFitSolContinue$<$ EOT $>$::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=4cm]{classmo_fit_sol_continue}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item
typedef EOT::Fitness {\bf Fitness}\label{classmo_fit_sol_continue_369ed94a788d8bdc08d5554f7669376f}
\begin{CompactList}\small\item\em Alias for the fitness. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item
{\bf moFitSolContinue} ({\bf Fitness} \_\-\_\-fitness, bool \_\-\_\-maximization=true)
\begin{CompactList}\small\item\em Basic constructor. \item\end{CompactList}\item
bool {\bf operator()} (const EOT \&\_\-\_\-sol)
\begin{CompactList}\small\item\em Function that activates the stopping criterion. \item\end{CompactList}\item
void {\bf init} ()\label{classmo_fit_sol_continue_670bd895b4edfcd3aebb40d2295d7f7c}
\begin{CompactList}\small\item\em Procedure which allows to initialise all the stuff needed. \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item
{\bf Fitness} {\bf fitness}\label{classmo_fit_sol_continue_87d0ba8f2f76f61c89317eed5f094dfc}
\begin{CompactList}\small\item\em Fitness target. \item\end{CompactList}\item
bool {\bf maximization}
\begin{CompactList}\small\item\em Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value. \item\end{CompactList}\end{CompactItemize}
\subsection{Detailed Description}
\subsubsection*{template$<$class EOT$>$ class moFitSolContinue$<$ EOT $>$}
One possible stop criterion for a solution-based heuristic.
The stop criterion corresponds to a fitness threshold gained.
Definition at line 21 of file moFitSolContinue.h.
\subsection{Constructor \& Destructor Documentation}
\index{moFitSolContinue@{moFitSolContinue}!moFitSolContinue@{moFitSolContinue}}
\index{moFitSolContinue@{moFitSolContinue}!moFitSolContinue@{moFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ {\bf moFitSolContinue}$<$ EOT $>$::{\bf moFitSolContinue} ({\bf Fitness} {\em \_\-\_\-fitness}, bool {\em \_\-\_\-maximization} = {\tt true})\hspace{0.3cm}{\tt [inline]}}\label{classmo_fit_sol_continue_5af29ede3794a7a73d8f6b0d9ebccc80}
Basic constructor.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-fitness}]The fitness to reach. \item[{\em \_\-\_\-maximization}]Indicate if the the aim is to maximize or minimize the fitness. \end{description}
\end{Desc}
Definition at line 34 of file moFitSolContinue.h.
\subsection{Member Function Documentation}
\index{moFitSolContinue@{moFitSolContinue}!operator()@{operator()}}
\index{operator()@{operator()}!moFitSolContinue@{moFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moFitSolContinue}$<$ EOT $>$::operator() (const EOT \& {\em \_\-\_\-sol})\hspace{0.3cm}{\tt [inline, virtual]}}\label{classmo_fit_sol_continue_fa9f0a15f99c998115cae9b456403a27}
Function that activates the stopping criterion.
Indicates if the fitness threshold has not been yet reached.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-sol}]the current solution. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true or false according to the value of the fitness. \end{Desc}
Implements {\bf eoUF$<$ const EOT \&, bool $>$}.
Definition at line 44 of file moFitSolContinue.h.
References moFitSolContinue$<$ EOT $>$::fitness, and moFitSolContinue$<$ EOT $>$::maximization.
\subsection{Member Data Documentation}
\index{moFitSolContinue@{moFitSolContinue}!maximization@{maximization}}
\index{maximization@{maximization}!moFitSolContinue@{moFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moFitSolContinue}$<$ EOT $>$::{\bf maximization}\hspace{0.3cm}{\tt [private]}}\label{classmo_fit_sol_continue_d686a52cbcaa57924a585c7c90456612}
Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value.
It can be interesting to know this information because some solution-based metaheuristics can generate solution with a fitness that is worse that the best known fitness (in this case, the counter is not reinitialized).
Definition at line 72 of file moFitSolContinue.h.
Referenced by moFitSolContinue$<$ EOT $>$::operator()().
The documentation for this class was generated from the following file:\begin{CompactItemize}
\item
moFitSolContinue.h\end{CompactItemize}

36
trunk/paradiseo-mo/doc/latex/classmo_gen_sol_continue.tex
View file

@ -1,6 +1,6 @@
\section{moGenSolContinue$<$ EOT $>$ Class Template Reference}
\label{classmo_gen_sol_continue}\index{moGenSolContinue@{moGenSolContinue}}
One possible stop criterion for a solution-based heuristic.
One possible stopping criterion for a solution-based heuristic.
{\tt \#include $<$moGenSolContinue.h$>$}
@ -15,11 +15,12 @@ Inheritance diagram for moGenSolContinue$<$ EOT $>$::\begin{figure}[H]
\begin{CompactItemize}
\item
{\bf moGenSolContinue} (unsigned int \_\-\_\-maxNumGen)
\begin{CompactList}\small\item\em Simple constructor. \item\end{CompactList}\item
\begin{CompactList}\small\item\em Basic constructor. \item\end{CompactList}\item
bool {\bf operator()} (const EOT \&\_\-\_\-sol)
\begin{CompactList}\small\item\em Function that activates the stop criterion. \item\end{CompactList}\item
void {\bf init} ()
\begin{CompactList}\small\item\em Procedure which allows to initialise the generation counter. \item\end{CompactList}\end{CompactItemize}
void {\bf init} ()\label{classmo_gen_sol_continue_6c5db8182157584b56507cc9075602d4}
\begin{CompactList}\small\item\em Procedure which allows to initialise all the stuff needed. \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item
@ -34,9 +35,9 @@ unsigned int {\bf numGen}\label{classmo_gen_sol_continue_630d9736a3a2c952540cdc2
\subsection{Detailed Description}
\subsubsection*{template$<$class EOT$>$ class moGenSolContinue$<$ EOT $>$}
One possible stop criterion for a solution-based heuristic.
One possible stopping criterion for a solution-based heuristic.
The stop criterion corresponds to a maximum number of iteration.
The stopping criterion corresponds to a maximum number of iteration.
@ -48,7 +49,7 @@ Definition at line 21 of file moGenSolContinue.h.
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ {\bf moGenSolContinue}$<$ EOT $>$::{\bf moGenSolContinue} (unsigned int {\em \_\-\_\-maxNumGen})\hspace{0.3cm}{\tt [inline]}}\label{classmo_gen_sol_continue_b56e890f1caa3f98e161c6512b59c95b}
Simple constructor.
Basic constructor.
\begin{Desc}
\item[Parameters:]
@ -67,7 +68,7 @@ Definition at line 30 of file moGenSolContinue.h.
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.
Increments the counter and returns true if the current number of iteration is lower than the given maximum number of iterations.
\begin{Desc}
\item[Parameters:]
@ -75,27 +76,14 @@ Increments the counter and returns TRUE if the current number of iteration is lo
\item[{\em \_\-\_\-sol}]the current solution. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]TRUE or FALSE according to the current generation number. \end{Desc}
\item[Returns:]true or false according to the current generation number. \end{Desc}
Implements {\bf eoUF$<$ const EOT \&, bool $>$}.
Definition at line 44 of file moGenSolContinue.h.
Definition at line 42 of file moGenSolContinue.h.
References moGenSolContinue$<$ EOT $>$::maxNumGen, and moGenSolContinue$<$ EOT $>$::numGen.\index{moGenSolContinue@{moGenSolContinue}!init@{init}}
\index{init@{init}!moGenSolContinue@{moGenSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ void {\bf moGenSolContinue}$<$ EOT $>$::init ()\hspace{0.3cm}{\tt [inline, virtual]}}\label{classmo_gen_sol_continue_6c5db8182157584b56507cc9075602d4}
Procedure which allows to initialise the generation counter.
It can also be used to reset the iteration counter.
Implements {\bf moSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_sol_continue_064dc966a210f4ffb9515be3f03ca4c7}.
Definition at line 54 of file moGenSolContinue.h.
References moGenSolContinue$<$ EOT $>$::numGen.
References moGenSolContinue$<$ EOT $>$::maxNumGen, and moGenSolContinue$<$ EOT $>$::numGen.
The documentation for this class was generated from the following file:\begin{CompactItemize}
\item

209
trunk/paradiseo-mo/doc/latex/classmo_no_fit_impr_sol_continue.eps Normal file
View file

@ -0,0 +1,209 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: ClassName
%%Creator: Doxygen
%%CreationDate: Time
%%For:
%Magnification: 1.00
%%Orientation: Portrait
%%BoundingBox: 0 0 500 386.473
%%Pages: 0
%%BeginSetup
%%EndSetup
%%EndComments
% ----- variables -----
/boxwidth 0 def
/boxheight 40 def
/fontheight 24 def
/marginwidth 10 def
/distx 20 def
/disty 40 def
/boundaspect 1.29375 def % aspect ratio of the BoundingBox (width/height)
/boundx 500 def
/boundy boundx boundaspect div def
/xspacing 0 def
/yspacing 0 def
/rows 4 def
/cols 1 def
/scalefactor 0 def
/boxfont /Times-Roman findfont fontheight scalefont def
% ----- procedures -----
/dotted { [1 4] 0 setdash } def
/dashed { [5] 0 setdash } def
/solid { [] 0 setdash } def
/max % result = MAX(arg1,arg2)
{
/a exch def
/b exch def
a b gt {a} {b} ifelse
} def
/xoffset % result = MAX(0,(scalefactor-(boxwidth*cols+distx*(cols-1)))/2)
{
0 scalefactor boxwidth cols mul distx cols 1 sub mul add sub 2 div max
} def
/cw % boxwidth = MAX(boxwidth, stringwidth(arg1))
{
/str exch def
/boxwidth boxwidth str stringwidth pop max def
} def
/box % draws a box with text `arg1' at grid pos (arg2,arg3)
{ gsave
2 setlinewidth
newpath
exch xspacing mul xoffset add
exch yspacing mul
moveto
boxwidth 0 rlineto
0 boxheight rlineto
boxwidth neg 0 rlineto
0 boxheight neg rlineto
closepath
dup stringwidth pop neg boxwidth add 2 div
boxheight fontheight 2 div sub 2 div
rmoveto show stroke
grestore
} def
/mark
{ newpath
exch xspacing mul xoffset add boxwidth add
exch yspacing mul
moveto
0 boxheight 4 div rlineto
boxheight neg 4 div boxheight neg 4 div rlineto
closepath
eofill
stroke
} def
/arrow
{ newpath
moveto
3 -8 rlineto
-6 0 rlineto
3 8 rlineto
closepath
eofill
stroke
} def
/out % draws an output connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight add
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/in % draws an input connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul disty 2 div sub
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/hedge
{
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight 2 div sub
/y exch def
/x exch def
newpath
x y moveto
boxwidth 2 div distx add 0 rlineto
stroke
1 eq
{ newpath x boxwidth 2 div distx add add y moveto
-8 3 rlineto
0 -6 rlineto
8 3 rlineto
closepath
eofill
stroke
} if
} def
/vedge
{
/ye exch def
/ys exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add dup
ys yspacing mul boxheight 2 div sub
moveto
ye yspacing mul boxheight 2 div sub
lineto
stroke
} def
/conn % connections the blocks from col `arg1' to `arg2' of row `arg3'
{
/ys exch def
/xe exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add
ys yspacing mul disty 2 div sub
moveto
xspacing xe xs sub mul 0
rlineto
stroke
} def
% ----- main ------
boxfont setfont
1 boundaspect scale
(moNoFitImprSolContinue< EOT >) cw
(moSolContinue< EOT >) cw
(eoUF< const EOT &, bool >) cw
(eoFunctorBase) cw
/boxwidth boxwidth marginwidth 2 mul add def
/xspacing boxwidth distx add def
/yspacing boxheight disty add def
/scalefactor
boxwidth cols mul distx cols 1 sub mul add
boxheight rows mul disty rows 1 sub mul add boundaspect mul
max def
boundx scalefactor div boundy scalefactor div scale
% ----- classes -----
(moNoFitImprSolContinue< EOT >) 0 0 box
(moSolContinue< EOT >) 0 1 box
(eoUF< const EOT &, bool >) 0 2 box
(eoFunctorBase) 0 3 box
% ----- relations -----
solid
0 0 0 out
solid
1 0 1 in
solid
0 0 1 out
solid
1 0 2 in
solid
0 0 2 out
solid
1 0 3 in

116
trunk/paradiseo-mo/doc/latex/classmo_no_fit_impr_sol_continue.tex Normal file
View file

@ -0,0 +1,116 @@
\section{moNoFitImprSolContinue$<$ EOT $>$ Class Template Reference}
\label{classmo_no_fit_impr_sol_continue}\index{moNoFitImprSolContinue@{moNoFitImprSolContinue}}
One possible stop criterion for a solution-based heuristic.
{\tt \#include $<$moNoFitImprSolContinue.h$>$}
Inheritance diagram for moNoFitImprSolContinue$<$ EOT $>$::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=4cm]{classmo_no_fit_impr_sol_continue}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item
typedef EOT::Fitness {\bf Fitness}\label{classmo_no_fit_impr_sol_continue_64c184de66bb37d75d53aa600ac947b3}
\begin{CompactList}\small\item\em Alias for the fitness. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item
{\bf moNoFitImprSolContinue} (unsigned int \_\-\_\-maxNumberOfIterationWithoutImprovment, bool \_\-\_\-maximization=true)
\begin{CompactList}\small\item\em Basic constructor. \item\end{CompactList}\item
bool {\bf operator()} (const EOT \&\_\-\_\-sol)
\begin{CompactList}\small\item\em Function that activates the stopping criterion. \item\end{CompactList}\item
void {\bf init} ()\label{classmo_no_fit_impr_sol_continue_21641c0a38a4501baae6133cbc591de4}
\begin{CompactList}\small\item\em Procedure which allows to initialise all the stuff needed. \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item
unsigned int {\bf maxNumberOfIterationsWithoutImprovment}\label{classmo_no_fit_impr_sol_continue_9dbd725a2dab787f9f7b159b759e4834}
\begin{CompactList}\small\item\em Maximum number of iterations without improvment allowed. \item\end{CompactList}\item
bool {\bf firstFitnessSaved}\label{classmo_no_fit_impr_sol_continue_ca3591e47a075b59e0826f31234c71ef}
\begin{CompactList}\small\item\em Flag that this is the first time that the fitness is used. \item\end{CompactList}\item
{\bf Fitness} {\bf fitness}\label{classmo_no_fit_impr_sol_continue_3d3d2b43a4dd73e38689cc0018d44ee7}
\begin{CompactList}\small\item\em Current Fitness. \item\end{CompactList}\item
bool {\bf maximization}
\begin{CompactList}\small\item\em Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value. \item\end{CompactList}\item
unsigned int {\bf counter}\label{classmo_no_fit_impr_sol_continue_46fc008a8f7cd06dcaaeb4016b433adb}
\begin{CompactList}\small\item\em The iteration couter. \item\end{CompactList}\end{CompactItemize}
\subsection{Detailed Description}
\subsubsection*{template$<$class EOT$>$ class moNoFitImprSolContinue$<$ EOT $>$}
One possible stop criterion for a solution-based heuristic.
The stop criterion corresponds to a maximum number of iterations without improvement.
Definition at line 21 of file moNoFitImprSolContinue.h.
\subsection{Constructor \& Destructor Documentation}
\index{moNoFitImprSolContinue@{moNoFitImprSolContinue}!moNoFitImprSolContinue@{moNoFitImprSolContinue}}
\index{moNoFitImprSolContinue@{moNoFitImprSolContinue}!moNoFitImprSolContinue@{moNoFitImprSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ {\bf moNoFitImprSolContinue}$<$ EOT $>$::{\bf moNoFitImprSolContinue} (unsigned int {\em \_\-\_\-maxNumberOfIterationWithoutImprovment}, bool {\em \_\-\_\-maximization} = {\tt true})\hspace{0.3cm}{\tt [inline]}}\label{classmo_no_fit_impr_sol_continue_979c991cbae53e1fd596964837c8d32d}
Basic constructor.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-maxNumberOfIterationWithoutImprovment}]The number of iterations without fitness improvment to reach for stop. \item[{\em \_\-\_\-maximization}]Indicate if the the aim is to maximize or minimize the fitness. \end{description}
\end{Desc}
Definition at line 34 of file moNoFitImprSolContinue.h.
\subsection{Member Function Documentation}
\index{moNoFitImprSolContinue@{moNoFitImprSolContinue}!operator()@{operator()}}
\index{operator()@{operator()}!moNoFitImprSolContinue@{moNoFitImprSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moNoFitImprSolContinue}$<$ EOT $>$::operator() (const EOT \& {\em \_\-\_\-sol})\hspace{0.3cm}{\tt [inline, virtual]}}\label{classmo_no_fit_impr_sol_continue_dbd663623cae56ec76ee504ecb226fed}
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). \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-sol}]the current solution. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true or false. \end{Desc}
Implements {\bf eoUF$<$ const EOT \&, bool $>$}.
Definition at line 45 of file moNoFitImprSolContinue.h.
References moNoFitImprSolContinue$<$ EOT $>$::counter, moNoFitImprSolContinue$<$ EOT $>$::firstFitnessSaved, moNoFitImprSolContinue$<$ EOT $>$::fitness, moNoFitImprSolContinue$<$ EOT $>$::maximization, and moNoFitImprSolContinue$<$ EOT $>$::maxNumberOfIterationsWithoutImprovment.
\subsection{Member Data Documentation}
\index{moNoFitImprSolContinue@{moNoFitImprSolContinue}!maximization@{maximization}}
\index{maximization@{maximization}!moNoFitImprSolContinue@{moNoFitImprSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moNoFitImprSolContinue}$<$ EOT $>$::{\bf maximization}\hspace{0.3cm}{\tt [private]}}\label{classmo_no_fit_impr_sol_continue_73295d6a4ad437b0ab06848ac24698c4}
Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value.
It can be interesting to know this information because some solution-based metaheuristics can generate solutions wiht a fitness that is worse that the best known fitness (in this case, the counter is not reinitialized).
Definition at line 96 of file moNoFitImprSolContinue.h.
Referenced by moNoFitImprSolContinue$<$ EOT $>$::operator()().
The documentation for this class was generated from the following file:\begin{CompactItemize}
\item
moNoFitImprSolContinue.h\end{CompactItemize}

38
trunk/paradiseo-mo/doc/latex/classmo_sol_continue.eps
View file

@ -5,7 +5,7 @@
%%For:
%Magnification: 1.00
%%Orientation: Portrait
%%BoundingBox: 0 0 500 441.989
%%BoundingBox: 0 0 500 96.6184
%%Pages: 0
%%BeginSetup
%%EndSetup
@ -19,13 +19,13 @@
/marginwidth 10 def
/distx 20 def
/disty 40 def
/boundaspect 1.13125 def % aspect ratio of the BoundingBox (width/height)
/boundaspect 5.175 def % aspect ratio of the BoundingBox (width/height)
/boundx 500 def
/boundy boundx boundaspect div def
/xspacing 0 def
/yspacing 0 def
/rows 4 def
/cols 1 def
/cols 4 def
/scalefactor 0 def
/boxfont /Times-Roman findfont fontheight scalefont def
@ -176,7 +176,10 @@ boxfont setfont
(moSolContinue< EOT >) cw
(eoUF< const EOT &, bool >) cw
(eoFunctorBase) cw
(moFitSolContinue< EOT >) cw
(moGenSolContinue< EOT >) cw
(moNoFitImprSolContinue< EOT >) cw
(moSteadyFitSolContinue< EOT >) cw
/boxwidth boxwidth marginwidth 2 mul add def
/xspacing boxwidth distx add def
/yspacing boxheight disty add def
@ -188,22 +191,33 @@ boundx scalefactor div boundy scalefactor div scale
% ----- classes -----
(moSolContinue< EOT >) 0 1 box
(eoUF< const EOT &, bool >) 0 2 box
(eoFunctorBase) 0 3 box
(moGenSolContinue< EOT >) 0 0 box
(moSolContinue< EOT >) 1.5 1 box
(eoUF< const EOT &, bool >) 1.5 2 box
(eoFunctorBase) 1.5 3 box
(moFitSolContinue< EOT >) 0 0 box
(moGenSolContinue< EOT >) 1 0 box
(moNoFitImprSolContinue< EOT >) 2 0 box
(moSteadyFitSolContinue< EOT >) 3 0 box
% ----- relations -----
solid
0 0 1 out
0 1.5 1 out
solid
1 0 2 in
1 1.5 2 in
solid
0 0 2 out
0 1.5 2 out
solid
1 0 3 in
1 1.5 3 in
solid
1 0 0.25 out
1 1.5 0.25 out
solid
0 3 1 conn
solid
0 0 0.75 in
solid
0 1 0.75 in
solid
0 2 0.75 in
solid
0 3 0.75 in

12
trunk/paradiseo-mo/doc/latex/classmo_sol_continue.tex
View file

@ -1,6 +1,6 @@
\section{moSolContinue$<$ EOT $>$ Class Template Reference}
\label{classmo_sol_continue}\index{moSolContinue@{moSolContinue}}
Class that describes a stop criterion for a solution-based heuristic.
Class that describes a stopping criterion for a solution-based heuristic.
{\tt \#include $<$moSolContinue.h$>$}
@ -8,20 +8,20 @@ Class that describes a stop criterion for a solution-based heuristic.
Inheritance diagram for moSolContinue$<$ EOT $>$::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=4cm]{classmo_sol_continue}
\includegraphics[height=2.70531cm]{classmo_sol_continue}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item
virtual void {\bf init} ()=0
\begin{CompactList}\small\item\em Procedure which initialises all that the stop criterion needs. \item\end{CompactList}\end{CompactItemize}
\begin{CompactList}\small\item\em Procedure which initialises all that the stopping criterion needs. \item\end{CompactList}\end{CompactItemize}
\subsection{Detailed Description}
\subsubsection*{template$<$class EOT$>$ class moSolContinue$<$ EOT $>$}
Class that describes a stop criterion for a solution-based heuristic.
Class that describes a stopping criterion for a solution-based heuristic.
It allows to add an initialisation procedure to an object that is a unary function ({\bf eoUF}).
@ -35,11 +35,11 @@ Definition at line 22 of file moSolContinue.h.
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ virtual void {\bf moSolContinue}$<$ EOT $>$::init ()\hspace{0.3cm}{\tt [pure virtual]}}\label{classmo_sol_continue_064dc966a210f4ffb9515be3f03ca4c7}
Procedure which initialises all that the stop criterion needs.
Procedure which initialises all that the stopping criterion needs.
Generally, it allocates some data structures or initialises some counters.
Implemented in {\bf moGenSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_gen_sol_continue_6c5db8182157584b56507cc9075602d4}.
Implemented in {\bf moFitSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_fit_sol_continue_670bd895b4edfcd3aebb40d2295d7f7c}, {\bf moGenSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_gen_sol_continue_6c5db8182157584b56507cc9075602d4}, {\bf moNoFitImprSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_no_fit_impr_sol_continue_21641c0a38a4501baae6133cbc591de4}, and {\bf moSteadyFitSolContinue$<$ EOT $>$} \doxyref{}{p.}{classmo_steady_fit_sol_continue_87563493addc8e4b58982c55a67179b9}.
The documentation for this class was generated from the following file:\begin{CompactItemize}
\item

209
trunk/paradiseo-mo/doc/latex/classmo_steady_fit_sol_continue.eps Normal file
View file

@ -0,0 +1,209 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: ClassName
%%Creator: Doxygen
%%CreationDate: Time
%%For:
%Magnification: 1.00
%%Orientation: Portrait
%%BoundingBox: 0 0 500 388.35
%%Pages: 0
%%BeginSetup
%%EndSetup
%%EndComments
% ----- variables -----
/boxwidth 0 def
/boxheight 40 def
/fontheight 24 def
/marginwidth 10 def
/distx 20 def
/disty 40 def
/boundaspect 1.2875 def % aspect ratio of the BoundingBox (width/height)
/boundx 500 def
/boundy boundx boundaspect div def
/xspacing 0 def
/yspacing 0 def
/rows 4 def
/cols 1 def
/scalefactor 0 def
/boxfont /Times-Roman findfont fontheight scalefont def
% ----- procedures -----
/dotted { [1 4] 0 setdash } def
/dashed { [5] 0 setdash } def
/solid { [] 0 setdash } def
/max % result = MAX(arg1,arg2)
{
/a exch def
/b exch def
a b gt {a} {b} ifelse
} def
/xoffset % result = MAX(0,(scalefactor-(boxwidth*cols+distx*(cols-1)))/2)
{
0 scalefactor boxwidth cols mul distx cols 1 sub mul add sub 2 div max
} def
/cw % boxwidth = MAX(boxwidth, stringwidth(arg1))
{
/str exch def
/boxwidth boxwidth str stringwidth pop max def
} def
/box % draws a box with text `arg1' at grid pos (arg2,arg3)
{ gsave
2 setlinewidth
newpath
exch xspacing mul xoffset add
exch yspacing mul
moveto
boxwidth 0 rlineto
0 boxheight rlineto
boxwidth neg 0 rlineto
0 boxheight neg rlineto
closepath
dup stringwidth pop neg boxwidth add 2 div
boxheight fontheight 2 div sub 2 div
rmoveto show stroke
grestore
} def
/mark
{ newpath
exch xspacing mul xoffset add boxwidth add
exch yspacing mul
moveto
0 boxheight 4 div rlineto
boxheight neg 4 div boxheight neg 4 div rlineto
closepath
eofill
stroke
} def
/arrow
{ newpath
moveto
3 -8 rlineto
-6 0 rlineto
3 8 rlineto
closepath
eofill
stroke
} def
/out % draws an output connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight add
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/in % draws an input connector for the block at (arg1,arg2)
{
newpath
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul disty 2 div sub
/y exch def
/x exch def
x y moveto
0 disty 2 div rlineto
stroke
1 eq { x y disty 2 div add arrow } if
} def
/hedge
{
exch xspacing mul xoffset add boxwidth 2 div add
exch yspacing mul boxheight 2 div sub
/y exch def
/x exch def
newpath
x y moveto
boxwidth 2 div distx add 0 rlineto
stroke
1 eq
{ newpath x boxwidth 2 div distx add add y moveto
-8 3 rlineto
0 -6 rlineto
8 3 rlineto
closepath
eofill
stroke
} if
} def
/vedge
{
/ye exch def
/ys exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add dup
ys yspacing mul boxheight 2 div sub
moveto
ye yspacing mul boxheight 2 div sub
lineto
stroke
} def
/conn % connections the blocks from col `arg1' to `arg2' of row `arg3'
{
/ys exch def
/xe exch def
/xs exch def
newpath
xs xspacing mul xoffset add boxwidth 2 div add
ys yspacing mul disty 2 div sub
moveto
xspacing xe xs sub mul 0
rlineto
stroke
} def
% ----- main ------
boxfont setfont
1 boundaspect scale
(moSteadyFitSolContinue< EOT >) cw
(moSolContinue< EOT >) cw
(eoUF< const EOT &, bool >) cw
(eoFunctorBase) cw
/boxwidth boxwidth marginwidth 2 mul add def
/xspacing boxwidth distx add def
/yspacing boxheight disty add def
/scalefactor
boxwidth cols mul distx cols 1 sub mul add
boxheight rows mul disty rows 1 sub mul add boundaspect mul
max def
boundx scalefactor div boundy scalefactor div scale
% ----- classes -----
(moSteadyFitSolContinue< EOT >) 0 0 box
(moSolContinue< EOT >) 0 1 box
(eoUF< const EOT &, bool >) 0 2 box
(eoFunctorBase) 0 3 box
% ----- relations -----
solid
0 0 0 out
solid
1 0 1 in
solid
0 0 1 out
solid
1 0 2 in
solid
0 0 2 out
solid
1 0 3 in

124
trunk/paradiseo-mo/doc/latex/classmo_steady_fit_sol_continue.tex Normal file
View file

@ -0,0 +1,124 @@
\section{moSteadyFitSolContinue$<$ EOT $>$ Class Template Reference}
\label{classmo_steady_fit_sol_continue}\index{moSteadyFitSolContinue@{moSteadyFitSolContinue}}
One possible stopping criterion for a solution-based heuristic.
{\tt \#include $<$moSteadyFitSolContinue.h$>$}
Inheritance diagram for moSteadyFitSolContinue$<$ EOT $>$::\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=4cm]{classmo_steady_fit_sol_continue}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item
typedef EOT::Fitness {\bf Fitness}\label{classmo_steady_fit_sol_continue_c289721abbbafe50f6e3b8305dd31007}
\begin{CompactList}\small\item\em Alias for the fitness. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item
{\bf moSteadyFitSolContinue} (unsigned int \_\-\_\-maxNumberOfIterations, unsigned int \_\-\_\-maxNumberOfIterationWithoutImprovment, bool \_\-\_\-maximization=true)
\begin{CompactList}\small\item\em Basic constructor. \item\end{CompactList}\item
bool {\bf operator()} (const EOT \&\_\-\_\-sol)
\begin{CompactList}\small\item\em Function that activates the stopping criterion. \item\end{CompactList}\item
void {\bf init} ()\label{classmo_steady_fit_sol_continue_87563493addc8e4b58982c55a67179b9}
\begin{CompactList}\small\item\em Procedure which allows to initialise the stuff needed. \item\end{CompactList}\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item
unsigned int {\bf maxNumberOfIterations}\label{classmo_steady_fit_sol_continue_36b43c2a252887ad027165ac32393fe8}
\begin{CompactList}\small\item\em Maximum number of iterations before considering the fitness. \item\end{CompactList}\item
unsigned int {\bf maxNumberOfIterationsWithoutImprovment}\label{classmo_steady_fit_sol_continue_92a3ea5b6752938b159257f8c6c62580}
\begin{CompactList}\small\item\em Maximum number of iterations without improvment allowed. \item\end{CompactList}\item
bool {\bf maxNumberOfIterationsReached}\label{classmo_steady_fit_sol_continue_7d88c0eb91b2a12121ba1c3ae9139887}
\begin{CompactList}\small\item\em Flag that indicates that the maxNumberIteration have been reached. \item\end{CompactList}\item
bool {\bf firstFitnessSaved}\label{classmo_steady_fit_sol_continue_025bf2789e470fdde989eee9121035c3}
\begin{CompactList}\small\item\em Flag that this is the first time that the fitness is used. \item\end{CompactList}\item
{\bf Fitness} {\bf fitness}\label{classmo_steady_fit_sol_continue_a5c62e7049b36f6e71e92b559568c09e}
\begin{CompactList}\small\item\em Current Fitness. \item\end{CompactList}\item
bool {\bf maximization}
\begin{CompactList}\small\item\em Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value. \item\end{CompactList}\item
unsigned int {\bf counter}\label{classmo_steady_fit_sol_continue_245c9099a2c40dfc4f34b3ff216d13ce}
\begin{CompactList}\small\item\em The iteration couter. \item\end{CompactList}\end{CompactItemize}
\subsection{Detailed Description}
\subsubsection*{template$<$class EOT$>$ class moSteadyFitSolContinue$<$ EOT $>$}
One possible stopping criterion for a solution-based heuristic.
The stop criterion corresponds to a maximum number of iterations without improvement (after a minimum number of iterations).
Definition at line 21 of file moSteadyFitSolContinue.h.
\subsection{Constructor \& Destructor Documentation}
\index{moSteadyFitSolContinue@{moSteadyFitSolContinue}!moSteadyFitSolContinue@{moSteadyFitSolContinue}}
\index{moSteadyFitSolContinue@{moSteadyFitSolContinue}!moSteadyFitSolContinue@{moSteadyFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ {\bf moSteadyFitSolContinue}$<$ EOT $>$::{\bf moSteadyFitSolContinue} (unsigned int {\em \_\-\_\-maxNumberOfIterations}, unsigned int {\em \_\-\_\-maxNumberOfIterationWithoutImprovment}, bool {\em \_\-\_\-maximization} = {\tt true})\hspace{0.3cm}{\tt [inline]}}\label{classmo_steady_fit_sol_continue_bde46266638f645d409cf1afb7190c19}
Basic constructor.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-maxNumberOfIterations}]The number of iterations to reach before looking for the fitness. \item[{\em \_\-\_\-maxNumberOfIterationWithoutImprovment}]The number of iterations without fitness improvment to reach for stop. \item[{\em \_\-\_\-maximization}]Indicate if the the aim is to maximize or minimize the fitness. \end{description}
\end{Desc}
Definition at line 35 of file moSteadyFitSolContinue.h.
\subsection{Member Function Documentation}
\index{moSteadyFitSolContinue@{moSteadyFitSolContinue}!operator()@{operator()}}
\index{operator()@{operator()}!moSteadyFitSolContinue@{moSteadyFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moSteadyFitSolContinue}$<$ EOT $>$::operator() (const EOT \& {\em \_\-\_\-sol})\hspace{0.3cm}{\tt [inline, virtual]}}\label{classmo_steady_fit_sol_continue_942e58ec00bb61000a83c80176e14bc3}
Function that activates the stopping criterion.
Indicates if the fitness has not been improved since a number of iterations (after a minimum of iterations).
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-\_\-sol}]the current solution. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true or false. \end{Desc}
Implements {\bf eoUF$<$ const EOT \&, bool $>$}.
Definition at line 47 of file moSteadyFitSolContinue.h.
References moSteadyFitSolContinue$<$ EOT $>$::counter, moSteadyFitSolContinue$<$ EOT $>$::firstFitnessSaved, moSteadyFitSolContinue$<$ EOT $>$::fitness, moSteadyFitSolContinue$<$ EOT $>$::maximization, moSteadyFitSolContinue$<$ EOT $>$::maxNumberOfIterations, moSteadyFitSolContinue$<$ EOT $>$::maxNumberOfIterationsReached, and moSteadyFitSolContinue$<$ EOT $>$::maxNumberOfIterationsWithoutImprovment.
\subsection{Member Data Documentation}
\index{moSteadyFitSolContinue@{moSteadyFitSolContinue}!maximization@{maximization}}
\index{maximization@{maximization}!moSteadyFitSolContinue@{moSteadyFitSolContinue}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class EOT$>$ bool {\bf moSteadyFitSolContinue}$<$ EOT $>$::{\bf maximization}\hspace{0.3cm}{\tt [private]}}\label{classmo_steady_fit_sol_continue_cc54de2c6f32b650e5a7ee36efc1ba73}
Flag that indicate if there is a maximization (true) or a minimization (false) of the fitness value.
It can be interesting to know this information because some solution-based metaheuristics can generate solution with a fitness that is worse that the best known fitness (in this case, the counter is not reinitialized).
Definition at line 114 of file moSteadyFitSolContinue.h.
Referenced by moSteadyFitSolContinue$<$ EOT $>$::operator()().
The documentation for this class was generated from the following file:\begin{CompactItemize}
\item
moSteadyFitSolContinue.h\end{CompactItemize}

4
trunk/paradiseo-mo/doc/latex/doxygen.sty
View file

@ -10,8 +10,8 @@
{\fancyplain{}{\bfseries\rightmark}}
\rhead[\fancyplain{}{\bfseries\leftmark}]
{\fancyplain{}{\bfseries\thepage}}
\rfoot[\fancyplain{}{\bfseries\scriptsize Generated on Fri Jul 6 17:23:18 2007 for PARADISEO-MO by Doxygen }]{}
\lfoot[]{\fancyplain{}{\bfseries\scriptsize Generated on Fri Jul 6 17:23:18 2007 for PARADISEO-MO by Doxygen }}
\rfoot[\fancyplain{}{\bfseries\scriptsize Generated on Tue Jul 31 13:43:22 2007 for PARADISEO-MO by Doxygen }]{}
\lfoot[]{\fancyplain{}{\bfseries\scriptsize Generated on Tue Jul 31 13:43:22 2007 for PARADISEO-MO by Doxygen }}
\cfoot{}
\newenvironment{Code}
{\footnotesize}

3
trunk/paradiseo-mo/doc/latex/hierarchy.tex
View file

@ -52,7 +52,10 @@ This inheritance list is sorted roughly, but not completely, alphabetically:\beg
\item eoUF$<$ const EOT \&, bool $>${\tt [external]}\begin{CompactList}
\item \contentsline{section}{moSolContinue$<$ EOT $>$}{\pageref{classmo_sol_continue}}{}
\begin{CompactList}
\item \contentsline{section}{moFitSolContinue$<$ EOT $>$}{\pageref{classmo_fit_sol_continue}}{}
\item \contentsline{section}{moGenSolContinue$<$ EOT $>$}{\pageref{classmo_gen_sol_continue}}{}
\item \contentsline{section}{moNoFitImprSolContinue$<$ EOT $>$}{\pageref{classmo_no_fit_impr_sol_continue}}{}
\item \contentsline{section}{moSteadyFitSolContinue$<$ EOT $>$}{\pageref{classmo_steady_fit_sol_continue}}{}
\end{CompactList}
\end{CompactList}
\item eoUF$<$ double \&, bool $>${\tt [external]}\begin{CompactList}

5
trunk/paradiseo-mo/doc/latex/refman.tex
View file

@ -20,7 +20,7 @@
\vspace*{1cm}
{\large Generated by Doxygen 1.5.2}\\
\vspace*{0.5cm}
{\small Fri Jul 6 17:23:18 2007}\\
{\small Tue Jul 31 13:43:22 2007}\\
\end{center}
\end{titlepage}
\clearemptydoublepage
@ -42,6 +42,7 @@
\include{classmo_cooling_schedule}
\include{classmo_exponential_cooling_schedule}
\include{classmo_first_impr_select}
\include{classmo_fit_sol_continue}
\include{classmo_gen_sol_continue}
\include{classmo_h_c}
\include{classmo_h_c_move_loop_expl}
@ -57,12 +58,14 @@
\include{classmo_move_select}
\include{classmo_next_move}
\include{classmo_no_aspir_crit}
\include{classmo_no_fit_impr_sol_continue}
\include{classmo_rand_impr_select}
\include{classmo_rand_move}
\include{classmo_s_a}
\include{classmo_simple_move_tabu_list}
\include{classmo_simple_solution_tabu_list}
\include{classmo_sol_continue}
\include{classmo_steady_fit_sol_continue}
\include{classmo_tabu_list}
\include{classmo_t_s}
\include{classmo_t_s_move_loop_expl}