00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 #include "test/branch.hh"
00045
00046 #include <algorithm>
00047 #include <map>
00048 #include <vector>
00049 #include <iostream>
00050
00051 #include <gecode/kernel.hh>
00052 #include <gecode/int.hh>
00053 #ifdef GECODE_HAS_SET_VARS
00054 #include <gecode/set.hh>
00055 #endif
00056 #ifdef GECODE_HAS_FLOAT_VARS
00057 #include <gecode/float.hh>
00058 #endif
00059
00060 #include <gecode/search.hh>
00061
00062 namespace Test { namespace Branch {
00063
00065 double tbl(const Gecode::Space&, double w, double b) {
00066 return (w + (b-w)/2.0);
00067 }
00068
00070 class IntTestSpace : public Gecode::Space {
00071 public:
00073 Gecode::IntVarArray x;
00075 Gecode::IntVarBranch vara, varb;
00077 Gecode::IntValBranch val;
00079 IntTestSpace(int n, Gecode::IntSet& d)
00080 : x(*this, n, d),
00081 vara(Gecode::INT_VAR_NONE()), varb(Gecode::INT_VAR_NONE()),
00082 val(Gecode::INT_VAL_MIN()) {}
00084 IntTestSpace(bool share, IntTestSpace& s)
00085 : Gecode::Space(share,s), vara(s.vara), varb(s.varb), val(s.val) {
00086 x.update(*this, share, s.x);
00087 }
00089 virtual Gecode::Space* copy(bool share) {
00090 return new IntTestSpace(share,*this);
00091 }
00092 };
00093
00095 class BoolTestSpace : public Gecode::Space {
00096 public:
00098 Gecode::BoolVarArray x;
00100 BoolTestSpace(int n)
00101 : x(*this, n, 0, 1) {}
00103 BoolTestSpace(bool share, BoolTestSpace& s)
00104 : Gecode::Space(share,s) {
00105 x.update(*this, share, s.x);
00106 }
00108 virtual Gecode::Space* copy(bool share) {
00109 return new BoolTestSpace(share,*this);
00110 }
00111 };
00112
00113 #ifdef GECODE_HAS_SET_VARS
00114
00115 class SetTestSpace : public Gecode::Space {
00116 public:
00118 Gecode::SetVarArray x;
00120 SetTestSpace(int n, Gecode::IntSet& d)
00121 : x(*this, n, Gecode::IntSet::empty, d) {}
00123 SetTestSpace(bool share, SetTestSpace& s)
00124 : Gecode::Space(share,s) {
00125 x.update(*this, share, s.x);
00126 }
00128 virtual Gecode::Space* copy(bool share) {
00129 return new SetTestSpace(share,*this);
00130 }
00131 };
00132 #endif
00133
00134 #ifdef GECODE_HAS_FLOAT_VARS
00135
00136 class FloatTestSpace : public Gecode::Space {
00137 public:
00139 Gecode::FloatVarArray x;
00141 FloatTestSpace(int n, Gecode::FloatVal& d)
00142 : x(*this, n, d.min(), d.max()) {}
00144 FloatTestSpace(bool share, FloatTestSpace& s)
00145 : Gecode::Space(share,s) {
00146 x.update(*this, share, s.x);
00147 }
00149 virtual Gecode::Space* copy(bool share) {
00150 return new FloatTestSpace(share,*this);
00151 }
00152 };
00153 #endif
00154
00160
00161 const char* int_var_branch_name[] = {
00162 "SINGLE VARIABLE",
00163 "INT_VAR_NONE",
00164 "INT_VAR_RND",
00165 "INT_VAR_MERIT_MIN",
00166 "INT_VAR_MERIT_MAX",
00167 "INT_VAR_DEGREE_MIN",
00168 "INT_VAR_DEGREE_MAX",
00169 "INT_VAR_AFC_MIN",
00170 "INT_VAR_AFC_MAX",
00171 "INT_VAR_ACTIVITY_MIN",
00172 "INT_VAR_ACTIVITY_MAX",
00173 "INT_VAR_MIN_MIN",
00174 "INT_VAR_MIN_MAX",
00175 "INT_VAR_MAX_MIN",
00176 "INT_VAR_MAX_MAX",
00177 "INT_VAR_SIZE_MIN",
00178 "INT_VAR_SIZE_MAX",
00179 "INT_VAR_DEGREE_SIZE_MIN",
00180 "INT_VAR_DEGREE_SIZE_MAX",
00181 "INT_VAR_AFC_SIZE_MIN",
00182 "INT_VAR_AFC_SIZE_MAX",
00183 "INT_VAR_ACTIVITY_SIZE_MIN",
00184 "INT_VAR_ACTIVITY_SIZE_MAX",
00185 "INT_VAR_REGRET_MIN_MIN",
00186 "INT_VAR_REGRET_MIN_MAX",
00187 "INT_VAR_REGRET_MAX_MIN",
00188 "INT_VAR_REGRET_MAX_MAX"
00189 };
00191 const int n_int_var_branch =
00192 sizeof(int_var_branch_name)/sizeof(const char*);
00194 double int_merit(const Gecode::Space&, Gecode::IntVar x, int) {
00195 return x.min();
00196 }
00198 double bool_merit(const Gecode::Space&, Gecode::BoolVar x, int) {
00199 return x.min();
00200 }
00202 const char* int_val_branch_name[] = {
00203 "INT_VAL_MIN",
00204 "INT_VAL_MED",
00205 "INT_VAL_MAX",
00206 "INT_VAL_RND",
00207 "INT_VAL_SPLIT_MIN",
00208 "INT_VAL_SPLIT_MAX",
00209 "INT_VAL_RANGE_MIN",
00210 "INT_VAL_RANGE_MAX",
00211 "INT_VAL",
00212 "INT_VALUES_MIN",
00213 "INT_VALUES_MAX",
00214 "INT_VAL_NEAR_MIN",
00215 "INT_VAL_NEAR_MAX",
00216 "INT_VAL_NEAR_INC",
00217 "INT_VAL_NEAR_DEC",
00218 };
00220 const int n_int_val_branch =
00221 sizeof(int_val_branch_name)/sizeof(const char*);
00223 int int_val(const Gecode::Space&, Gecode::IntVar x, int) {
00224 return x.min();
00225 }
00227 int bool_val(const Gecode::Space&, Gecode::BoolVar x, int) {
00228 return x.min();
00229 }
00231
00232 #ifdef GECODE_HAS_SET_VARS
00233
00238
00239 const char* set_var_branch_name[] = {
00240 "SINGLE VARIABLE",
00241 "SET_VAR_NONE",
00242 "SET_VAR_RND",
00243 "SET_VAR_MERIT_MIN",
00244 "SET_VAR_MERIT_MAX",
00245 "SET_VAR_DEGREE_MIN",
00246 "SET_VAR_DEGREE_MAX",
00247 "SET_VAR_AFC_MIN",
00248 "SET_VAR_AFC_MAX",
00249 "SET_VAR_ACTIVITY_MIN",
00250 "SET_VAR_ACTIVITY_MAX",
00251 "SET_VAR_MIN_MIN",
00252 "SET_VAR_MIN_MAX",
00253 "SET_VAR_MAX_MIN",
00254 "SET_VAR_MAX_MAX",
00255 "SET_VAR_SIZE_MIN",
00256 "SET_VAR_SIZE_MAX",
00257 "SET_VAR_DEGREE_SIZE_MIN",
00258 "SET_VAR_DEGREE_SIZE_MAX",
00259 "SET_VAR_AFC_SIZE_MIN",
00260 "SET_VAR_AFC_SIZE_MAX",
00261 "SET_VAR_ACTIVITY_SIZE_MIN",
00262 "SET_VAR_ACTIVITY_SIZE_MAX"
00263 };
00265 const int n_set_var_branch =
00266 sizeof(set_var_branch_name)/sizeof(const char*);
00268 double set_merit(const Gecode::Space&, Gecode::SetVar, int) {
00269 return 2.0;
00270 }
00272 const char* set_val_branch_name[] = {
00273 "SET_VAL_MIN_INC",
00274 "SET_VAL_MIN_EXC",
00275 "SET_VAL_MED_INC",
00276 "SET_VAL_MED_EXC",
00277 "SET_VAL_MAX_INC",
00278 "SET_VAL_MAX_EXC",
00279 "SET_VAL_RND_INC",
00280 "SET_VAL_RND_EXC",
00281 "SET_VAL"
00282 };
00284 const int n_set_val_branch =
00285 sizeof(set_val_branch_name)/sizeof(const char*);
00287 int set_val(const Gecode::Space&, Gecode::SetVar x, int) {
00288 Gecode::SetVarUnknownRanges r(x);
00289 return r.min();
00290 }
00292 #endif
00293
00294 #ifdef GECODE_HAS_FLOAT_VARS
00295
00300
00301 const char* float_var_branch_name[] = {
00302 "SINGLE VARIABLE",
00303 "FLOAT_VAR_NONE",
00304 "FLOAT_VAR_RND",
00305 "FLOAT_VAR_MERIT_MIN",
00306 "FLOAT_VAR_MERIT_MAX",
00307 "FLOAT_VAR_DEGREE_MIN",
00308 "FLOAT_VAR_DEGREE_MAX",
00309 "FLOAT_VAR_AFC_MIN",
00310 "FLOAT_VAR_AFC_MAX",
00311 "FLOAT_VAR_ACTIVITY_MIN",
00312 "FLOAT_VAR_ACTIVITY_MAX",
00313 "FLOAT_VAR_MIN_MIN",
00314 "FLOAT_VAR_MIN_MAX",
00315 "FLOAT_VAR_MAX_MIN",
00316 "FLOAT_VAR_MAX_MAX",
00317 "FLOAT_VAR_SIZE_MIN",
00318 "FLOAT_VAR_SIZE_MAX",
00319 "FLOAT_VAR_DEGREE_SIZE_MIN",
00320 "FLOAT_VAR_DEGREE_SIZE_MAX",
00321 "FLOAT_VAR_AFC_SIZE_MIN",
00322 "FLOAT_VAR_AFC_SIZE_MAX",
00323 "FLOAT_VAR_ACTIVITY_SIZE_MIN",
00324 "FLOAT_VAR_ACTIVITY_SIZE_MAX"
00325 };
00327 const int n_float_var_branch =
00328 sizeof(float_var_branch_name)/sizeof(const char*);
00330 double float_merit(const Gecode::Space&, Gecode::FloatVar x, int) {
00331 return static_cast<double>(x.degree());
00332 }
00334 const char* float_val_branch_name[] = {
00335 "FLOAT_VAL_SPLIT_MIN",
00336 "FLOAT_VAL_SPLIT_MAX",
00337 "FLOAT_VAL_SPLIT_RND",
00338 "FLOAT_VAL"
00339 };
00341 const int n_float_val_branch =
00342 sizeof(float_val_branch_name)/sizeof(const char*);
00344 Gecode::FloatNumBranch float_val(const Gecode::Space&,
00345 Gecode::FloatVar x, int) {
00346 Gecode::FloatNumBranch nl; nl.n=x.med(); nl.l=true;
00347 return nl;
00348 }
00350 #endif
00351
00353 class RunInfo {
00354 public:
00355 std::string var, val;
00356 unsigned int a_d, c_d;
00357 RunInfo(const std::string& vara, const std::string& varb,
00358 const std::string& valname,
00359 const Gecode::Search::Options& o)
00360 : var(vara + "::" + varb), val(valname), a_d(o.a_d), c_d(o.c_d) {}
00361 void print(std::ostream& o) const {
00362 o << "(" << var << ", " << val << ", " << a_d << ", " << c_d << ")";
00363 }
00364 };
00365
00366 }}
00367
00368 std::ostream&
00369 operator<<(std::ostream& os, const Test::Branch::RunInfo& ri) {
00370 ri.print(os);
00371 return os;
00372 }
00373
00374
00375 namespace Test { namespace Branch {
00376
00378 template<class TestSpace>
00379 int solutions(TestSpace* c, Gecode::Search::Options& o, int maxNbSol = -1) {
00380 o.a_d = Base::rand(10);
00381 o.c_d = Base::rand(10);
00382 Gecode::DFS<TestSpace> e_s(c, o);
00383 delete c;
00384
00385
00386 int s = 0;
00387 do {
00388 Gecode::Space* ex = e_s.next();
00389 if (ex == NULL) break;
00390 delete ex;
00391 ++s;
00392 if ((maxNbSol >= 0) && (maxNbSol == s)) break;
00393 } while (true);
00394 return s;
00395 }
00396
00397 IntTest::IntTest(const std::string& s, int a, const Gecode::IntSet& d)
00398 : Base("Int::Branch::"+s), arity(a), dom(d) {
00399 }
00400
00401 bool
00402 IntTest::run(void) {
00403 using std::map;
00404 using std::vector;
00405 using std::string;
00406 using std::ostream;
00407 using namespace Gecode;
00408
00409
00410 map<int, vector<RunInfo> > results;
00411
00412 IntTestSpace* root = new IntTestSpace(arity,dom);
00413 post(*root, root->x);
00414 results.clear();
00415
00416 IntArgs d(arity);
00417 for (int i=arity; i--; )
00418 d[i]=i;
00419
00420 for (int vara = 0; vara<n_int_var_branch; vara++) {
00421 for (int varb = 1; varb<n_int_var_branch; varb++) {
00422 for (int val = 0; val<n_int_val_branch; val++) {
00423 Rnd r(1);
00424
00425 IntValBranch ivb;
00426 switch (val) {
00427 case 0: ivb = INT_VAL_MIN(); break;
00428 case 1: ivb = INT_VAL_MED(); break;
00429 case 2: ivb = INT_VAL_MAX(); break;
00430 case 3: ivb = INT_VAL_RND(r); break;
00431 case 4: ivb = INT_VAL_SPLIT_MIN(); break;
00432 case 5: ivb = INT_VAL_SPLIT_MAX(); break;
00433 case 6: ivb = INT_VAL_RANGE_MIN(); break;
00434 case 7: ivb = INT_VAL_RANGE_MAX(); break;
00435 case 8: ivb = INT_VAL(&int_val); break;
00436 case 9: ivb = INT_VALUES_MIN(); break;
00437 case 10: ivb = INT_VALUES_MAX(); break;
00438 case 11: ivb = INT_VAL_NEAR_MIN(d); break;
00439 case 12: ivb = INT_VAL_NEAR_MAX(d); break;
00440 case 13: ivb = INT_VAL_NEAR_INC(d); break;
00441 case 14: ivb = INT_VAL_NEAR_DEC(d); break;
00442 }
00443
00444 IntTestSpace* c = static_cast<IntTestSpace*>(root->clone(false));
00445
00446 if ((vara == 0) && (val < 11)) {
00447 for (int i=0; i<c->x.size(); i++)
00448 branch(*c, c->x[i], ivb);
00449 } else {
00450 Rnd ra(1);
00451 IntVarBranch ivba;
00452 IntActivity iaa(*c, c->x, 0.9);
00453 switch (vara) {
00454 case 0: ivba = INT_VAR_NONE(); break;
00455 case 1: ivba = INT_VAR_NONE(); break;
00456 case 2: ivba = INT_VAR_RND(ra); break;
00457 case 3: ivba = INT_VAR_MERIT_MIN(&int_merit); break;
00458 case 4: ivba = INT_VAR_MERIT_MAX(&int_merit); break;
00459 case 5: ivba = INT_VAR_DEGREE_MIN(); break;
00460 case 6: ivba = INT_VAR_DEGREE_MAX(); break;
00461 case 7: ivba = INT_VAR_AFC_MIN(0.5); break;
00462 case 8: ivba = INT_VAR_AFC_MAX(0.5); break;
00463 case 9: ivba = INT_VAR_ACTIVITY_MIN(iaa); break;
00464 case 10: ivba = INT_VAR_ACTIVITY_MAX(iaa); break;
00465 case 11: ivba = INT_VAR_MIN_MIN(); break;
00466 case 12: ivba = INT_VAR_MIN_MAX(); break;
00467 case 13: ivba = INT_VAR_MAX_MIN(); break;
00468 case 14: ivba = INT_VAR_MAX_MAX(); break;
00469 case 15: ivba = INT_VAR_SIZE_MIN(); break;
00470 case 16: ivba = INT_VAR_SIZE_MAX(); break;
00471 case 17: ivba = INT_VAR_DEGREE_SIZE_MIN(); break;
00472 case 18: ivba = INT_VAR_DEGREE_SIZE_MAX(); break;
00473 case 19: ivba = INT_VAR_AFC_SIZE_MIN(); break;
00474 case 20: ivba = INT_VAR_AFC_SIZE_MAX(); break;
00475 case 21: ivba = INT_VAR_ACTIVITY_SIZE_MIN(iaa); break;
00476 case 22: ivba = INT_VAR_ACTIVITY_SIZE_MAX(iaa); break;
00477 case 23: ivba = INT_VAR_REGRET_MIN_MIN(); break;
00478 case 24: ivba = INT_VAR_REGRET_MIN_MAX(); break;
00479 case 25: ivba = INT_VAR_REGRET_MAX_MIN(); break;
00480 case 26: ivba = INT_VAR_REGRET_MAX_MAX(); break;
00481 }
00482
00483 Rnd rb(2);
00484 IntVarBranch ivbb;
00485 IntActivity iab(*c, c->x, 0.9, &int_merit);
00486 switch (varb) {
00487 case 0: ivbb = INT_VAR_NONE(); break;
00488 case 1: ivbb = INT_VAR_NONE(); break;
00489 case 2: ivbb = INT_VAR_RND(rb); break;
00490 case 3: ivbb = INT_VAR_MERIT_MIN(&int_merit,&tbl); break;
00491 case 4: ivbb = INT_VAR_MERIT_MAX(&int_merit,&tbl); break;
00492 case 5: ivbb = INT_VAR_DEGREE_MIN(&tbl); break;
00493 case 6: ivbb = INT_VAR_DEGREE_MAX(&tbl); break;
00494 case 7: ivbb = INT_VAR_AFC_MIN(0.5,&tbl); break;
00495 case 8: ivbb = INT_VAR_AFC_MAX(0.5,&tbl); break;
00496 case 9: ivbb = INT_VAR_ACTIVITY_MIN(iab,&tbl); break;
00497 case 10: ivbb = INT_VAR_ACTIVITY_MAX(iab,&tbl); break;
00498 case 11: ivbb = INT_VAR_MIN_MIN(&tbl); break;
00499 case 12: ivbb = INT_VAR_MIN_MAX(&tbl); break;
00500 case 13: ivbb = INT_VAR_MAX_MIN(&tbl); break;
00501 case 14: ivbb = INT_VAR_MAX_MAX(&tbl); break;
00502 case 15: ivbb = INT_VAR_SIZE_MIN(&tbl); break;
00503 case 16: ivbb = INT_VAR_SIZE_MAX(&tbl); break;
00504 case 17: ivbb = INT_VAR_DEGREE_SIZE_MIN(&tbl); break;
00505 case 18: ivbb = INT_VAR_DEGREE_SIZE_MAX(&tbl); break;
00506 case 19: ivbb = INT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
00507 case 20: ivbb = INT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
00508 case 21: ivbb = INT_VAR_ACTIVITY_SIZE_MIN(iab,&tbl); break;
00509 case 22: ivbb = INT_VAR_ACTIVITY_SIZE_MAX(iab,&tbl); break;
00510 case 23: ivbb = INT_VAR_REGRET_MIN_MIN(&tbl); break;
00511 case 24: ivbb = INT_VAR_REGRET_MIN_MAX(&tbl); break;
00512 case 25: ivbb = INT_VAR_REGRET_MAX_MIN(&tbl); break;
00513 case 26: ivbb = INT_VAR_REGRET_MAX_MAX(&tbl); break;
00514 }
00515
00516 switch (Base::rand(9U)) {
00517 case 0U:
00518 branch(*c, c->x, ivba, ivb); break;
00519 case 1U:
00520 branch(*c, c->x, ivbb, ivb); break;
00521 case 2U:
00522 branch(*c, c->x, tiebreak(ivba,ivbb), ivb); break;
00523 case 3U:
00524 branch(*c, c->x, tiebreak(ivbb,ivba), ivb); break;
00525 case 4U:
00526 branch(*c, c->x, tiebreak(ivba,ivba,ivbb), ivb); break;
00527 case 5U:
00528 branch(*c, c->x, tiebreak(ivba,ivbb,ivbb), ivb); break;
00529 case 6U:
00530 branch(*c, c->x, tiebreak(ivbb,ivba,ivba), ivb); break;
00531 case 7U:
00532 branch(*c, c->x, tiebreak(ivba,ivba,ivbb,ivba), ivb); break;
00533 case 8U:
00534 branch(*c, c->x, tiebreak(ivbb,ivba,ivbb,ivba), ivb); break;
00535 }
00536
00537 }
00538 Gecode::Search::Options o;
00539 results[solutions(c,o)].push_back
00540 (RunInfo(int_var_branch_name[vara],
00541 int_var_branch_name[varb],
00542 int_val_branch_name[val],
00543 o));
00544 }
00545 }
00546 }
00547 if (results.size() > 1)
00548 goto failed;
00549 delete root;
00550 return true;
00551 failed:
00552 std::cout << "FAILURE" << std::endl;
00553 for (map<int, vector<RunInfo> >::iterator it = results.begin();
00554 it != results.end(); ++it) {
00555 std::cout << "Number of solutions: " << it->first << std::endl;
00556 for (unsigned int i = 0; i < it->second.size(); ++i)
00557 std::cout << it->second[i] << " ";
00558 std::cout << std::endl;
00559 }
00560
00561 delete root;
00562 return results.size() == 1;
00563 }
00564
00565 BoolTest::BoolTest(const std::string& s, int a)
00566 : Base("Bool::Branch::"+s), arity(a) {
00567 }
00568
00569 bool
00570 BoolTest::run(void) {
00571 using std::map;
00572 using std::vector;
00573 using std::string;
00574 using std::ostream;
00575 using namespace Gecode;
00576
00577
00578 map<int, vector<RunInfo> > results;
00579
00580 BoolTestSpace* root = new BoolTestSpace(arity);
00581 post(*root, root->x);
00582 results.clear();
00583
00584 IntArgs d(arity);
00585 for (int i=arity; i--; )
00586 d[i]=i % 2;
00587
00588 for (int vara = 0; vara<n_int_var_branch; vara++) {
00589 for (int varb = 1; varb<n_int_var_branch; varb++) {
00590 for (int val = 0; val<n_int_val_branch; val++) {
00591
00592 Rnd r(1);
00593
00594 IntValBranch ivb;
00595 switch (val) {
00596 case 0: ivb = INT_VAL_MIN(); break;
00597 case 1: ivb = INT_VAL_MED(); break;
00598 case 2: ivb = INT_VAL_MAX(); break;
00599 case 3: ivb = INT_VAL_RND(r); break;
00600 case 4: ivb = INT_VAL_SPLIT_MIN(); break;
00601 case 5: ivb = INT_VAL_SPLIT_MAX(); break;
00602 case 6: ivb = INT_VAL_RANGE_MIN(); break;
00603 case 7: ivb = INT_VAL_RANGE_MAX(); break;
00604 case 8: ivb = INT_VAL(&bool_val); break;
00605 case 9: ivb = INT_VALUES_MIN(); break;
00606 case 10: ivb = INT_VALUES_MAX(); break;
00607 case 11: ivb = INT_VAL_NEAR_MIN(d); break;
00608 case 12: ivb = INT_VAL_NEAR_MAX(d); break;
00609 case 13: ivb = INT_VAL_NEAR_INC(d); break;
00610 case 14: ivb = INT_VAL_NEAR_DEC(d); break;
00611 }
00612
00613 BoolTestSpace* c = static_cast<BoolTestSpace*>(root->clone(false));
00614
00615 if ((vara == 0) && (val < 11)) {
00616 for (int i=0; i<c->x.size(); i++)
00617 branch(*c, c->x[i], ivb);
00618 } else {
00619
00620
00621 Rnd ra(1);
00622 IntVarBranch ivba;
00623 IntActivity iaa(*c, c->x, 0.9);
00624 switch (vara) {
00625 case 0: ivba = INT_VAR_NONE(); break;
00626 case 1: ivba = INT_VAR_NONE(); break;
00627 case 2: ivba = INT_VAR_RND(ra); break;
00628 case 3: ivba = INT_VAR_MERIT_MIN(&bool_merit); break;
00629 case 4: ivba = INT_VAR_MERIT_MAX(&bool_merit); break;
00630 case 5: ivba = INT_VAR_DEGREE_MIN(); break;
00631 case 6: ivba = INT_VAR_DEGREE_MAX(); break;
00632 case 7: ivba = INT_VAR_AFC_MIN(0.5); break;
00633 case 8: ivba = INT_VAR_AFC_MAX(0.5); break;
00634 case 9: ivba = INT_VAR_ACTIVITY_MIN(iaa); break;
00635 case 10: ivba = INT_VAR_ACTIVITY_MAX(iaa); break;
00636 case 11: ivba = INT_VAR_MIN_MIN(); break;
00637 case 12: ivba = INT_VAR_MIN_MAX(); break;
00638 case 13: ivba = INT_VAR_MAX_MIN(); break;
00639 case 14: ivba = INT_VAR_MAX_MAX(); break;
00640 case 15: ivba = INT_VAR_SIZE_MIN(); break;
00641 case 16: ivba = INT_VAR_SIZE_MAX(); break;
00642 case 17: ivba = INT_VAR_DEGREE_SIZE_MIN(); break;
00643 case 18: ivba = INT_VAR_DEGREE_SIZE_MAX(); break;
00644 case 19: ivba = INT_VAR_AFC_SIZE_MIN(); break;
00645 case 20: ivba = INT_VAR_AFC_SIZE_MAX(); break;
00646 case 21: ivba = INT_VAR_ACTIVITY_SIZE_MIN(iaa); break;
00647 case 22: ivba = INT_VAR_ACTIVITY_SIZE_MAX(iaa); break;
00648 case 23: ivba = INT_VAR_REGRET_MIN_MIN(); break;
00649 case 24: ivba = INT_VAR_REGRET_MIN_MAX(); break;
00650 case 25: ivba = INT_VAR_REGRET_MAX_MIN(); break;
00651 case 26: ivba = INT_VAR_REGRET_MAX_MAX(); break;
00652 }
00653
00654 Rnd rb(2);
00655 IntVarBranch ivbb;
00656 IntActivity iab(*c, c->x, 0.9, &bool_merit);
00657 switch (varb) {
00658 case 0: ivbb = INT_VAR_NONE(); break;
00659 case 1: ivbb = INT_VAR_NONE(); break;
00660 case 2: ivbb = INT_VAR_RND(rb); break;
00661 case 3: ivbb = INT_VAR_MERIT_MIN(&bool_merit,&tbl); break;
00662 case 4: ivbb = INT_VAR_MERIT_MAX(&bool_merit,&tbl); break;
00663 case 5: ivbb = INT_VAR_DEGREE_MIN(&tbl); break;
00664 case 6: ivbb = INT_VAR_DEGREE_MAX(&tbl); break;
00665 case 7: ivbb = INT_VAR_AFC_MIN(0.5,&tbl); break;
00666 case 8: ivbb = INT_VAR_AFC_MAX(0.5,&tbl); break;
00667 case 9: ivbb = INT_VAR_ACTIVITY_MIN(iab,&tbl); break;
00668 case 10: ivbb = INT_VAR_ACTIVITY_MAX(iab,&tbl); break;
00669 case 11: ivbb = INT_VAR_MIN_MIN(&tbl); break;
00670 case 12: ivbb = INT_VAR_MIN_MAX(&tbl); break;
00671 case 13: ivbb = INT_VAR_MAX_MIN(&tbl); break;
00672 case 14: ivbb = INT_VAR_MAX_MAX(&tbl); break;
00673 case 15: ivbb = INT_VAR_SIZE_MIN(&tbl); break;
00674 case 16: ivbb = INT_VAR_SIZE_MAX(&tbl); break;
00675 case 17: ivbb = INT_VAR_DEGREE_SIZE_MIN(&tbl); break;
00676 case 18: ivbb = INT_VAR_DEGREE_SIZE_MAX(&tbl); break;
00677 case 19: ivbb = INT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
00678 case 20: ivbb = INT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
00679 case 21: ivbb = INT_VAR_ACTIVITY_SIZE_MIN(iab,&tbl); break;
00680 case 22: ivbb = INT_VAR_ACTIVITY_SIZE_MAX(iab,&tbl); break;
00681 case 23: ivbb = INT_VAR_REGRET_MIN_MIN(&tbl); break;
00682 case 24: ivbb = INT_VAR_REGRET_MIN_MAX(&tbl); break;
00683 case 25: ivbb = INT_VAR_REGRET_MAX_MIN(&tbl); break;
00684 case 26: ivbb = INT_VAR_REGRET_MAX_MAX(&tbl); break;
00685 }
00686
00687 switch (Base::rand(9U)) {
00688 case 0U:
00689 branch(*c, c->x, ivba, ivb); break;
00690 case 1U:
00691 branch(*c, c->x, ivbb, ivb); break;
00692 case 2U:
00693 branch(*c, c->x, tiebreak(ivba,ivbb), ivb); break;
00694 case 3U:
00695 branch(*c, c->x, tiebreak(ivbb,ivba), ivb); break;
00696 case 4U:
00697 branch(*c, c->x, tiebreak(ivba,ivba,ivbb), ivb); break;
00698 case 5U:
00699 branch(*c, c->x, tiebreak(ivba,ivbb,ivbb), ivb); break;
00700 case 6U:
00701 branch(*c, c->x, tiebreak(ivbb,ivba,ivba), ivb); break;
00702 case 7U:
00703 branch(*c, c->x, tiebreak(ivba,ivba,ivbb,ivba), ivb); break;
00704 case 8U:
00705 branch(*c, c->x, tiebreak(ivbb,ivba,ivbb,ivba), ivb); break;
00706 }
00707
00708 }
00709 Gecode::Search::Options o;
00710 results[solutions(c,o)].push_back
00711 (RunInfo(int_var_branch_name[vara],
00712 int_var_branch_name[varb],
00713 int_val_branch_name[val],
00714 o));
00715 }
00716 }
00717 }
00718 if (results.size() > 1)
00719 goto failed;
00720 delete root;
00721 return true;
00722 failed:
00723 std::cout << "FAILURE" << std::endl;
00724 for (map<int, vector<RunInfo> >::iterator it = results.begin();
00725 it != results.end(); ++it) {
00726 std::cout << "Number of solutions: " << it->first << std::endl;
00727 for (unsigned int i = 0; i < it->second.size(); ++i)
00728 std::cout << it->second[i] << " ";
00729 std::cout << std::endl;
00730 }
00731
00732 delete root;
00733 return results.size() == 1;
00734 }
00735
00736 #ifdef GECODE_HAS_SET_VARS
00737 SetTest::SetTest(const std::string& s, int a, const Gecode::IntSet& d)
00738 : Base("Set::Branch::"+s), arity(a), dom(d) {
00739 }
00740
00741 bool
00742 SetTest::run(void) {
00743 using std::map;
00744 using std::vector;
00745 using std::string;
00746 using std::ostream;
00747 using namespace Gecode;
00748
00749
00750 map<int, vector<RunInfo> > results;
00751
00752 SetTestSpace* root = new SetTestSpace(arity,dom);
00753 post(*root, root->x);
00754 root->status();
00755 results.clear();
00756
00757 for (int vara = 0; vara<n_set_var_branch; vara++) {
00758 for (int varb = 1; varb<n_set_var_branch; varb++) {
00759 for (int val = 0; val<n_set_val_branch; val++) {
00760 Rnd r(1);
00761
00762 SetValBranch svb;
00763 switch (val) {
00764 case 0: svb = SET_VAL_MIN_INC(); break;
00765 case 1: svb = SET_VAL_MIN_EXC(); break;
00766 case 2: svb = SET_VAL_MED_INC(); break;
00767 case 3: svb = SET_VAL_MED_EXC(); break;
00768 case 4: svb = SET_VAL_MAX_INC(); break;
00769 case 5: svb = SET_VAL_MAX_EXC(); break;
00770 case 6: svb = SET_VAL_RND_INC(r); break;
00771 case 7: svb = SET_VAL_RND_EXC(r); break;
00772 case 8: svb = SET_VAL(&set_val); break;
00773 }
00774
00775 SetTestSpace* c = static_cast<SetTestSpace*>(root->clone(false));
00776
00777 if (vara == 0) {
00778 for (int i=0; i<c->x.size(); i++)
00779 branch(*c, c->x[i], svb);
00780 } else {
00781 Rnd ra(1);
00782 SetVarBranch svba;
00783 SetActivity saa(*c, c->x, 0.9);
00784 switch (vara) {
00785 case 0: break;
00786 case 1: svba = SET_VAR_NONE(); break;
00787 case 2: svba = SET_VAR_RND(ra); break;
00788 case 3: svba = SET_VAR_MERIT_MIN(&set_merit); break;
00789 case 4: svba = SET_VAR_MERIT_MAX(&set_merit); break;
00790 case 5: svba = SET_VAR_DEGREE_MIN(); break;
00791 case 6: svba = SET_VAR_DEGREE_MAX(); break;
00792 case 7: svba = SET_VAR_AFC_MIN(0.5); break;
00793 case 8: svba = SET_VAR_AFC_MAX(0.5); break;
00794 case 9: svba = SET_VAR_ACTIVITY_MIN(saa); break;
00795 case 10: svba = SET_VAR_ACTIVITY_MAX(saa); break;
00796 case 11: svba = SET_VAR_MIN_MIN(); break;
00797 case 12: svba = SET_VAR_MIN_MAX(); break;
00798 case 13: svba = SET_VAR_MAX_MIN(); break;
00799 case 14: svba = SET_VAR_MAX_MAX(); break;
00800 case 15: svba = SET_VAR_SIZE_MIN(); break;
00801 case 16: svba = SET_VAR_SIZE_MAX(); break;
00802 case 17: svba = SET_VAR_DEGREE_SIZE_MIN(); break;
00803 case 18: svba = SET_VAR_DEGREE_SIZE_MAX(); break;
00804 case 19: svba = SET_VAR_AFC_SIZE_MIN(); break;
00805 case 20: svba = SET_VAR_AFC_SIZE_MAX(); break;
00806 case 21: svba = SET_VAR_ACTIVITY_SIZE_MIN(saa); break;
00807 case 22: svba = SET_VAR_ACTIVITY_SIZE_MAX(saa); break;
00808 }
00809
00810 Rnd rb(2);
00811 SetVarBranch svbb;
00812 SetActivity sab(*c, c->x, 0.9, &set_merit);
00813 switch (varb) {
00814 case 0: break;
00815 case 1: svbb = SET_VAR_NONE(); break;
00816 case 2: svbb = SET_VAR_RND(rb); break;
00817 case 3: svbb = SET_VAR_MERIT_MIN(&set_merit,&tbl); break;
00818 case 4: svbb = SET_VAR_MERIT_MAX(&set_merit,&tbl); break;
00819 case 5: svbb = SET_VAR_DEGREE_MIN(&tbl); break;
00820 case 6: svbb = SET_VAR_DEGREE_MAX(&tbl); break;
00821 case 7: svbb = SET_VAR_AFC_MIN(0.5,&tbl); break;
00822 case 8: svbb = SET_VAR_AFC_MAX(0.5,&tbl); break;
00823 case 9: svbb = SET_VAR_ACTIVITY_MIN(sab,&tbl); break;
00824 case 10: svbb = SET_VAR_ACTIVITY_MAX(sab,&tbl); break;
00825 case 11: svbb = SET_VAR_MIN_MIN(&tbl); break;
00826 case 12: svbb = SET_VAR_MIN_MAX(&tbl); break;
00827 case 13: svbb = SET_VAR_MAX_MIN(&tbl); break;
00828 case 14: svbb = SET_VAR_MAX_MAX(&tbl); break;
00829 case 15: svbb = SET_VAR_SIZE_MIN(&tbl); break;
00830 case 16: svbb = SET_VAR_SIZE_MAX(&tbl); break;
00831 case 17: svbb = SET_VAR_DEGREE_SIZE_MIN(&tbl); break;
00832 case 18: svbb = SET_VAR_DEGREE_SIZE_MAX(&tbl); break;
00833 case 19: svbb = SET_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
00834 case 20: svbb = SET_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
00835 case 21: svbb = SET_VAR_ACTIVITY_SIZE_MIN(sab,&tbl); break;
00836 case 22: svbb = SET_VAR_ACTIVITY_SIZE_MAX(sab,&tbl); break;
00837 }
00838
00839 switch (Base::rand(9U)) {
00840 case 0U:
00841 branch(*c, c->x, svba, svb); break;
00842 case 1U:
00843 branch(*c, c->x, svbb, svb); break;
00844 case 2U:
00845 branch(*c, c->x, tiebreak(svba,svbb), svb); break;
00846 case 3U:
00847 branch(*c, c->x, tiebreak(svbb,svba), svb); break;
00848 case 4U:
00849 branch(*c, c->x, tiebreak(svba,svba,svbb), svb); break;
00850 case 5U:
00851 branch(*c, c->x, tiebreak(svba,svbb,svbb), svb); break;
00852 case 6U:
00853 branch(*c, c->x, tiebreak(svbb,svba,svba), svb); break;
00854 case 7U:
00855 branch(*c, c->x, tiebreak(svba,svba,svbb,svba), svb); break;
00856 case 8U:
00857 branch(*c, c->x, tiebreak(svbb,svba,svbb,svba), svb); break;
00858 }
00859
00860 }
00861 Gecode::Search::Options o;
00862 results[solutions(c,o)].push_back
00863 (RunInfo(set_var_branch_name[vara],
00864 set_var_branch_name[varb],
00865 set_val_branch_name[val],
00866 o));
00867 }
00868 }
00869 }
00870 if (results.size() > 1)
00871 goto failed;
00872 delete root;
00873 return true;
00874 failed:
00875 std::cout << "FAILURE" << std::endl;
00876 for (map<int, vector<RunInfo> >::iterator it = results.begin();
00877 it != results.end(); ++it) {
00878 std::cout << "Number of solutions: " << it->first << std::endl;
00879 for (unsigned int i = 0; i < it->second.size(); ++i)
00880 std::cout << it->second[i] << " ";
00881 std::cout << std::endl;
00882 }
00883
00884 delete root;
00885 return results.size() == 1;
00886 }
00887 #endif
00888
00889 #ifdef GECODE_HAS_FLOAT_VARS
00890 FloatTest::FloatTest(const std::string& s, int a, const Gecode::FloatVal& d, int nbs)
00891 : Base("Float::Branch::"+s), arity(a), dom(d), nbSols(nbs) {
00892 }
00893
00894 bool
00895 FloatTest::run(void) {
00896 using std::map;
00897 using std::vector;
00898 using std::string;
00899 using std::ostream;
00900 using namespace Gecode;
00901
00902
00903 map<int, vector<RunInfo> > results;
00904
00905 FloatTestSpace* root = new FloatTestSpace(arity,dom);
00906 post(*root, root->x);
00907 root->status();
00908 results.clear();
00909
00910 for (int vara = 0; vara<n_float_var_branch; vara++) {
00911 for (int varb = 1; varb<n_float_var_branch; varb++) {
00912 for (int val = 0; val<n_float_val_branch; val++) {
00913 Rnd r(1);
00914
00915 FloatValBranch fvb;
00916 switch (val) {
00917 case 0: fvb = FLOAT_VAL_SPLIT_MIN(); break;
00918 case 1: fvb = FLOAT_VAL_SPLIT_MAX(); break;
00919 case 2: fvb = FLOAT_VAL_SPLIT_RND(r); break;
00920 case 3: fvb = FLOAT_VAL(&float_val); break;
00921 }
00922
00923 FloatTestSpace* c = static_cast<FloatTestSpace*>(root->clone(false));
00924 if (vara == 0) {
00925 for (int i=0; i<c->x.size(); i++)
00926 branch(*c, c->x[i], fvb);
00927 } else {
00928 Rnd ra(1);
00929 FloatVarBranch fvba;
00930 FloatActivity faa(*c, c->x, 0.9);
00931 switch (vara) {
00932 case 0: break;
00933 case 1: fvba = FLOAT_VAR_NONE(); break;
00934 case 2: fvba = FLOAT_VAR_RND(ra); break;
00935 case 3: fvba = FLOAT_VAR_MERIT_MIN(&float_merit); break;
00936 case 4: fvba = FLOAT_VAR_MERIT_MAX(&float_merit); break;
00937 case 5: fvba = FLOAT_VAR_DEGREE_MIN(); break;
00938 case 6: fvba = FLOAT_VAR_DEGREE_MAX(); break;
00939 case 7: fvba = FLOAT_VAR_AFC_MIN(0.5); break;
00940 case 8: fvba = FLOAT_VAR_AFC_MAX(0.5); break;
00941 case 9: fvba = FLOAT_VAR_ACTIVITY_MIN(faa); break;
00942 case 10: fvba = FLOAT_VAR_ACTIVITY_MAX(faa); break;
00943 case 11: fvba = FLOAT_VAR_MIN_MIN(); break;
00944 case 12: fvba = FLOAT_VAR_MIN_MAX(); break;
00945 case 13: fvba = FLOAT_VAR_MAX_MIN(); break;
00946 case 14: fvba = FLOAT_VAR_MAX_MAX(); break;
00947 case 15: fvba = FLOAT_VAR_SIZE_MIN(); break;
00948 case 16: fvba = FLOAT_VAR_SIZE_MAX(); break;
00949 case 17: fvba = FLOAT_VAR_DEGREE_SIZE_MIN(); break;
00950 case 18: fvba = FLOAT_VAR_DEGREE_SIZE_MAX(); break;
00951 case 19: fvba = FLOAT_VAR_AFC_SIZE_MIN(); break;
00952 case 20: fvba = FLOAT_VAR_AFC_SIZE_MAX(); break;
00953 case 21: fvba = FLOAT_VAR_ACTIVITY_SIZE_MIN(faa); break;
00954 case 22: fvba = FLOAT_VAR_ACTIVITY_SIZE_MAX(faa); break;
00955 }
00956
00957 Rnd rb(2);
00958 FloatVarBranch fvbb;
00959 FloatActivity fab(*c, c->x, 0.9, &float_merit);
00960 switch (varb) {
00961 case 0: break;
00962 case 1: fvbb = FLOAT_VAR_NONE(); break;
00963 case 2: fvbb = FLOAT_VAR_RND(rb); break;
00964 case 3: fvbb = FLOAT_VAR_MERIT_MIN(&float_merit,&tbl); break;
00965 case 4: fvbb = FLOAT_VAR_MERIT_MAX(&float_merit,&tbl); break;
00966 case 5: fvbb = FLOAT_VAR_DEGREE_MIN(&tbl); break;
00967 case 6: fvbb = FLOAT_VAR_DEGREE_MAX(&tbl); break;
00968 case 7: fvbb = FLOAT_VAR_AFC_MIN(0.5,&tbl); break;
00969 case 8: fvbb = FLOAT_VAR_AFC_MAX(0.5,&tbl); break;
00970 case 9: fvbb = FLOAT_VAR_ACTIVITY_MIN(fab,&tbl); break;
00971 case 10: fvbb = FLOAT_VAR_ACTIVITY_MAX(fab,&tbl); break;
00972 case 11: fvbb = FLOAT_VAR_MIN_MIN(&tbl); break;
00973 case 12: fvbb = FLOAT_VAR_MIN_MAX(&tbl); break;
00974 case 13: fvbb = FLOAT_VAR_MAX_MIN(&tbl); break;
00975 case 14: fvbb = FLOAT_VAR_MAX_MAX(&tbl); break;
00976 case 15: fvbb = FLOAT_VAR_SIZE_MIN(&tbl); break;
00977 case 16: fvbb = FLOAT_VAR_SIZE_MAX(&tbl); break;
00978 case 17: fvbb = FLOAT_VAR_DEGREE_SIZE_MIN(&tbl); break;
00979 case 18: fvbb = FLOAT_VAR_DEGREE_SIZE_MAX(&tbl); break;
00980 case 19: fvbb = FLOAT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
00981 case 20: fvbb = FLOAT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
00982 case 21: fvbb = FLOAT_VAR_ACTIVITY_SIZE_MIN(fab,&tbl); break;
00983 case 22: fvbb = FLOAT_VAR_ACTIVITY_SIZE_MAX(fab,&tbl); break;
00984 }
00985
00986 switch (Base::rand(9U)) {
00987 case 0U:
00988 branch(*c, c->x, fvba, fvb); break;
00989 case 1U:
00990 branch(*c, c->x, fvbb, fvb); break;
00991 case 2U:
00992 branch(*c, c->x, tiebreak(fvba,fvbb), fvb); break;
00993 case 3U:
00994 branch(*c, c->x, tiebreak(fvbb,fvba), fvb); break;
00995 case 4U:
00996 branch(*c, c->x, tiebreak(fvba,fvba,fvbb), fvb); break;
00997 case 5U:
00998 branch(*c, c->x, tiebreak(fvba,fvbb,fvbb), fvb); break;
00999 case 6U:
01000 branch(*c, c->x, tiebreak(fvbb,fvba,fvba), fvb); break;
01001 case 7U:
01002 branch(*c, c->x, tiebreak(fvba,fvba,fvbb,fvba), fvb); break;
01003 case 8U:
01004 branch(*c, c->x, tiebreak(fvbb,fvba,fvbb,fvba), fvb); break;
01005 }
01006
01007 }
01008 Gecode::Search::Options o;
01009 results[solutions(c,o,nbSols)].push_back
01010 (RunInfo(float_var_branch_name[vara],
01011 float_var_branch_name[varb],
01012 float_val_branch_name[val],
01013 o));
01014 }
01015 }
01016 }
01017 if (results.size() > 1)
01018 goto failed;
01019 delete root;
01020 return true;
01021 failed:
01022 std::cout << "FAILURE" << std::endl;
01023 for (map<int, vector<RunInfo> >::iterator it = results.begin();
01024 it != results.end(); ++it) {
01025 std::cout << "Number of solutions: " << it->first << std::endl;
01026 for (unsigned int i = 0; i < it->second.size(); ++i)
01027 std::cout << it->second[i] << " ";
01028 std::cout << std::endl;
01029 }
01030
01031 delete root;
01032 return results.size() == 1;
01033 }
01034 #endif
01035
01036 }}
01037
01038