00001
00002
00003
00004
00005 class OpProblem;
00006 class IncompleteAlgorithm;
00007 class Metaheuristic;
00008 class NeighborhoodSearch;
00009 class Move;
00010
00011
00012
00013
00014
00015
00018 class Configuration
00019
00020 {public :
00021 int nbvar;
00022
00024 int* config;
00025
00027 int valuation;
00028
00030 vector<int> var_conflict;
00031
00033 int regrouped;
00034 virtual ~Configuration();
00035 Configuration();
00036 Configuration(int nbvar);
00037
00039 virtual void copy_element (Configuration* config2);
00040
00042 virtual void init_conflicts ();
00043
00045 virtual void incr_conflicts (int var, int val, int index, int incr);
00046
00047
00049 virtual void set_conflicts (int var, int val, int index, int nbconf);
00050
00051
00053 virtual int get_conflicts (int var, int val, int index);
00054
00056 virtual int get_conflicts_problem (OpProblem* problem, int var, int val);
00057
00058
00060 virtual void update_conflicts(OpProblem* problem, Move* move);
00061 };
00062
00063
00065 class CSPConfiguration: public Configuration
00066 {
00067 public :
00068 CSPConfiguration (int nbvar);
00069 CSPConfiguration(int nbvar, int nbcol);
00070 };
00071
00072
00073
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
00093
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
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
00116 class Move
00117 {public :
00118 int valuation;
00119 Move();
00120 virtual ~Move() {;};
00121
00123 virtual int eqmove(Move* move1);
00124
00126 virtual void copymove(Move* move);
00127
00129 virtual Move* computetabumove(Configuration* config){return 0;};
00130 };
00131
00132
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
00144 Move* computetabumove(Configuration* config);
00145 };
00146
00147
00148
00151 class OpProblem
00152 {public :
00153
00155 Configuration* best_config;
00156
00158 int nbvar;
00159
00161 int lower_bound;
00162
00164 Move* currentmove;
00165
00167 Move* firstmove;
00168
00170 Move* bestmove;
00171 OpProblem(){};
00172 virtual ~OpProblem(){};
00173
00175 virtual void move_execution(Configuration* configuration, Move* move);
00176
00178 virtual void incr_update_conflicts(IncrCSPConfiguration* configuration,Move* move){};
00179
00181 virtual void fullincr_update_conflicts(FullincrCSPConfiguration* configuration,Move* move){};
00182
00184 virtual void allocate_moves();
00185
00188 virtual Move* create_move(){return 0;};
00189
00191 virtual void adjust_parameters(Configuration* configuration, int & maxneighbors, int & minneighbors){};
00192
00194 virtual void next_move(Configuration* configuration, Move* move, NeighborhoodSearch* nbhs){};
00195
00197 virtual void random_configuration(Configuration* configuration){};
00198
00200 virtual void best_config_analysis(){};
00201
00203 virtual void best_config_write(){};
00204
00205
00207 virtual void best_config_verification();
00208
00210 virtual void init_population (Configuration** population,int populationsize) {};
00211
00213 virtual Configuration* create_configuration(){return 0;};
00214
00216 virtual int compute_conflict (Configuration* configuration,int var, int val) {return 0;};
00217
00219 virtual int config_evaluation(Configuration* configuration) {return 0;};
00220
00222 virtual int move_evaluation (Configuration* configuration,Move* move){return 0;};
00223
00225 virtual int index2value (int index, int var) {return index;};
00226
00228 virtual int value2index(int value,int var) {return value;};
00229
00231 virtual void compute_var_conflict (Configuration* configuration) {};
00232 };
00233
00234
00235
00238 class NeighborhoodSearch
00239 {public :
00240
00242 int minneighbors;
00243
00245 int maxneighbors;
00246
00247
00250 int finished;
00251
00253 int var_conflict;
00254
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
00263
00266 class IncompleteAlgorithm
00267 {public :
00268 string methodname;
00269
00270
00272 int threshold;
00273 virtual ~IncompleteAlgorithm(){};
00274
00276 virtual void randomwalk (OpProblem* problem, Configuration* configuration);
00277 virtual void initthreshold(Configuration** population, int popsize){;};
00278
00280 virtual void run (OpProblem *problem,Configuration ** population);
00281
00282 };
00283
00284
00285
00289 class LSAlgorithm: public IncompleteAlgorithm
00290 {public :
00291
00293 int walklength;
00294
00296 NeighborhoodSearch * nbhsearch;
00297
00299 Metaheuristic* mheur;
00300
00302 int nhtries;
00303 double avgnhtries;
00304 double avgsqnhtries;
00305
00307 int nbmoves;
00308 LSAlgorithm(int nbmov);
00309 ~LSAlgorithm();
00310
00312 virtual int isfeasible(Move* move);
00313 void randomwalk (OpProblem* problem, Configuration* configuration);
00314
00315
00318 virtual int configurationmove(OpProblem* problem,Configuration* configuration);
00319 void initthreshold(Configuration** population, int popsize);
00320 void run (OpProblem *problem, Configuration ** population);
00321
00323 int test_bestfound( int value, int nbmov);
00324
00325 };
00326
00327
00329 class Metaheuristic
00330 {public :
00331 virtual ~Metaheuristic(){};
00332
00334 virtual void executebeforemove(Move* move, Configuration* configuration,OpProblem* problem);
00335
00337 virtual void reinit();
00338
00340 virtual int acceptance(Move* move,Configuration* config);
00341 };
00342
00343
00344
00347 class TabuSearch: public Metaheuristic
00348 {public :
00349
00351 int tabulength;
00352
00354 list<Move*> move_list;
00355 TabuSearch(int tabul);
00356
00358 int acceptance (Move* move, Configuration* config);
00359
00361 int nontabumove (Move* move);
00362
00364 void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00365
00367 void reinit();
00368 };
00369
00370
00372 class Metropolis: public Metaheuristic
00373 {public :
00374 double temperature;
00375 Metropolis(double temp);
00376
00377
00379 int acceptance (Move* move, Configuration* config);
00380 };
00381
00382
00383
00384
00387 class ThresholdAccepting: public Metaheuristic
00388 {public :
00389
00391 double thresholdinit;
00392
00394 double delta;
00395
00397 double thresholdaccept;
00398
00399
00402 ThresholdAccepting(double maxthreshold, int walklength);
00403
00405 int acceptance (Move* move,Configuration* config);
00406
00408 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00409
00411 void reinit();
00412 };
00413
00414
00416 class SimulatedAnnealing: public Metaheuristic
00417 {public :
00418
00420 double inittemperature;
00421
00423 double delta;
00424
00426 double temperature;
00427
00430 SimulatedAnnealing(double initialtemperature, int walklength);
00431
00432
00433
00434
00437 int acceptance (Move* move, Configuration* config);
00438
00440 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00441 void reinit();
00442 };
00443
00444
00445
00449
00450
00451 class TabuAcceptingrate: public TabuSearch
00452 {public :
00453
00455 float Pd;
00456
00458 float P0;
00459 TabuAcceptingrate(int tabul, float Pd, float P0);
00460
00462 int acceptance (Move* move, Configuration* config);
00463 };
00464
00465
00466
00468 class RandomSearch: public Metaheuristic
00469 {public :
00470 RandomSearch();
00471 int acceptance (Move* move, Configuration* config);
00472 };
00473
00474
00476 class GreedySearch: public Metaheuristic
00477 {public :
00478 GreedySearch();
00479 int acceptance (Move* move, Configuration* config);
00480 };
00481
00482
00483
00484
00485
00486
00487
00488
00492 class GWWAlgorithm: public IncompleteAlgorithm
00493 {public :
00494
00496 int populationsize;
00497
00498
00501 int regrouptest;
00502
00505 int lastmovedescent;
00506
00508 int elitism;
00509
00511 int nomovestop;
00512
00514 int thresholddelta;
00515
00517 int nbiteration;
00518
00520 int thresholdchanges;
00521
00523 int total_nhtries;
00524
00526 int total_nbmoves;
00527
00529 LSAlgorithm* walkalgorithm;
00530
00531 ~GWWAlgorithm();
00532
00534 virtual void populationrandomwalk (OpProblem* problem, Configuration** population);
00535
00537 virtual int nb_threshold_population(Configuration** population);
00538
00540 void randomwalk (OpProblem* problem, Configuration* configuration);
00541
00543 void initthreshold(Configuration** population, int popsize);
00544
00546 virtual void thresholdupdate();
00547
00549 virtual void thresholdcomputedelta(Configuration** population);
00550
00552 void run (OpProblem *problem, Configuration** population);
00553
00555 virtual void regrouping(Configuration** population);
00556
00558 void populationkeepbest (OpProblem* problem, Configuration** population);
00559
00561 virtual void thresholdchangesupdate();
00562 };
00563
00564
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
00577 class StandardGWWAlgorithm : public ThresholdGWWAlgorithm
00578 {public :
00579
00581 double thresholddescent;
00582
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
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
00600 class AdaptiveGWWAlgorithm : public ThresholdGWWAlgorithm
00601 { public :
00602
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
00611
00614 class FastAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00615 {public :
00616
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
00626 class MedianAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00627 {public :
00628
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
00637 class BestAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00638 {public :
00639
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
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
00658 int nbkilled;
00659 };
00660
00661
00662
00663