Main Page | Class Hierarchy | Class List | File List | Class Members

incop.h

00001 /* Les définitions des classes de la partie algorithme + OpProblem */
00004 /* les classes "abstraites" utilisées dans les paramètres des méthodes */
00005 class OpProblem;
00006 class IncompleteAlgorithm;
00007 class Metaheuristic;
00008 class NeighborhoodSearch;
00009 class Move;
00010 
00011 
00012 
00013 /* la classe Configuration  le champ config comprend la configuration elle-même sous forme de tableau d'entiers
00014 le champ valuation contient sa valeur pour l'évaluation */
00015 
00018 class Configuration 
00019 
00020 {public :
00021   int nbvar;
00022  int trynumber;
00023 /* les valeurs courantes des variables : implanté sous forme de tableau d'entiers*/
00025   int* config;
00026 /* la valeur de la configuration */
00028   int valuation;
00029   int var_conflict_size;
00030 /* les variables participant à un conflit : implanté sous forme de vecteur */
00032    vector<int> var_conflict;    
00033    set<int> set_var_conflict;
00034 /* indicateur si la configuration a été regroupée (pour GWW) */
00036   int regrouped;
00037   virtual ~Configuration();
00038   Configuration();
00039   Configuration(int nbvar);
00040 /* copie d'une configuration config2 dans this*/
00042   virtual void copy_element (Configuration* config2);
00043 /* initialisation à 0 de la structure de données des conflits */
00045   virtual void init_conflicts ();
00046 /* stockage de l'augmentation des conflits de (var,val) de incr */
00048   virtual void incr_conflicts (int var, int val, int index, int incr);
00049 
00050 /* stockage du nombre des conflits nbconf de (var,val)  */
00052   virtual  void set_conflicts (int var, int val, int index, int nbconf);
00053 
00054 /* nombre de conflits de (var,val) stocké */
00056   virtual  int get_conflicts (int var, int val, int index);
00057 /* nombre de conflits de (var,val) , au besoin recalculé */
00059   virtual  int get_conflicts_problem (OpProblem* problem, int var, int val);
00060 
00061 /* mise à jour des conflits après avoir effectué le mouvement move*/
00063   virtual void update_conflicts(OpProblem* problem, Move* move);
00064 };
00065 
00066 /* CSPConfiguration : pour les CSP */
00068 class CSPConfiguration: public Configuration
00069 {
00070  public :
00071  int domainsize;
00072 
00073  CSPConfiguration(int nbvar, int domsize);
00074 };
00075 
00076 /* L'incrémentalité avec stockage de la participation à l'évaluation des valeurs courantes des 
00077 variables de la configuration : implanté dans tabconflicts (tableau  à une dimension) */
00080 class IncrCSPConfiguration : public CSPConfiguration
00081 { public : 
00082   int* tabconflicts;
00083   IncrCSPConfiguration (int nbvar);
00084   IncrCSPConfiguration(int nbvar, int nbcol);
00085   ~IncrCSPConfiguration();
00086   void copy_element (Configuration* config2);
00087   void init_conflicts ();
00088   void incr_conflicts (int var, int val , int index, int incr);
00089   void set_conflicts (int var, int val, int index,  int nbconf);
00090   int get_conflicts (int var, int val , int index);
00091   int get_conflicts_problem (OpProblem* problem, int var, int val);
00092   virtual  void set_variableconflicts (int var, int nbconf);
00093   void update_conflicts(OpProblem* problem, Move* move);                
00094 };
00095 
00096 /* l'incrémentalité totale : participation à l'évaluation de chaque
00097 valeur de chaque variable stockée dans le  tableau tabconflicts à deux dimensions (variable, indice de la valeur)*/
00101 class FullincrCSPConfiguration : public CSPConfiguration
00102 { public :
00103   int tabconflictsize;
00104   int** tabconflicts;
00105 
00106   FullincrCSPConfiguration(int nbvar, int domainsize);
00107   ~FullincrCSPConfiguration();
00108   void copy_element (Configuration* config2);
00109   void init_conflicts ();
00110   void incr_conflicts (int var, int val , int index, int incr);
00111   void set_conflicts (int var, int val, int index, int nbconf);
00112 /* nombre de conflits de (var,val) stocké : utilisation de l'indice de la valeur index*/
00114   int get_conflicts (int var, int val, int index);
00115   int get_conflicts_problem (OpProblem* problem, int var, int val);
00116   void update_conflicts(OpProblem* problem, Move* move);
00117 };
00118 
00119 /* classe Move */
00121 class Move 
00122 {public :
00123  int valuation;
00124  Move();
00125  virtual ~Move() {;};
00126 /* le test d'égalité d'un mouvement (utilisé pour la recherche d'un mouvement dans la liste taboue)*/
00128  virtual int eqmove(Move* move1);
00129 /* copie du mouvement move1 dans this */
00131  virtual void copymove(Move* move);
00132 /* le mouvement a mettre dans la liste taboue */
00134  virtual Move* computetabumove(Configuration* config){return 0;};
00135 };
00136 
00137 /* classe CSPMove :  un mouvement pour les CSP : variable , valeur */
00139 class CSPMove : public Move
00140 {public :
00141  int variable;
00142  int value;
00143  CSPMove();
00144  ~CSPMove() {;};
00145  int eqmove(Move* move);
00146  void copymove (Move* move);
00147 /* le mouvement stocké tabou est le mouvement inverse du mouvement effectué */
00149  Move* computetabumove(Configuration* config);
00150 };
00151 
00152 
00153 /* classe racine des problèmes d'optimisation (minimisation) */
00156 class OpProblem 
00157 {public :
00158 /* la meilleure configuration trouvée */
00160   Configuration* best_config;
00161 /* nombre de variables */
00163   int nbvar;  
00164 /* taille maximum des domaines */
00166   int domainsize;
00167 /* borne inférieure donnée au départ : sert de condition d'arrêt quand elle est atteinte */
00169   int lower_bound;
00170 /* le mouvement courant */
00172   Move* currentmove;
00173 /* le premier mouvement faisable essayé dans le voisinage*/
00175   Move* firstmove;
00176 /* le meilleur mouvement essayé */
00178   Move* bestmove;
00179   OpProblem(){};
00180   virtual ~OpProblem(){};
00181 /* exécution d'un mouvement (modification de la configuration courante) */
00183   virtual void move_execution(Configuration* configuration, Move* move);
00184 /* mise à jour de la structure des conflits (cas IncrCSPConfiguration) */
00186   virtual void incr_update_conflicts(IncrCSPConfiguration* configuration,Move* move){};
00187 /* mise à jour de la structure des conflits (cas FullincrCSPConfiguration) */
00189   virtual void fullincr_update_conflicts(FullincrCSPConfiguration* configuration,Move* move){};
00190 /* création des 3 objets Move (currentmove,bestmove,firstmove) */
00192   virtual void allocate_moves();
00193 /* création d'un mouvement (la classe du mouvement dépend du problène) : méthode implantée dans les sous-classes */
00196   virtual Move* create_move(){return 0;};
00197 /* ajustement des paramètres du voisinage (quand la taille du voisinage est supérieure à maxneighbors) */
00199   virtual void adjust_parameters(Configuration* configuration, int & maxneighbors, int & minneighbors){};
00200 /* prochain mouvement du voisinage à tester */
00202   virtual void next_move(Configuration* configuration, Move* move, NeighborhoodSearch* nbhs){}; 
00203 /* affectation aléatoire des variables d'une configuration */
00205   virtual void random_configuration(Configuration* configuration){};
00206 /* analyse da la meilleure solution */
00208   virtual void best_config_analysis(){};
00209 /* ecriture de la meilleure solution */
00211   virtual void best_config_write(){};
00212 
00213 /* vérification de la meilleure solution (recalcul de son coût) */
00215   virtual void best_config_verification();
00216 /* initialisation d'une population de taille populationsize */
00218   virtual void init_population (Configuration** population,int populationsize) {};
00219 /* création d'une configuration (la classe exacte dépend du problème) */
00221   virtual Configuration* create_configuration(){return 0;};
00222 /* calcul de la participation à l'évaluation de l'affectation (var,val) */
00224   virtual int compute_conflict (Configuration* configuration,int var, int val) {return 0;};
00225 /* évaluation d'une configuration */
00227   virtual int config_evaluation(Configuration* configuration) {return 0;};
00228 /* évaluation d'un mouvement move sur une configuration */
00230   virtual int move_evaluation (Configuration* configuration,Move* move){return 0;};
00231 /* passage de l'indice dans le domaine à la valeur */
00233   virtual int index2value (int index, int var) {return index;};
00234 /* passage d'une valeur à son indice dans le domaine de la variable */
00236   virtual int value2index(int value,int var) {return value;};
00237 /* calcule l'ensemble des variables en conflit de la configuration*/
00239   virtual void compute_var_conflict (Configuration* configuration) {};
00240   virtual int tabuindex(Move* move, Configuration* configuration) {return 0;};
00241   virtual int tabuinverseindex(Move* move, Configuration* configuration){return 0;};
00242   virtual int nbtabuindex(){return 0;};
00243 };
00244   
00245 /* Le voisinage paramétré d'une part par  min voisins explorés, 
00246 max voisins explorés et épuisement voisinage et d'autre part par var_conflict et val_conflict */
00249 class NeighborhoodSearch
00250 {public :
00251 /* nombre minimum de voisins explorés */
00253   int minneighbors;
00254 /* nombre maximum de voisins explorés */
00256   int maxneighbors;
00257 /* indicateur de comportement quand le voisinage est épuisé sans qu'un voisin n'ait été accepté :
00258 0 stagnation, 1 on effectue le 1er mouvement faisable, k on effectue le meilleur mouvement faisable parmi k mouvements essayés non acceptés*/
00261   int finished;
00262 /* indicateur de restriction aux variables en conflit (0 pas de restriction, 1 restriction) */
00264   int var_conflict;
00265 /* indicateur de restriction aux meilleures variables d'une variable (0 pas de restriction, 1 restriction) */
00267   int val_conflict;
00268   double nbhrate;
00269   NeighborhoodSearch( int maxneigh, int minneigh, int finish, int var_conf, int val_conf, double nbbr);
00270   int returnbestmove();
00271   void adjust_neighborhood(Configuration* configuration, OpProblem* problem, int& maxneigh, int& minneigh, int nbmoves);
00272   virtual void dynamicmaxneighbors(int & maxneigh, int & minneigh, int nbmoves);
00273   virtual void initsearch();
00274   virtual void spareneighboradjust(Configuration* config, Move* move){;}
00275 };
00276 
00277 
00278 /* Voisinage avec réglage dynamique du paramètre max-voisins*/
00280 class DynamicNeighborhoodSearch: public NeighborhoodSearch
00281 {public:
00282  DynamicNeighborhoodSearch(int maxneigh, int minneigh, int finish, int var_conf, int val_conf, double nbbr);
00283 /* valeur initiale du parametre maxneighbors */
00285  int initmaxneighbors;
00286 /* valeur initiale du parametre minneighbors */
00288  int initminneighbors;
00289 /* période de réajustement du paramètre */
00291  int adjustperiod;
00292  void initsearch();
00293 /* ajustement des paramètres minneighbors et maxneighbors */
00295  void dynamicmaxneighbors(int & maxneigh, int & minneigh, int nbmoves);
00296 };
00297 
00298 class DynamicSpareneighbor: public NeighborhoodSearch
00299 {public :
00300 DynamicSpareneighbor (int maxneigh, int minneigh, int finish, int var_conf, int val_conf, double nbbr);
00301 void spareneighboradjust(Configuration* config, Move* move);
00302 int nbmovesdown;
00303 };
00304 
00305 /* Les Algorithmes
00306 la classe mere : algo de recherche incomplet */
00309 class IncompleteAlgorithm
00310 {public :
00311   string methodname;
00312 /* un seuil peut être utilisé pour empêcher des mouvements de coût supérieur au seuil
00313 (utilisé dans les recherches locales des marches de GWW)*/
00315   int threshold;
00316   virtual ~IncompleteAlgorithm(){};
00317 /* marche d'une particule */
00319   virtual void randomwalk (OpProblem* problem, Configuration* configuration);
00320   virtual void initthreshold(Configuration** population, int popsize){;};
00321 /* exécution de l'algorithme sur une population (réduite à une particule pour une recherche locale) */
00323   virtual void run (OpProblem *problem,Configuration ** population);
00324 
00325 };
00326 
00327 /* la classe des algos de marche aléatoire paramétrée par longueur marche
00328 un voisinage et une metaheuristique */
00332 class LSAlgorithm: public IncompleteAlgorithm
00333 {public :
00334 /* longueur de la marche */
00336   int walklength;
00337 /* le voisinage */
00339   NeighborhoodSearch * nbhsearch;  
00340 /* la métaheuristique */
00342   Metaheuristic* mheur;
00343 /* le nombre d'essais de mouvements (pour les stats) */
00345   int nhtries;
00346   double avgnhtries;
00347   double avgsqnhtries;
00348 /* nombre de mouvements effectués */
00350   int nbmoves;
00351   LSAlgorithm(int nbmov);
00352   ~LSAlgorithm();
00353 /* faisabilité d'un mouvement  (sous ou au niveau du seuil pour marche de GWW) */
00355   virtual int isfeasible(Move* move);
00356   void randomwalk   (OpProblem* problem, Configuration* configuration);
00357 /* algorithme d'exploration du voisinage pour sélectionner et effectuer un mouvement à partir de la configuration courante
00358 Effectue le mouvement et renvoie 1 si un mvt a ete effectué et 0 si aucun mouvement ne l'a été*/
00361   virtual int configurationmove(OpProblem* problem,Configuration* configuration);
00362   void initthreshold(Configuration** population, int popsize);
00363   void run (OpProblem *problem, Configuration ** population);
00364 /* test de meilleur trouvé (renvoie 1 si un meilleur absolu est trouvé)*/
00366   int test_bestfound(Move* move);
00367 
00368 
00369 };
00370 
00371 class LSAlgorithmGWW: public LSAlgorithm
00372 {public :
00373  LSAlgorithmGWW(int nbmov);
00374  int isfeasible(Move* move);
00375 };
00376 
00377 /* les différentes métaheuristiques */
00379 class Metaheuristic
00380 {public :
00381   virtual ~Metaheuristic(){};
00382 /* mise à jour des données de la métaheuristique juste avant qu'un mouvement soit effectué */
00384   virtual void executebeforemove(Move* move, Configuration* configuration,OpProblem* problem);
00385 /* initialisation des données de la métaheuristique */
00387   virtual void reinit(OpProblem* problem);
00388 /* condition d'acceptation d'un mouvement : renvoie 1 si le mouvement est accepté */
00390   virtual int acceptance(Move* move,Configuration*  config);
00391   virtual void adjustparameter (int parameter) {;};
00392 };
00393 
00394 /* marche avec liste taboue : parametree par longueur de la liste : cette liste de mouvements est 
00395 implantee à l'aide d'une liste de Move* */
00398 class TabuSearch: public Metaheuristic
00399 {public :
00400 /* longueur maximale de la liste taboue */
00402   int tabulength;
00403 /* liste taboue : traitée comme une file */
00405   list<Move*> move_list;
00406   TabuSearch(int tabul);
00407 /* acceptation d'un mouvement : non tabou  (le critère d'aspiration est dans l'algo de recherche du voisin) */
00409   int acceptance (Move* move, Configuration* config);
00410 /* test de non présence dans la liste taboue : la présence d'un mvt est faite avec eqmove */
00412   int  nontabumove (Move* move);
00413 /* mise à jour de la liste taboue qui est traitée comme une file de longueur maximale tabulength */
00415   void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00416 /* réinitialisation : la liste taboue est vidée */
00418   void reinit(OpProblem* problem);
00419   void adjustparameter (int length);
00420 };
00421 
00422 class TabuGreedySearch: public TabuSearch
00423 {public :
00424   TabuGreedySearch(int tabul);
00425  int acceptance (Move* move, Configuration* config);
00426 };
00427 
00428 class IncrTabuSearch: public TabuSearch
00429 {public :
00430   IncrTabuSearch(int tabul);
00431   int nbiter;
00432   vector<int> tabutime;
00433   OpProblem* currentproblem;
00434   int  acceptance (Move* move, Configuration* config);
00435   void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00436   void reinit(OpProblem* problem);
00437 };
00438 
00439 class IncrTabuGreedySearch: public IncrTabuSearch
00440 {public :
00441   IncrTabuGreedySearch(int tabul);
00442  int acceptance (Move* move, Configuration* config);
00443 };
00444 
00445 /* marche Metropolis : un seul paramètre = temperature */
00447 class Metropolis: public Metaheuristic
00448 {public :
00449   double temperature;
00450   Metropolis(double temp);
00451 /* la formule classique de Metropolis d'acceptation d'un mouvement détériorant
00452 l'évaluation : probabilité p = exp (-evaluationdelta/temperature) */
00454   int acceptance (Move* move, Configuration* config);
00455   void adjustparameter(int parameter);
00456 };
00457 
00458 /* l'acceptation à seuil : un mouvement ne doit pas détériorer l'évaluation plus que le seuil courant ; 
00459 le seuil diminue linéairement de thresholdinit à 0*/
00460 
00463 class ThresholdAccepting: public Metaheuristic
00464 {public :
00465 /* seuil initial */
00467   double thresholdinit;
00468 /* pas de baisse du seuil */
00470   double delta;
00471 /* valeur courante du seuil */
00473   double thresholdaccept; // le seuil tel que géré par TA
00474 /* constructeur : 2 arguments seuil initial maxthreshold et nombre de pas, 
00475 le pas constant delta de baisse du seuil est calculé*/
00478   ThresholdAccepting(double maxthreshold, int walklength);
00479 /* condition d'acceptation : être sous ou au niveau du  seuil */
00481   int acceptance (Move* move,Configuration* config);
00482 /* le seuil est diminué de delta */
00484   void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00485 /* le seuil est initialisé à thresholdinit */
00487   void reinit(OpProblem* problem);
00488 };
00489 
00490 /* le recuit simulé : descente linéaire de température de inittemperature à 0 */
00492 class SimulatedAnnealing: public Metaheuristic
00493 {public :
00494 /* temperature initiale */
00496   double inittemperature;
00497 /* pas constant de baisse de temperature */
00499   double delta;
00500 /* temperature courante */
00502   double temperature; 
00503   int walklength; 
00504 /* Constructeur : 2 arguments : température initiale et longueur de marche */
00507   SimulatedAnnealing(double initialtemperature, int walklength);
00508 /* acceptation en fonction de la temperature : formule classique du recuit simulé 
00509 probablité d'acceptation d'un mouvement détériorant l'évaluation :
00510 probabilité =  exp (-evaluationdelta/temperature) */
00511 
00514   int acceptance (Move* move, Configuration* config);
00515 /* la température est baissée de delta */
00517   void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00518   void reinit(OpProblem* problem);
00519   void adjustparameter (int parameter);
00520 };
00521 
00522 
00523 /* marche hybride tabou + pourcentages d'acceptation selon sens des mouvements */
00527 //                          liste taboue 
00528 
00529 class TabuAcceptingrate: public TabuSearch
00530 {public :
00531    /* probabilité d'acceptation d'un mauvais   */
00533   float Pd;       
00534   /* probabilité d'acceptatiion d'un mouvement de même coût que le courant */
00536   float P0;        
00537   TabuAcceptingrate(int tabul, float Pd, float P0);
00538 /* critère d'acceptation : non tabou et pourcentages d'acceptation suivant sens du mouvement (détériorant, neutre, améliorant) */
00540   int acceptance (Move* move, Configuration* config);
00541 };
00542 
00543 
00544 /* marche aléatoire : tout voisin faisable est accepté */
00546 class RandomSearch: public Metaheuristic
00547 {public :
00548   RandomSearch();
00549   int acceptance (Move* move, Configuration* config);
00550 };
00551 
00552 /* marche gloutonne : on accepte un voisin de cout inférieur ou égal à la configuration courante*/
00554 class GreedySearch: public Metaheuristic
00555 {public :
00556   GreedySearch();
00557   int acceptance (Move* move, Configuration* config);
00558 };
00559 
00560 //-------------------------------------------------------------------------------------------------
00561 
00562 
00563 /* les algos de type GWW 
00564  les différentes sous classes diffèrent par la gestion du seuil
00565 et les regroupements de particules */
00566 
00570 class GWWAlgorithm: public IncompleteAlgorithm
00571 {public :
00572 /* nombre de particules */
00574   int populationsize;
00575 /* indicateur de marche uniquement si la particule a été regroupée 
00576 (utile pour GWW de base, sans recherche locale, uniquement) (1 oui, 0 non) */
00579   int regrouptest;
00580 /* indicateur de baisse du seuil au dernier mouvement de la marche (pour essayer d'empecher la particule d' etre redistribuée) (1 oui, 0 non) */
00583   int lastmovedescent;
00584 /* indicateur d'élitisme : remet-on le meilleur individu dans la population à chaque regroupement (1 oui, 0 non) */
00586   int elitism;
00587 /* indicateur d'arrêt de la marche en cas de stagnation (1 oui, 0 non) */
00589   int nomovestop;
00590 /* le décrément du seuil (calculé par thresholdcomputedelta) */
00592   int thresholddelta;
00593 /* le nombre d'iterations max : utile quand pas de seuil (NothresholdGWWAlgorithm) */
00595   int nbiteration;
00596 /* le nombre de changements de seuil (pour les statistiques) */
00598   int thresholdchanges;
00599 /* le nombre total d'essais de mouvements entre 2 regroupements (pour les statistiques)*/
00601   int total_nhtries;
00602 /* le nombre total de mouvements entre 2 regroupements (pour les statistiques)*/
00604   int total_nbmoves;
00605 /* l'algorithme de recherche locale utilisé */
00607   LSAlgorithm* walkalgorithm;
00608 /* destructeur */
00609   ~GWWAlgorithm();
00610 /* recherche locale sur l'ensemble de la population */
00612   virtual  void populationrandomwalk (OpProblem* problem, Configuration** population);
00613 /* le nombre de particules au seuil (pour les statistiques),  la population étant déjà triée à l'appel */
00615   virtual int nb_threshold_population(Configuration** population);
00616 /* une recherche locale pour une particule */
00618   void randomwalk   (OpProblem* problem, Configuration* configuration);
00619 /* initialisation du seuil */
00621   void initthreshold(Configuration** population, int popsize);
00622 /* méthode de baisse du seuil (le delta a déjà été calculé)*/
00624   virtual void thresholdupdate();
00625 /* méthode de calcul du décrément du seuil */
00627   virtual void thresholdcomputedelta(Configuration** population);
00628 /* déroulement de l'algorithme */
00630   void run (OpProblem *problem, Configuration** population);
00631 /* regroupement des mauvais individus sur les bons */
00633   virtual  void regrouping(Configuration** population);
00634 /* en cas d'élitisme, on remet le meilleur dans la population */
00636   void populationkeepbest (OpProblem* problem, Configuration** population);
00637 /* incremente le compteur de changements de seuil (pour les statistiques) */
00639   virtual  void thresholdchangesupdate();
00640 };
00641 
00642 /* Classe abstraite : GWW avec seuil */
00644 class ThresholdGWWAlgorithm : public GWWAlgorithm
00645 {public :
00646   void thresholdupdate();
00647 void thresholdchangesupdate();
00648 void initthreshold(Configuration** population, int popsize);
00649 int nb_threshold_population(Configuration** population);
00650 };
00651 
00652 
00653 /* GWW standard : descente du seuil avec taux fixe */
00655 class StandardGWWAlgorithm : public ThresholdGWWAlgorithm
00656 {public :
00657 /* taux de baisse du seuil */
00659   double thresholddescent;
00660 /* seuil minimum (correspond en général à une borne inférieure connue) */
00662   int thresholdmin;  
00663   void regrouping(Configuration** population);
00664   StandardGWWAlgorithm(int population_size, int grtest,int lastmove, int elitisme,int stop, double thresdescent,int threshmin );
00665   void thresholdcomputedelta(Configuration** population);
00666 };
00667 
00668 /* GWW descente du seuil au moins au niveau du pire */
00670 class FastStandardGWWAlgorithm: public StandardGWWAlgorithm
00671 {public :
00672    void thresholdcomputedelta(Configuration** population);
00673    FastStandardGWWAlgorithm(int population_size, int grtest,int lastmove, int elitisme, int stop, double thresdescent,int threshmin );  
00674 };
00675 
00676 /* GWW avec descente su seuil en tuant un nombre donné de particules à chaque fois */
00678 class AdaptiveGWWAlgorithm : public ThresholdGWWAlgorithm
00679 { public :
00680 /* nombre de mauvaises particules à regrouper sur les bonnes */
00682   int nbkilled;
00683   AdaptiveGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, int nbkilled );
00684   void regrouping(Configuration** population);
00685   void thresholdcomputedelta(Configuration** population);
00686 };
00687 
00688 /* GWW avec descente du seuil au plus bas des valeurs de seuil obtenues par AdaptiveGWWAlgorithm et FastStandardGWWAlgorithm
00689  (un nombre de particules et un taux) */
00692 class FastAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00693 {public :
00694 /* taux de descente du seuil */
00696   double thresholddescent;
00697   int nbmaxkilled;
00698   FastAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, int nbkilled, int maxkilled, double thresholddescent);
00699   void thresholdcomputedelta(Configuration** population);
00700 };
00701 
00702 /* GWW avec descente du seuil en fonction du médian de la population*/
00704 class MedianAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00705 {public :
00706 /* taux de baisse du seuil : fraction de la distance entre la pire et la médiane (entre 0 et 1) */
00708   double mediandescent;
00709   MedianAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, double mediandescent);
00710   void thresholdcomputedelta(Configuration** population);
00711 };
00712 
00713 /* GWW avec descente du seuil en fonction du meilleur de la population*/
00715 class BestAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00716 {public :
00717 /* taux de baisse du seuil : fraction de la distance entre la pire et la meilleure (entre 0 et 1) */
00720   double bestdescent;
00721   BestAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, double bestdescent);
00722   void thresholdcomputedelta(Configuration** population);
00723 };
00724 
00725 
00726 
00727 /* GWW sans seuil : 2 paramètres : nombre de tués à chaque itération, nombre d'itérations */
00729 class NothresholdGWWAlgorithm : public GWWAlgorithm 
00730 {public :
00731   NothresholdGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop,
00732         int killed,  int nbiter);
00733   void regrouping(Configuration** population);
00734 /* nombre de particules à regrouper à chaque itération */
00736   int nbkilled;
00737 };
00738 
00739 
00740 
00741 

Generated on Wed Sep 15 17:58:38 2004 for INCOP by doxygen 1.3.5