00001
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 int trynumber;
00023
00025 int* config;
00026
00028 int valuation;
00029 int var_conflict_size;
00030
00032 vector<int> var_conflict;
00033 set<int> set_var_conflict;
00034
00036 int regrouped;
00037 virtual ~Configuration();
00038 Configuration();
00039 Configuration(int nbvar);
00040
00042 virtual void copy_element (Configuration* config2);
00043
00045 virtual void init_conflicts ();
00046
00048 virtual void incr_conflicts (int var, int val, int index, int incr);
00049
00050
00052 virtual void set_conflicts (int var, int val, int index, int nbconf);
00053
00054
00056 virtual int get_conflicts (int var, int val, int index);
00057
00059 virtual int get_conflicts_problem (OpProblem* problem, int var, int val);
00060
00061
00063 virtual void update_conflicts(OpProblem* problem, Move* move);
00064 };
00065
00066
00068 class CSPConfiguration: public Configuration
00069 {
00070 public :
00071 int domainsize;
00072
00073 CSPConfiguration(int nbvar, int domsize);
00074 };
00075
00076
00077
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
00097
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
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
00121 class Move
00122 {public :
00123 int valuation;
00124 Move();
00125 virtual ~Move() {;};
00126
00128 virtual int eqmove(Move* move1);
00129
00131 virtual void copymove(Move* move);
00132
00134 virtual Move* computetabumove(Configuration* config){return 0;};
00135 };
00136
00137
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
00149 Move* computetabumove(Configuration* config);
00150 };
00151
00152
00153
00156 class OpProblem
00157 {public :
00158
00160 Configuration* best_config;
00161
00163 int nbvar;
00164
00166 int domainsize;
00167
00169 int lower_bound;
00170
00172 Move* currentmove;
00173
00175 Move* firstmove;
00176
00178 Move* bestmove;
00179 OpProblem(){};
00180 virtual ~OpProblem(){};
00181
00183 virtual void move_execution(Configuration* configuration, Move* move);
00184
00186 virtual void incr_update_conflicts(IncrCSPConfiguration* configuration,Move* move){};
00187
00189 virtual void fullincr_update_conflicts(FullincrCSPConfiguration* configuration,Move* move){};
00190
00192 virtual void allocate_moves();
00193
00196 virtual Move* create_move(){return 0;};
00197
00199 virtual void adjust_parameters(Configuration* configuration, int & maxneighbors, int & minneighbors){};
00200
00202 virtual void next_move(Configuration* configuration, Move* move, NeighborhoodSearch* nbhs){};
00203
00205 virtual void random_configuration(Configuration* configuration){};
00206
00208 virtual void best_config_analysis(){};
00209
00211 virtual void best_config_write(){};
00212
00213
00215 virtual void best_config_verification();
00216
00218 virtual void init_population (Configuration** population,int populationsize) {};
00219
00221 virtual Configuration* create_configuration(){return 0;};
00222
00224 virtual int compute_conflict (Configuration* configuration,int var, int val) {return 0;};
00225
00227 virtual int config_evaluation(Configuration* configuration) {return 0;};
00228
00230 virtual int move_evaluation (Configuration* configuration,Move* move){return 0;};
00231
00233 virtual int index2value (int index, int var) {return index;};
00234
00236 virtual int value2index(int value,int var) {return value;};
00237
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
00246
00249 class NeighborhoodSearch
00250 {public :
00251
00253 int minneighbors;
00254
00256 int maxneighbors;
00257
00258
00261 int finished;
00262
00264 int var_conflict;
00265
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
00280 class DynamicNeighborhoodSearch: public NeighborhoodSearch
00281 {public:
00282 DynamicNeighborhoodSearch(int maxneigh, int minneigh, int finish, int var_conf, int val_conf, double nbbr);
00283
00285 int initmaxneighbors;
00286
00288 int initminneighbors;
00289
00291 int adjustperiod;
00292 void initsearch();
00293
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
00306
00309 class IncompleteAlgorithm
00310 {public :
00311 string methodname;
00312
00313
00315 int threshold;
00316 virtual ~IncompleteAlgorithm(){};
00317
00319 virtual void randomwalk (OpProblem* problem, Configuration* configuration);
00320 virtual void initthreshold(Configuration** population, int popsize){;};
00321
00323 virtual void run (OpProblem *problem,Configuration ** population);
00324
00325 };
00326
00327
00328
00332 class LSAlgorithm: public IncompleteAlgorithm
00333 {public :
00334
00336 int walklength;
00337
00339 NeighborhoodSearch * nbhsearch;
00340
00342 Metaheuristic* mheur;
00343
00345 int nhtries;
00346 double avgnhtries;
00347 double avgsqnhtries;
00348
00350 int nbmoves;
00351 LSAlgorithm(int nbmov);
00352 ~LSAlgorithm();
00353
00355 virtual int isfeasible(Move* move);
00356 void randomwalk (OpProblem* problem, Configuration* configuration);
00357
00358
00361 virtual int configurationmove(OpProblem* problem,Configuration* configuration);
00362 void initthreshold(Configuration** population, int popsize);
00363 void run (OpProblem *problem, Configuration ** population);
00364
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
00379 class Metaheuristic
00380 {public :
00381 virtual ~Metaheuristic(){};
00382
00384 virtual void executebeforemove(Move* move, Configuration* configuration,OpProblem* problem);
00385
00387 virtual void reinit(OpProblem* problem);
00388
00390 virtual int acceptance(Move* move,Configuration* config);
00391 virtual void adjustparameter (int parameter) {;};
00392 };
00393
00394
00395
00398 class TabuSearch: public Metaheuristic
00399 {public :
00400
00402 int tabulength;
00403
00405 list<Move*> move_list;
00406 TabuSearch(int tabul);
00407
00409 int acceptance (Move* move, Configuration* config);
00410
00412 int nontabumove (Move* move);
00413
00415 void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00416
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
00447 class Metropolis: public Metaheuristic
00448 {public :
00449 double temperature;
00450 Metropolis(double temp);
00451
00452
00454 int acceptance (Move* move, Configuration* config);
00455 void adjustparameter(int parameter);
00456 };
00457
00458
00459
00460
00463 class ThresholdAccepting: public Metaheuristic
00464 {public :
00465
00467 double thresholdinit;
00468
00470 double delta;
00471
00473 double thresholdaccept;
00474
00475
00478 ThresholdAccepting(double maxthreshold, int walklength);
00479
00481 int acceptance (Move* move,Configuration* config);
00482
00484 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00485
00487 void reinit(OpProblem* problem);
00488 };
00489
00490
00492 class SimulatedAnnealing: public Metaheuristic
00493 {public :
00494
00496 double inittemperature;
00497
00499 double delta;
00500
00502 double temperature;
00503 int walklength;
00504
00507 SimulatedAnnealing(double initialtemperature, int walklength);
00508
00509
00510
00511
00514 int acceptance (Move* move, Configuration* config);
00515
00517 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00518 void reinit(OpProblem* problem);
00519 void adjustparameter (int parameter);
00520 };
00521
00522
00523
00527
00528
00529 class TabuAcceptingrate: public TabuSearch
00530 {public :
00531
00533 float Pd;
00534
00536 float P0;
00537 TabuAcceptingrate(int tabul, float Pd, float P0);
00538
00540 int acceptance (Move* move, Configuration* config);
00541 };
00542
00543
00544
00546 class RandomSearch: public Metaheuristic
00547 {public :
00548 RandomSearch();
00549 int acceptance (Move* move, Configuration* config);
00550 };
00551
00552
00554 class GreedySearch: public Metaheuristic
00555 {public :
00556 GreedySearch();
00557 int acceptance (Move* move, Configuration* config);
00558 };
00559
00560
00561
00562
00563
00564
00565
00566
00570 class GWWAlgorithm: public IncompleteAlgorithm
00571 {public :
00572
00574 int populationsize;
00575
00576
00579 int regrouptest;
00580
00583 int lastmovedescent;
00584
00586 int elitism;
00587
00589 int nomovestop;
00590
00592 int thresholddelta;
00593
00595 int nbiteration;
00596
00598 int thresholdchanges;
00599
00601 int total_nhtries;
00602
00604 int total_nbmoves;
00605
00607 LSAlgorithm* walkalgorithm;
00608
00609 ~GWWAlgorithm();
00610
00612 virtual void populationrandomwalk (OpProblem* problem, Configuration** population);
00613
00615 virtual int nb_threshold_population(Configuration** population);
00616
00618 void randomwalk (OpProblem* problem, Configuration* configuration);
00619
00621 void initthreshold(Configuration** population, int popsize);
00622
00624 virtual void thresholdupdate();
00625
00627 virtual void thresholdcomputedelta(Configuration** population);
00628
00630 void run (OpProblem *problem, Configuration** population);
00631
00633 virtual void regrouping(Configuration** population);
00634
00636 void populationkeepbest (OpProblem* problem, Configuration** population);
00637
00639 virtual void thresholdchangesupdate();
00640 };
00641
00642
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
00655 class StandardGWWAlgorithm : public ThresholdGWWAlgorithm
00656 {public :
00657
00659 double thresholddescent;
00660
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
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
00678 class AdaptiveGWWAlgorithm : public ThresholdGWWAlgorithm
00679 { public :
00680
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
00689
00692 class FastAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00693 {public :
00694
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
00704 class MedianAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00705 {public :
00706
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
00715 class BestAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00716 {public :
00717
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
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
00736 int nbkilled;
00737 };
00738
00739
00740
00741