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

incop.h

00001 
00002 /* the definitions of classes of the algorithmic part + OpProblem */
00003 
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 /* les valeurs courantes des variables : implanté sous forme de tableau d'entiers*/
00024   int* config;
00025 /* la valeur de la configuration */
00027   int valuation;
00028 /* les variables participant à un conflit : implanté sous forme de vecteur */
00030   vector<int> var_conflict;     
00031 /* indicateur si la configuration a été regroupée (pour GWW) */
00033   int regrouped;
00034   virtual ~Configuration();
00035   Configuration();
00036   Configuration(int nbvar);
00037 /* copie d'une configuration config2 dans this*/
00039   virtual void copy_element (Configuration* config2);
00040 /* initialisation à 0 de la structure de données des conflits */
00042   virtual void init_conflicts ();
00043 /* stockage de l'augmentation des conflits de (var,val) de incr */
00045   virtual void incr_conflicts (int var, int val, int index, int incr);
00046 
00047 /* stockage du nombre des conflits nbconf de (var,val)  */
00049   virtual  void set_conflicts (int var, int val, int index, int nbconf);
00050 
00051 /* nombre de conflits de (var,val) stocké */
00053   virtual  int get_conflicts (int var, int val, int index);
00054 /* nombre de conflits de (var,val) , au besoin recalculé */
00056   virtual  int get_conflicts_problem (OpProblem* problem, int var, int val);
00057 
00058 /* mise à jour des conflits après avoir effectué le mouvement move*/
00060   virtual void update_conflicts(OpProblem* problem, Move* move);
00061 };
00062 
00063 /* CSPConfiguration : pour les CSP */
00065 class CSPConfiguration: public Configuration
00066 {
00067  public :
00068  CSPConfiguration (int nbvar);
00069  CSPConfiguration(int nbvar, int nbcol);
00070 };
00071 
00072 /* L'incrémentalité avec stockage de la participation à l'évaluation des valeurs courantes des 
00073 variables de la configuration : implanté dans tabconflicts (tableau  à une dimension) */
00076 class IncrCSPConfiguration : public CSPConfiguration
00077 { public : 
00078   int* tabconflicts;
00079   IncrCSPConfiguration (int nbvar);
00080   IncrCSPConfiguration(int nbvar, int nbcol);
00081   ~IncrCSPConfiguration();
00082   void copy_element (Configuration* config2);
00083   void init_conflicts ();
00084   void incr_conflicts (int var, int val , int index, int incr);
00085   void set_conflicts (int var, int val, int index,  int nbconf);
00086   int get_conflicts (int var, int val , int index);
00087   int get_conflicts_problem (OpProblem* problem, int var, int val);
00088   virtual  void set_variableconflicts (int var, int nbconf);
00089   void update_conflicts(OpProblem* problem, Move* move);                
00090 };
00091 
00092 /* l'incrémentalité totale : participation à l'évaluation de chaque
00093 valeur de chaque variable stockée dans le  tableau tabconflicts à deux dimensions (variable, indice de la valeur)*/
00097 class FullincrCSPConfiguration : public CSPConfiguration
00098 { public :
00099   int tabconflictsize;
00100   int** tabconflicts;
00101   FullincrCSPConfiguration(int nbvar, int domainsize);
00102   ~FullincrCSPConfiguration();
00103   void copy_element (Configuration* config2);
00104   void init_conflicts ();
00105   void incr_conflicts (int var, int val , int index, int incr);
00106   void set_conflicts (int var, int val, int index, int nbconf);
00107 /* nombre de conflits de (var,val) stocké : utilisation de l'indice de la valeur index*/
00109   int get_conflicts (int var, int val, int index);
00110   int get_conflicts_problem (OpProblem* problem, int var, int val);
00111   void update_conflicts(OpProblem* problem, Move* move);
00112 };
00113 
00114 /* classe Move */
00116 class Move 
00117 {public :
00118  int valuation;
00119  Move();
00120  virtual ~Move() {;};
00121 /* le test d'égalité d'un mouvement (utilisé pour la recherche d'un mouvement dans la liste taboue)*/
00123  virtual int eqmove(Move* move1);
00124 /* copie du mouvement move1 dans this */
00126  virtual void copymove(Move* move);
00127 /* le mouvement a mettre dans la liste taboue */
00129  virtual Move* computetabumove(Configuration* config){return 0;};
00130 };
00131 
00132 /* classe CSPMove :  un mouvement pour les CSP : variable , valeur */
00134 class CSPMove : public Move
00135 {public :
00136  int variable;
00137  int value;
00138  CSPMove();
00139  ~CSPMove() {;};
00140  int eqmove(Move* move);
00141  void copymove (Move* move);
00142 /* le mouvement stocké tabou est le mouvement inverse du mouvement effectué */
00144  Move* computetabumove(Configuration* config);
00145 };
00146 
00147 
00148 /* classe racine des problèmes d'optimisation (minimisation) */
00151 class OpProblem 
00152 {public :
00153 /* la meilleure configuration trouvée */
00155   Configuration* best_config;
00156 /* nombre de variables */
00158   int nbvar;  
00159 /* borne inférieure donnée au départ : sert de condition d'arrêt quand elle est atteinte */
00161   int lower_bound;
00162 /* le mouvement courant */
00164   Move* currentmove;
00165 /* le premier mouvement faisable essayé dans le voisinage*/
00167   Move* firstmove;
00168 /* le meilleur mouvement essayé */
00170   Move* bestmove;
00171   OpProblem(){};
00172   virtual ~OpProblem(){};
00173 /* exécution d'un mouvement (modification de la configuration courante) */
00175   virtual void move_execution(Configuration* configuration, Move* move);
00176 /* mise à jour de la structure des conflits (cas IncrCSPConfiguration) */
00178   virtual void incr_update_conflicts(IncrCSPConfiguration* configuration,Move* move){};
00179 /* mise à jour de la structure des conflits (cas FullincrCSPConfiguration) */
00181   virtual void fullincr_update_conflicts(FullincrCSPConfiguration* configuration,Move* move){};
00182 /* création des 3 objets Move (currentmove,bestmove,firstmove) */
00184   virtual void allocate_moves();
00185 /* création d'un mouvement (la classe du mouvement dépend du problène) : méthode implantée dans les sous-classes */
00188   virtual Move* create_move(){return 0;};
00189 /* ajustement des paramètres du voisinage (quand la taille du voisinage est supérieure à maxneighbors) */
00191   virtual void adjust_parameters(Configuration* configuration, int & maxneighbors, int & minneighbors){};
00192 /* prochain mouvement du voisinage à tester */
00194   virtual void next_move(Configuration* configuration, Move* move, NeighborhoodSearch* nbhs){}; 
00195 /* affectation aléatoire des variables d'une configuration */
00197   virtual void random_configuration(Configuration* configuration){};
00198 /* analyse da la meilleure solution */
00200   virtual void best_config_analysis(){};
00201 /* ecriture de la meilleure solution */
00203   virtual void best_config_write(){};
00204 
00205 /* vérification de la meilleure solution (recalcul de son coût) */
00207   virtual void best_config_verification();
00208 /* initialisation d'une population de taille populationsize */
00210   virtual void init_population (Configuration** population,int populationsize) {};
00211 /* création d'une configuration (la classe exacte dépend du problème) */
00213   virtual Configuration* create_configuration(){return 0;};
00214 /* calcul de la participation à l'évaluation de l'affectation (var,val) */
00216   virtual int compute_conflict (Configuration* configuration,int var, int val) {return 0;};
00217 /* évaluation d'une configuration */
00219   virtual int config_evaluation(Configuration* configuration) {return 0;};
00220 /* évaluation d'un mouvement move sur une configuration */
00222   virtual int move_evaluation (Configuration* configuration,Move* move){return 0;};
00223 /* passage de l'indice dans le domaine à la valeur */
00225   virtual int index2value (int index, int var) {return index;};
00226 /* passage d'une valeur à son indice dans le domaine de la variable */
00228   virtual int value2index(int value,int var) {return value;};
00229 /* calcule l'ensemble des variables en conflit de la configuration*/
00231   virtual void compute_var_conflict (Configuration* configuration) {};
00232 };
00233   
00234 /* Le voisinage paramétré d'une part par  min voisins explorés, 
00235 max voisins explorés et épuisement voisinage et d'autre part par var_conflict et val_conflict */
00238 class NeighborhoodSearch
00239 {public :
00240 /* nombre minimum de voisins explorés */
00242   int minneighbors;
00243 /* nombre maximum de voisins explorés */
00245   int maxneighbors;
00246 /* indicateur de comportement quand le voisinage est épuisé sans qu'un voisin n'ait été accepté :
00247 0 stagnation, 1 on effectue le 1er mouvement faisable, 2 on effectue le meilleur mouvement faisable */
00250   int finished;
00251 /* indicateur de restriction aux variables en conflit (0 pas de restriction, 1 restriction) */
00253   int var_conflict;
00254 /* indicateur de restriction aux meilleures variables d'une variable (0 pas de restriction, 1 restriction) */
00256   int val_conflict;
00257   NeighborhoodSearch( int maxneigh, int minneigh, int finish, int var_conf, int val_conf);
00258   int returnbestmove();
00259 };
00260 
00261 
00262 /* Les Algorithmes
00263 la classe mere : algo de recherche incomplet */
00266 class IncompleteAlgorithm
00267 {public :
00268   string methodname;
00269 /* un seuil peut être utilisé pour empêcher des mouvements de coût supérieur au seuil
00270 (utilisé dans les recherches locales des marches de GWW)*/
00272   int threshold;
00273   virtual ~IncompleteAlgorithm(){};
00274 /* marche d'une particule */
00276   virtual void randomwalk (OpProblem* problem, Configuration* configuration);
00277   virtual void initthreshold(Configuration** population, int popsize){;};
00278 /* exécution de l'algorithme sur une population (réduite à une particule pour une recherche locale) */
00280   virtual void run (OpProblem *problem,Configuration ** population);
00281 
00282 };
00283 
00284 /* la classe des algos de marche aléatoire paramétrée par longueur marche
00285 un voisinage et une metaheuristique */
00289 class LSAlgorithm: public IncompleteAlgorithm
00290 {public :
00291 /* longueur de la marche */
00293   int walklength;
00294 /* le voisinage */
00296   NeighborhoodSearch * nbhsearch;  
00297 /* la métaheuristique */
00299   Metaheuristic* mheur;
00300 /* le nombre d'essais de mouvements (pour les stats) */
00302   int nhtries;
00303   double avgnhtries;
00304   double avgsqnhtries;
00305 /* nombre de mouvements effectués */
00307   int nbmoves;
00308   LSAlgorithm(int nbmov);
00309   ~LSAlgorithm();
00310 /* faisabilité d'un mouvement  (sous ou au niveau du seuil pour marche de GWW) */
00312   virtual int isfeasible(Move* move);
00313   void randomwalk   (OpProblem* problem, Configuration* configuration);
00314 /* algorithme d'exploration du voisinage pour sélectionner et effectuer un mouvement à partir de la configuration courante
00315 Effectue le mouvement et renvoie 1 si un mvt a ete effectué et 0 si aucun mouvement ne l'a été*/
00318   virtual int configurationmove(OpProblem* problem,Configuration* configuration);
00319   void initthreshold(Configuration** population, int popsize);
00320   void run (OpProblem *problem, Configuration ** population);
00321 /* test de meilleur trouvé (renvoie 1 si un meilleur absolu est trouvé)*/
00323   int test_bestfound( int value, int nbmov);
00324 
00325 };
00326 
00327 /* les différentes métaheuristiques */
00329 class Metaheuristic
00330 {public :
00331   virtual ~Metaheuristic(){};
00332 /* mise à jour des données de la métaheuristique juste avant qu'un mouvement soit effectué */
00334   virtual void executebeforemove(Move* move, Configuration* configuration,OpProblem* problem);
00335 /* initialisation des données de la métaheuristique */
00337   virtual void reinit();
00338 /* condition d'acceptation d'un mouvement : renvoie 1 si le mouvement est accepté */
00340   virtual int acceptance(Move* move,Configuration*  config);
00341 };
00342 
00343 /* marche avec liste taboue : parametree par longueur de la liste : cette liste de mouvements est 
00344 implantee à l'aide d'une liste de Move* */
00347 class TabuSearch: public Metaheuristic
00348 {public :
00349 /* longueur maximale de la liste taboue */
00351   int tabulength;
00352 /* liste taboue : traitée comme une file */
00354   list<Move*> move_list;
00355   TabuSearch(int tabul);
00356 /* acceptation d'un mouvement : non tabou  (le critère d'aspiration est dans l'algo de recherche du voisin) */
00358   int acceptance (Move* move, Configuration* config);
00359 /* test de non présence dans la liste taboue : la présence d'un mvt est faite avec eqmove */
00361   int  nontabumove (Move* move);
00362 /* mise à jour de la liste taboue qui est traitée comme une file de longueur maximale tabulength */
00364   void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00365 /* réinitialisation : la liste taboue est vidée */
00367   void reinit();
00368 };
00369 
00370 /* marche Metropolis : un seul paramètre = temperature */
00372 class Metropolis: public Metaheuristic
00373 {public :
00374   double temperature;
00375   Metropolis(double temp);
00376 /* la formule classique de Metropolis d'acceptation d'un mouvement détériorant
00377 l'évaluation : probabilité p = exp (-evaluationdelta/temperature) */
00379   int acceptance (Move* move, Configuration* config);
00380 };
00381 
00382 /* l'acceptation à seuil : un mouvement ne doit pas détériorer l'évaluation plus que le seuil courant ; 
00383 le seuil diminue linéairement de thresholdinit à 0*/
00384 
00387 class ThresholdAccepting: public Metaheuristic
00388 {public :
00389 /* seuil initial */
00391   double thresholdinit;
00392 /* pas de baisse du seuil */
00394   double delta;
00395 /* valeur courante du seuil */
00397   double thresholdaccept; // le seuil tel que géré par TA
00398 /* constructeur : 2 arguments seuil initial maxthreshold et nombre de pas, 
00399 le pas constant delta de baisse du seuil est calculé*/
00402   ThresholdAccepting(double maxthreshold, int walklength);
00403 /* condition d'acceptation : être sous ou au niveau du  seuil */
00405   int acceptance (Move* move,Configuration* config);
00406 /* le seuil est diminué de delta */
00408   void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00409 /* le seuil est initialisé à thresholdinit */
00411   void reinit();
00412 };
00413 
00414 /* le recuit simulé : descente linéaire de température de inittemperature à 0 */
00416 class SimulatedAnnealing: public Metaheuristic
00417 {public :
00418 /* temperature initiale */
00420   double inittemperature;
00421 /* pas constant de baisse de temperature */
00423   double delta;
00424 /* temperature courante */
00426   double temperature; 
00427 /* Constructeur : 2 arguments : température initiale et longueur de marche */
00430   SimulatedAnnealing(double initialtemperature, int walklength);
00431 /* acceptation en fonction de la temperature : formule classique du recuit simulé 
00432 probablité d'acceptation d'un mouvement détériorant l'évaluation :
00433 probabilité =  exp (-evaluationdelta/temperature) */
00434 
00437   int acceptance (Move* move, Configuration* config);
00438 /* la température est baissée de delta */
00440   void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00441   void reinit();
00442 };
00443 
00444 
00445 /* marche hybride tabou + pourcentages d'acceptation selon sens des mouvements */
00449 //                          liste taboue 
00450 
00451 class TabuAcceptingrate: public TabuSearch
00452 {public :
00453    /* probabilité d'acceptation d'un mauvais   */
00455   float Pd;       
00456   /* probabilité d'acceptatiion d'un mouvement de même coût que le courant */
00458   float P0;        
00459   TabuAcceptingrate(int tabul, float Pd, float P0);
00460 /* critère d'acceptation : non tabou et pourcentages d'acceptation suivant sens du mouvement (détériorant, neutre, améliorant) */
00462   int acceptance (Move* move, Configuration* config);
00463 };
00464 
00465 
00466 /* marche aléatoire : tout voisin faisable est accepté */
00468 class RandomSearch: public Metaheuristic
00469 {public :
00470   RandomSearch();
00471   int acceptance (Move* move, Configuration* config);
00472 };
00473 
00474 /* marche gloutonne : on accepte un voisin de cout inférieur ou égal à la configuration courante*/
00476 class GreedySearch: public Metaheuristic
00477 {public :
00478   GreedySearch();
00479   int acceptance (Move* move, Configuration* config);
00480 };
00481 
00482 //-------------------------------------------------------------------------------------------------
00483 
00484 
00485 /* les algos de type GWW 
00486  les différentes sous classes diffèrent par la gestion du seuil
00487 et les regroupements de particules */
00488 
00492 class GWWAlgorithm: public IncompleteAlgorithm
00493 {public :
00494 /* nombre de particules */
00496   int populationsize;
00497 /* indicateur de marche uniquement si la particule a été regroupée 
00498 (utile pour GWW de base, sans recherche locale, uniquement) (1 oui, 0 non) */
00501   int regrouptest;
00502 /* 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) */
00505   int lastmovedescent;
00506 /* indicateur d'élitisme : remet-on le meilleur individu dans la population à chaque regroupement (1 oui, 0 non) */
00508   int elitism;
00509 /* indicateur d'arrêt de la marche en cas de stagnation (1 oui, 0 non) */
00511   int nomovestop;
00512 /* le décrément du seuil (calculé par thresholdcomputedelta) */
00514   int thresholddelta;
00515 /* le nombre d'iterations max : utile quand pas de seuil (NothresholdGWWAlgorithm) */
00517   int nbiteration;
00518 /* le nombre de changements de seuil (pour les statistiques) */
00520   int thresholdchanges;
00521 /* le nombre total d'essais de mouvements entre 2 regroupements (pour les statistiques)*/
00523   int total_nhtries;
00524 /* le nombre total de mouvements entre 2 regroupements (pour les statistiques)*/
00526   int total_nbmoves;
00527 /* l'algorithme de recherche locale utilisé */
00529   LSAlgorithm* walkalgorithm;
00530 /* destructeur */
00531   ~GWWAlgorithm();
00532 /* recherche locale sur l'ensemble de la population */
00534   virtual  void populationrandomwalk (OpProblem* problem, Configuration** population);
00535 /* le nombre de particules au seuil (pour les statistiques),  la population étant déjà triée à l'appel */
00537   virtual int nb_threshold_population(Configuration** population);
00538 /* une recherche locale pour une particule */
00540   void randomwalk   (OpProblem* problem, Configuration* configuration);
00541 /* initialisation du seuil */
00543   void initthreshold(Configuration** population, int popsize);
00544 /* méthode de baisse du seuil (le delta a déjà été calculé)*/
00546   virtual void thresholdupdate();
00547 /* méthode de calcul du décrément du seuil */
00549   virtual void thresholdcomputedelta(Configuration** population);
00550 /* déroulement de l'algorithme */
00552   void run (OpProblem *problem, Configuration** population);
00553 /* regroupement des mauvais individus sur les bons */
00555   virtual  void regrouping(Configuration** population);
00556 /* en cas d'élitisme, on remet le meilleur dans la population */
00558   void populationkeepbest (OpProblem* problem, Configuration** population);
00559 /* incremente le compteur de changements de seuil (pour les statistiques) */
00561   virtual  void thresholdchangesupdate();
00562 };
00563 
00564 /* Classe abstraite : GWW avec seuil */
00566 class ThresholdGWWAlgorithm : public GWWAlgorithm
00567 {public :
00568   void thresholdupdate();
00569 void thresholdchangesupdate();
00570 void initthreshold(Configuration** population, int popsize);
00571 int nb_threshold_population(Configuration** population);
00572 };
00573 
00574 
00575 /* GWW standard : descente du seuil avec taux fixe */
00577 class StandardGWWAlgorithm : public ThresholdGWWAlgorithm
00578 {public :
00579 /* taux de baisse du seuil */
00581   double thresholddescent;
00582 /* seuil minimum (correspond en général à une borne inférieure connue) */
00584   int thresholdmin;  
00585   void regrouping(Configuration** population);
00586   StandardGWWAlgorithm(int population_size, int grtest,int lastmove, int elitisme,int stop, double thresdescent,int threshmin );
00587   void thresholdcomputedelta(Configuration** population);
00588 };
00589 
00590 /* GWW descente du seuil au moins au niveau du pire */
00592 class FastStandardGWWAlgorithm: public StandardGWWAlgorithm
00593 {public :
00594    void thresholdcomputedelta(Configuration** population);
00595    FastStandardGWWAlgorithm(int population_size, int grtest,int lastmove, int elitisme, int stop, double thresdescent,int threshmin );  
00596 };
00597 
00598 /* GWW avec descente su seuil en tuant un nombre donné de particules à chaque fois */
00600 class AdaptiveGWWAlgorithm : public ThresholdGWWAlgorithm
00601 { public :
00602 /* nombre de mauvaises particules à regrouper sur les bonnes */
00604   int nbkilled;
00605   AdaptiveGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, int nbkilled );
00606   void regrouping(Configuration** population);
00607   void thresholdcomputedelta(Configuration** population);
00608 };
00609 
00610 /* GWW avec descente du seuil au plus bas des valeurs de seuil obtenues par AdaptiveGWWAlgorithm et FastStandardGWWAlgorithm
00611  (un nombre de particules et un taux) */
00614 class FastAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00615 {public :
00616 /* taux de descente du seuil */
00618   double thresholddescent;
00619   int nbmaxkilled;
00620   FastAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, int nbkilled, int maxkilled, double thresholddescent);
00621   void thresholdcomputedelta(Configuration** population);
00622 };
00623 
00624 /* GWW avec descente du seuil en fonction du médian de la population*/
00626 class MedianAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00627 {public :
00628 /* taux de baisse du seuil : fraction de la distance entre la pire et la médiane (entre 0 et 1) */
00630   double mediandescent;
00631   MedianAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, double mediandescent);
00632   void thresholdcomputedelta(Configuration** population);
00633 };
00634 
00635 /* GWW avec descente du seuil en fonction du meilleur de la population*/
00637 class BestAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00638 {public :
00639 /* taux de baisse du seuil : fraction de la distance entre la pire et la meilleure (entre 0 et 1) */
00642   double bestdescent;
00643   BestAdaptGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop, double bestdescent);
00644   void thresholdcomputedelta(Configuration** population);
00645 };
00646 
00647 
00648 
00649 /* GWW sans seuil : 2 paramètres : nombre de tués à chaque itération, nombre d'itérations */
00651 class NothresholdGWWAlgorithm : public GWWAlgorithm 
00652 {public :
00653   NothresholdGWWAlgorithm(int population_size, int grtest, int lastmove, int elitisme, int stop,
00654         int killed,  int nbiter);
00655   void regrouping(Configuration** population);
00656 /* nombre de patricules à regrouper à chaque itération */
00658   int nbkilled;
00659 };
00660 
00661 
00662 
00663 

Generated on Fri Sep 26 17:27:25 2003 for INCOP by doxygen 1.3.3