00001
00005 class OpProblem;
00006 class IncompleteAlgorithm;
00007 class Metaheuristic;
00008 class NeighborhoodSearch;
00009 class Move;
00010
00011
00012
00016
00017
00018 class Configuration
00019
00020 {public :
00021 int nbvar;
00023
00024 int* config;
00026
00027 int valuation;
00029
00030 vector<int> var_conflict;
00032
00033 int regrouped;
00034 virtual ~Configuration();
00035 Configuration();
00036 Configuration(int nbvar);
00038
00039 virtual void copy_element (Configuration* config2);
00041
00042 virtual void init_conflicts ();
00044
00045 virtual void incr_conflicts (int var, int val, int index, int incr);
00046
00048
00049 virtual void set_conflicts (int var, int val, int index, int nbconf);
00050
00052
00053 virtual int get_conflicts (int var, int val, int index);
00055
00056 virtual int get_conflicts_problem (OpProblem* problem, int var, int val);
00057
00059
00060 virtual void update_conflicts(OpProblem* problem, Move* move);
00061 };
00062
00064
00065 class CSPConfiguration: public Configuration
00066 {
00067 public :
00068 CSPConfiguration (int nbvar);
00069 CSPConfiguration(int nbvar, int nbcol);
00070 };
00071
00074
00075
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
00094
00095
00096
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);
00108
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
00115
00116 class Move
00117 {public :
00118 int valuation;
00119 Move();
00120 virtual ~Move() {;};
00122
00123 virtual int eqmove(Move* move1);
00125
00126 virtual void copymove(Move* move);
00128
00129 virtual Move* computetabumove(Configuration* config){return 0;};
00130 };
00131
00133
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);
00143
00144 Move* computetabumove(Configuration* config);
00145 };
00146
00147
00149
00150
00151 class OpProblem
00152 {public :
00154
00155 Configuration* best_config;
00157
00158 int nbvar;
00160
00161 int lower_bound;
00163
00164 Move* currentmove;
00166
00167 Move* firstmove;
00169
00170 Move* bestmove;
00171 OpProblem(){};
00172 virtual ~OpProblem(){};
00174
00175 virtual void move_execution(Configuration* configuration, Move* move);
00177
00178 virtual void incr_update_conflicts(IncrCSPConfiguration* configuration,Move* move){};
00180
00181 virtual void fullincr_update_conflicts(FullincrCSPConfiguration* configuration,Move* move){};
00183
00184 virtual void allocate_moves();
00186
00187
00188 virtual Move* create_move(){return 0;};
00190
00191 virtual void adjust_parameters(Configuration* configuration, int & maxneighbors, int & minneighbors){};
00193
00194 virtual void next_move(Configuration* configuration, Move* move, NeighborhoodSearch* nbhs){};
00196
00197 virtual void random_configuration(Configuration* configuration){};
00199
00200 virtual void best_config_analysis(){};
00202
00203 virtual void best_config_write(){};
00204
00206
00207 virtual void best_config_verification();
00209
00210 virtual void init_population (Configuration** population,int populationsize) {};
00212
00213 virtual Configuration* create_configuration(){return 0;};
00215
00216 virtual int compute_conflict (Configuration* configuration,int var, int val) {return 0;};
00218
00219 virtual int config_evaluation(Configuration* configuration) {return 0;};
00221
00222 virtual int move_evaluation (Configuration* configuration,Move* move){return 0;};
00224
00225 virtual int index2value (int index, int var) {return index;};
00227
00228 virtual int value2index(int value,int var) {return value;};
00230
00231 virtual void compute_var_conflict (Configuration* configuration) {};
00232 };
00233
00236
00237
00238 class NeighborhoodSearch
00239 {public :
00241
00242 int minneighbors;
00244
00245 int maxneighbors;
00248
00249
00250 int finished;
00252
00253 int var_conflict;
00255
00256 int val_conflict;
00257 NeighborhoodSearch( int maxneigh, int minneigh, int finish, int var_conf, int val_conf);
00258 int returnbestmove();
00259 };
00260
00261
00264
00265
00266 class IncompleteAlgorithm
00267 {public :
00268 string methodname;
00271
00272 int threshold;
00273 virtual ~IncompleteAlgorithm(){};
00275
00276 virtual void randomwalk (OpProblem* problem, Configuration* configuration);
00277 virtual void initthreshold(Configuration** population, int popsize){;};
00279
00280 virtual void run (OpProblem *problem,Configuration ** population);
00281
00282 };
00283
00286
00287
00288
00289 class LSAlgorithm: public IncompleteAlgorithm
00290 {public :
00292
00293 int walklength;
00295
00296 NeighborhoodSearch * nbhsearch;
00298
00299 Metaheuristic* mheur;
00301
00302 int nhtries;
00303 double avgnhtries;
00304 double avgsqnhtries;
00306
00307 int nbmoves;
00308 LSAlgorithm(int nbmov);
00309 ~LSAlgorithm();
00311
00312 virtual int isfeasible(Move* move);
00313 void randomwalk (OpProblem* problem, Configuration* configuration);
00316
00317
00318 virtual int configurationmove(OpProblem* problem,Configuration* configuration);
00319 void initthreshold(Configuration** population, int popsize);
00320 void run (OpProblem *problem, Configuration ** population);
00322
00323 int test_bestfound( int value, int nbmov);
00324
00325 };
00326
00328
00329 class Metaheuristic
00330 {public :
00331 virtual ~Metaheuristic(){};
00333
00334 virtual void executebeforemove(Move* move, Configuration* configuration,OpProblem* problem);
00336
00337 virtual void reinit();
00339
00340 virtual int acceptance(Move* move,Configuration* config);
00341 };
00342
00345
00346
00347 class TabuSearch: public Metaheuristic
00348 {public :
00350
00351 int tabulength;
00353
00354 list<Move*> move_list;
00355 TabuSearch(int tabul);
00357
00358 int acceptance (Move* move, Configuration* config);
00360
00361 int nontabumove (Move* move);
00363
00364 void executebeforemove(Move* move, Configuration* configuration, OpProblem* problem);
00366
00367 void reinit();
00368 };
00369
00371
00372 class Metropolis: public Metaheuristic
00373 {public :
00374 double temperature;
00375 Metropolis(double temp);
00378
00379 int acceptance (Move* move, Configuration* config);
00380 };
00381
00385
00386
00387 class ThresholdAccepting: public Metaheuristic
00388 {public :
00390
00391 double thresholdinit;
00393
00394 double delta;
00396
00397 double thresholdaccept;
00398
00399
00402 ThresholdAccepting(double maxthreshold, int walklength);
00404
00405 int acceptance (Move* move,Configuration* config);
00407
00408 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00410
00411 void reinit();
00412 };
00413
00415
00416 class SimulatedAnnealing: public Metaheuristic
00417 {public :
00419
00420 double inittemperature;
00422
00423 double delta;
00425
00426 double temperature;
00427
00430 SimulatedAnnealing(double initialtemperature, int walklength);
00435
00436
00437 int acceptance (Move* move, Configuration* config);
00439
00440 void executebeforemove(Move* move, Configuration * configuration, OpProblem* problem);
00441 void reinit();
00442 };
00443
00444
00446
00447
00448
00449
00450
00451 class TabuAcceptingrate: public TabuSearch
00452 {public :
00454
00455 float Pd;
00457
00458 float P0;
00459 TabuAcceptingrate(int tabul, float Pd, float P0);
00461
00462 int acceptance (Move* move, Configuration* config);
00463 };
00464
00465
00467
00468 class RandomSearch: public Metaheuristic
00469 {public :
00470 RandomSearch();
00471 int acceptance (Move* move, Configuration* config);
00472 };
00473
00475
00476 class GreedySearch: public Metaheuristic
00477 {public :
00478 GreedySearch();
00479 int acceptance (Move* move, Configuration* config);
00480 };
00481
00482
00483
00484
00489
00490
00491
00492 class GWWAlgorithm: public IncompleteAlgorithm
00493 {public :
00495
00496 int populationsize;
00499
00500
00501 int regrouptest;
00503
00504
00505 int lastmovedescent;
00507
00508 int elitism;
00510
00511 int nomovestop;
00513
00514 int thresholddelta;
00516
00517 int nbiteration;
00519
00520 int thresholdchanges;
00522
00523 int total_nhtries;
00525
00526 int total_nbmoves;
00528
00529 LSAlgorithm* walkalgorithm;
00531 ~GWWAlgorithm();
00533
00534 virtual void populationrandomwalk (OpProblem* problem, Configuration** population);
00536
00537 virtual int nb_threshold_population(Configuration** population);
00539
00540 void randomwalk (OpProblem* problem, Configuration* configuration);
00542
00543 void initthreshold(Configuration** population, int popsize);
00545
00546 virtual void thresholdupdate();
00548
00549 virtual void thresholdcomputedelta(Configuration** population);
00551
00552 void run (OpProblem *problem, Configuration** population);
00554
00555 virtual void regrouping(Configuration** population);
00557
00558 void populationkeepbest (OpProblem* problem, Configuration** population);
00560
00561 virtual void thresholdchangesupdate();
00562 };
00563
00565
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
00576
00577 class StandardGWWAlgorithm : public ThresholdGWWAlgorithm
00578 {public :
00580
00581 double thresholddescent;
00583
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
00591
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
00599
00600 class AdaptiveGWWAlgorithm : public ThresholdGWWAlgorithm
00601 { public :
00603
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
00612
00613
00614 class FastAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00615 {public :
00617
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
00625
00626 class MedianAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00627 {public :
00629
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
00636
00637 class BestAdaptGWWAlgorithm: public AdaptiveGWWAlgorithm
00638 {public :
00640
00641
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
00650
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);
00657
00658 int nbkilled;
00659 };
00660
00661
00662
00663