Generated on for Gecode by doxygen 1.17.0
branch.cpp
Go to the documentation of this file.
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
5 * Christian Schulte <schulte@gecode.dev>
6 *
7 * Contributing authors:
8 * Vincent Barichard <Vincent.Barichard@univ-angers.fr>
9 *
10 * Copyright:
11 * Mikael Zayenz Lagerkvist, 2005
12 * Christian Schulte, 2009
13 * Vincent Barichard, 2012
14 *
15 * This file is part of Gecode, the generic constraint
16 * development environment:
17 * http://www.gecode.dev
18 *
19 * Permission is hereby granted, free of charge, to any person obtaining
20 * a copy of this software and associated documentation files (the
21 * "Software"), to deal in the Software without restriction, including
22 * without limitation the rights to use, copy, modify, merge, publish,
23 * distribute, sublicense, and/or sell copies of the Software, and to
24 * permit persons to whom the Software is furnished to do so, subject to
25 * the following conditions:
26 *
27 * The above copyright notice and this permission notice shall be
28 * included in all copies or substantial portions of the Software.
29 *
30 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
31 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
32 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
33 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
34 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
35 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 *
38 */
39
40#include "test/branch.hh"
41
42#include <algorithm>
43#include <map>
44#include <vector>
45#include <iostream>
46
47#include <gecode/kernel.hh>
48#include <gecode/int.hh>
49#ifdef GECODE_HAS_SET_VARS
50#include <gecode/set.hh>
51#endif
52#ifdef GECODE_HAS_FLOAT_VARS
53#include <gecode/float.hh>
54#endif
55
56#include <gecode/search.hh>
57
58namespace Test { namespace Branch {
59
61 double tbl(const Gecode::Space&, double w, double b) {
62 return (w + (b-w)/2.0);
63 }
64
66 class IntTestSpace : public Gecode::Space {
67 public:
76 : x(*this, n, d),
77 vara(Gecode::INT_VAR_NONE()), varb(Gecode::INT_VAR_NONE()),
78 val(Gecode::INT_VAL_MIN()) {}
79
81 : Gecode::Space(s), vara(s.vara), varb(s.varb), val(s.val) {
82 x.update(*this, s.x);
83 }
84
85 virtual Gecode::Space* copy(void) {
86 return new IntTestSpace(*this);
87 }
88 };
89
92 public:
97 : x(*this, n, 0, 1) {}
98
100 : Gecode::Space(s) {
101 x.update(*this, s.x);
102 }
103
104 virtual Gecode::Space* copy(void) {
105 return new BoolTestSpace(*this);
106 }
107 };
108
109#ifdef GECODE_HAS_SET_VARS
112 public:
117 : x(*this, n, Gecode::IntSet::empty, d) {}
118
120 : Gecode::Space(s) {
121 x.update(*this, s.x);
122 }
123
124 virtual Gecode::Space* copy(void) {
125 return new SetTestSpace(*this);
126 }
127 };
128#endif
129
130#ifdef GECODE_HAS_FLOAT_VARS
133 public:
138 : x(*this, n, d.min(), d.max()) {}
139
141 : Gecode::Space(s) {
142 x.update(*this, s.x);
143 }
144
145 virtual Gecode::Space* copy(void) {
146 return new FloatTestSpace(*this);
147 }
148 };
149#endif
150
156
157 const char* int_var_branch_name[] = {
158 "SINGLE VARIABLE",
159 "INT_VAR_NONE",
160 "INT_VAR_RND",
161 "INT_VAR_MERIT_MIN",
162 "INT_VAR_MERIT_MAX",
163 "INT_VAR_DEGREE_MIN",
164 "INT_VAR_DEGREE_MAX",
165 "INT_VAR_AFC_MIN",
166 "INT_VAR_AFC_MAX",
167 "INT_VAR_ACTION_MIN",
168 "INT_VAR_ACTION_MAX",
169 "INT_VAR_CHB_MIN",
170 "INT_VAR_CHB_MAX",
171 "INT_VAR_MIN_MIN",
172 "INT_VAR_MIN_MAX",
173 "INT_VAR_MAX_MIN",
174 "INT_VAR_MAX_MAX",
175 "INT_VAR_SIZE_MIN",
176 "INT_VAR_SIZE_MAX",
177 "INT_VAR_DEGREE_SIZE_MIN",
178 "INT_VAR_DEGREE_SIZE_MAX",
179 "INT_VAR_AFC_SIZE_MIN",
180 "INT_VAR_AFC_SIZE_MAX",
181 "INT_VAR_ACTION_SIZE_MIN",
182 "INT_VAR_ACTION_SIZE_MAX",
183 "INT_VAR_CHB_SIZE_MIN",
184 "INT_VAR_CHB_SIZE_MAX",
185 "INT_VAR_REGRET_MIN_MIN",
186 "INT_VAR_REGRET_MIN_MAX",
187 "INT_VAR_REGRET_MAX_MIN",
188 "INT_VAR_REGRET_MAX_MAX"
189 };
190
192 sizeof(int_var_branch_name)/sizeof(const char*);
194 const char* bool_var_branch_name[] = {
195 "SINGLE VARIABLE",
196 "BOOL_VAR_NONE",
197 "BOOL_VAR_RND",
198 "BOOL_VAR_MERIT_MIN",
199 "BOOL_VAR_MERIT_MAX",
200 "BOOL_VAR_DEGREE_MIN",
201 "BOOL_VAR_DEGREE_MAX",
202 "BOOL_VAR_AFC_MIN",
203 "BOOL_VAR_AFC_MAX",
204 "BOOL_VAR_ACTION_MIN",
205 "BOOL_VAR_ACTION_MAX",
206 "BOOL_VAR_CHB_MIN",
207 "BOOL_VAR_CHB_MAX"
208 };
209
211 sizeof(bool_var_branch_name)/sizeof(const char*);
214 return x.min();
215 }
216
218 return x.min();
219 }
220
221 const char* int_val_branch_name[] = {
222 "INT_VAL_MIN",
223 "INT_VAL_MED",
224 "INT_VAL_MAX",
225 "INT_VAL_RND",
226 "INT_VAL_SPLIT_MIN",
227 "INT_VAL_SPLIT_MAX",
228 "INT_VAL_RANGE_MIN",
229 "INT_VAL_RANGE_MAX",
230 "INT_VAL",
231 "INT_VALUES_MIN",
232 "INT_VALUES_MAX"
233 };
234
236 sizeof(int_val_branch_name)/sizeof(const char*);
238 const char* bool_val_branch_name[] = {
239 "BOOL_VAL_MIN",
240 "BOOL_VAL_MAX",
241 "BOOL_VAL_RND",
242 "BOOL_VAL"
243 };
244
246 sizeof(bool_val_branch_name)/sizeof(const char*);
249 return x.min();
250 }
251
253 return x.min();
254 }
255
256
257#ifdef GECODE_HAS_SET_VARS
263
264 const char* set_var_branch_name[] = {
265 "SINGLE VARIABLE",
266 "SET_VAR_NONE",
267 "SET_VAR_RND",
268 "SET_VAR_MERIT_MIN",
269 "SET_VAR_MERIT_MAX",
270 "SET_VAR_DEGREE_MIN",
271 "SET_VAR_DEGREE_MAX",
272 "SET_VAR_AFC_MIN",
273 "SET_VAR_AFC_MAX",
274 "SET_VAR_ACTION_MIN",
275 "SET_VAR_ACTION_MAX",
276 "SET_VAR_CHB_MIN",
277 "SET_VAR_CHB_MAX",
278 "SET_VAR_MIN_MIN",
279 "SET_VAR_MIN_MAX",
280 "SET_VAR_MAX_MIN",
281 "SET_VAR_MAX_MAX",
282 "SET_VAR_SIZE_MIN",
283 "SET_VAR_SIZE_MAX",
284 "SET_VAR_DEGREE_SIZE_MIN",
285 "SET_VAR_DEGREE_SIZE_MAX",
286 "SET_VAR_AFC_SIZE_MIN",
287 "SET_VAR_AFC_SIZE_MAX",
288 "SET_VAR_ACTION_SIZE_MIN",
289 "SET_VAR_ACTION_SIZE_MAX",
290 "SET_VAR_CHB_SIZE_MIN",
291 "SET_VAR_CHB_SIZE_MAX"
292 };
293
295 sizeof(set_var_branch_name)/sizeof(const char*);
298 return 2.0;
299 }
300
301 const char* set_val_branch_name[] = {
302 "SET_VAL_MIN_INC",
303 "SET_VAL_MIN_EXC",
304 "SET_VAL_MED_INC",
305 "SET_VAL_MED_EXC",
306 "SET_VAL_MAX_INC",
307 "SET_VAL_MAX_EXC",
308 "SET_VAL_RND_INC",
309 "SET_VAL_RND_EXC",
310 "SET_VAL"
311 };
312
314 sizeof(set_val_branch_name)/sizeof(const char*);
318 return r.min();
319 }
320
321#endif
322
323#ifdef GECODE_HAS_FLOAT_VARS
329
330 const char* float_var_branch_name[] = {
331 "SINGLE VARIABLE",
332 "FLOAT_VAR_NONE",
333 "FLOAT_VAR_RND",
334 "FLOAT_VAR_MERIT_MIN",
335 "FLOAT_VAR_MERIT_MAX",
336 "FLOAT_VAR_DEGREE_MIN",
337 "FLOAT_VAR_DEGREE_MAX",
338 "FLOAT_VAR_AFC_MIN",
339 "FLOAT_VAR_AFC_MAX",
340 "FLOAT_VAR_ACTION_MIN",
341 "FLOAT_VAR_ACTION_MAX",
342 "FLOAT_VAR_CHB_MIN",
343 "FLOAT_VAR_CHB_MAX",
344 "FLOAT_VAR_MIN_MIN",
345 "FLOAT_VAR_MIN_MAX",
346 "FLOAT_VAR_MAX_MIN",
347 "FLOAT_VAR_MAX_MAX",
348 "FLOAT_VAR_SIZE_MIN",
349 "FLOAT_VAR_SIZE_MAX",
350 "FLOAT_VAR_DEGREE_SIZE_MIN",
351 "FLOAT_VAR_DEGREE_SIZE_MAX",
352 "FLOAT_VAR_AFC_SIZE_MIN",
353 "FLOAT_VAR_AFC_SIZE_MAX",
354 "FLOAT_VAR_ACTION_SIZE_MIN",
355 "FLOAT_VAR_ACTION_SIZE_MAX",
356 "FLOAT_VAR_CHB_SIZE_MIN",
357 "FLOAT_VAR_CHB_SIZE_MAX"
358 };
359
361 sizeof(float_var_branch_name)/sizeof(const char*);
364 return static_cast<double>(x.degree());
365 }
366
367 const char* float_val_branch_name[] = {
368 "FLOAT_VAL_SPLIT_MIN",
369 "FLOAT_VAL_SPLIT_MAX",
370 "FLOAT_VAL_SPLIT_RND",
371 "FLOAT_VAL"
372 };
373
375 sizeof(float_val_branch_name)/sizeof(const char*);
378 Gecode::FloatVar x, int) {
379 Gecode::FloatNumBranch nl; nl.n=x.med(); nl.l=true;
380 return nl;
381 }
382
383#endif
384
386 class RunInfo {
387 public:
388 std::string var, val;
389 unsigned int a_d, c_d;
390 RunInfo(const std::string& vara, const std::string& varb,
391 const std::string& valname,
393 : var(vara + "::" + varb), val(valname), a_d(o.a_d), c_d(o.c_d) {}
394 void print(std::ostream& o) const {
395 o << "(" << var << ", " << val << ", " << a_d << ", " << c_d << ")";
396 }
397 };
398
399}}
400
401std::ostream&
402operator<<(std::ostream& os, const Test::Branch::RunInfo& ri) {
403 ri.print(os);
404 return os;
405}
406
407
408namespace Test { namespace Branch {
409
411 template<class TestSpace>
412 int solutions(TestSpace* c, Gecode::Search::Options& o, Gecode::Support::RandomGenerator& rand, int maxNbSol = -1) {
413 o.a_d = rand(10);
414 o.c_d = rand(10);
415 Gecode::DFS<TestSpace> e_s(c, o);
416 delete c;
417
418 // Find number of solutions
419 int s = 0;
420 do {
421 Gecode::Space* ex = e_s.next();
422 if (ex == nullptr) break;
423 delete ex;
424 ++s;
425 if ((maxNbSol >= 0) && (maxNbSol == s)) break;
426 } while (true);
427 return s;
428 }
429
430 IntTest::IntTest(const std::string& s, int a, const Gecode::IntSet& d)
431 : Base("Int::Branch::"+s), arity(a), dom(d) {
432 }
433
434 bool
436 using std::map;
437 using std::vector;
438 using std::string;
439 using std::ostream;
440 using namespace Gecode;
441
442 // Results of tests run
443 map<int, vector<RunInfo> > results;
444 // Set up root space
445 IntTestSpace* root = new IntTestSpace(arity,dom);
446 post(*root, root->x);
447 results.clear();
448
449 IntArgs d(arity);
450 for (int i=arity; i--; )
451 d[i]=i;
452
453 for (int vara = 0; vara<n_int_var_branch; vara++) {
454 for (int varb = 1; varb<n_int_var_branch; varb++) {
455 for (int val = 0; val<n_int_val_branch; val++) {
456 Rnd r(1);
457
458 IntValBranch ivb;
459 switch (val) {
460 case 0: ivb = INT_VAL_MIN(); break;
461 case 1: ivb = INT_VAL_MED(); break;
462 case 2: ivb = INT_VAL_MAX(); break;
463 case 3: ivb = INT_VAL_RND(r); break;
464 case 4: ivb = INT_VAL_SPLIT_MIN(); break;
465 case 5: ivb = INT_VAL_SPLIT_MAX(); break;
466 case 6: ivb = INT_VAL_RANGE_MIN(); break;
467 case 7: ivb = INT_VAL_RANGE_MAX(); break;
468 case 8: ivb = INT_VAL(&int_val); break;
469 case 9: ivb = INT_VALUES_MIN(); break;
470 case 10: ivb = INT_VALUES_MAX(); break;
471 }
472
473 IntTestSpace* c = static_cast<IntTestSpace*>(root->clone());
474
475 if ((vara == 0) && (val < 11)) {
476 for (int i=0; i<c->x.size(); i++)
477 branch(*c, c->x[i], ivb);
478 } else {
479 Rnd ra(1);
480 IntVarBranch ivba;
481 IntAction iaa(*c, c->x, 0.9);
482 IntCHB ica(*c, c->x);
483 switch (vara) {
484 case 0: ivba = INT_VAR_NONE(); break;
485 case 1: ivba = INT_VAR_NONE(); break;
486 case 2: ivba = INT_VAR_RND(ra); break;
487 case 3: ivba = INT_VAR_MERIT_MIN(&int_merit); break;
488 case 4: ivba = INT_VAR_MERIT_MAX(&int_merit); break;
489 case 5: ivba = INT_VAR_DEGREE_MIN(); break;
490 case 6: ivba = INT_VAR_DEGREE_MAX(); break;
491 case 7: ivba = INT_VAR_AFC_MIN(0.5); break;
492 case 8: ivba = INT_VAR_AFC_MAX(0.5); break;
493 case 9: ivba = INT_VAR_ACTION_MIN(iaa); break;
494 case 10: ivba = INT_VAR_ACTION_MAX(iaa); break;
495 case 11: ivba = INT_VAR_CHB_MIN(ica); break;
496 case 12: ivba = INT_VAR_CHB_MAX(ica); break;
497 case 13: ivba = INT_VAR_MIN_MIN(); break;
498 case 14: ivba = INT_VAR_MIN_MAX(); break;
499 case 15: ivba = INT_VAR_MAX_MIN(); break;
500 case 16: ivba = INT_VAR_MAX_MAX(); break;
501 case 17: ivba = INT_VAR_SIZE_MIN(); break;
502 case 18: ivba = INT_VAR_SIZE_MAX(); break;
503 case 19: ivba = INT_VAR_DEGREE_SIZE_MIN(); break;
504 case 20: ivba = INT_VAR_DEGREE_SIZE_MAX(); break;
505 case 21: ivba = INT_VAR_AFC_SIZE_MIN(); break;
506 case 22: ivba = INT_VAR_AFC_SIZE_MAX(); break;
507 case 23: ivba = INT_VAR_ACTION_SIZE_MIN(iaa); break;
508 case 24: ivba = INT_VAR_ACTION_SIZE_MAX(iaa); break;
509 case 25: ivba = INT_VAR_CHB_SIZE_MIN(ica); break;
510 case 26: ivba = INT_VAR_CHB_SIZE_MAX(ica); break;
511 case 27: ivba = INT_VAR_REGRET_MIN_MIN(); break;
512 case 28: ivba = INT_VAR_REGRET_MIN_MAX(); break;
513 case 29: ivba = INT_VAR_REGRET_MAX_MIN(); break;
514 case 30: ivba = INT_VAR_REGRET_MAX_MAX(); break;
515 }
516
517 Rnd rb(2);
518 IntVarBranch ivbb;
519 IntAction iab(*c, c->x, 0.9, true, true, &int_merit);
520 IntCHB icb(*c, c->x, &int_merit);
521 switch (varb) {
522 case 0: ivbb = INT_VAR_NONE(); break;
523 case 1: ivbb = INT_VAR_NONE(); break;
524 case 2: ivbb = INT_VAR_RND(rb); break;
525 case 3: ivbb = INT_VAR_MERIT_MIN(&int_merit,&tbl); break;
526 case 4: ivbb = INT_VAR_MERIT_MAX(&int_merit,&tbl); break;
527 case 5: ivbb = INT_VAR_DEGREE_MIN(&tbl); break;
528 case 6: ivbb = INT_VAR_DEGREE_MAX(&tbl); break;
529 case 7: ivbb = INT_VAR_AFC_MIN(0.5,&tbl); break;
530 case 8: ivbb = INT_VAR_AFC_MAX(0.5,&tbl); break;
531 case 9: ivbb = INT_VAR_ACTION_MIN(iab,&tbl); break;
532 case 10: ivbb = INT_VAR_ACTION_MAX(iab,&tbl); break;
533 case 11: ivbb = INT_VAR_CHB_MIN(icb,&tbl); break;
534 case 12: ivbb = INT_VAR_CHB_MAX(icb,&tbl); break;
535 case 13: ivbb = INT_VAR_MIN_MIN(&tbl); break;
536 case 14: ivbb = INT_VAR_MIN_MAX(&tbl); break;
537 case 15: ivbb = INT_VAR_MAX_MIN(&tbl); break;
538 case 16: ivbb = INT_VAR_MAX_MAX(&tbl); break;
539 case 17: ivbb = INT_VAR_SIZE_MIN(&tbl); break;
540 case 18: ivbb = INT_VAR_SIZE_MAX(&tbl); break;
541 case 19: ivbb = INT_VAR_DEGREE_SIZE_MIN(&tbl); break;
542 case 20: ivbb = INT_VAR_DEGREE_SIZE_MAX(&tbl); break;
543 case 21: ivbb = INT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
544 case 22: ivbb = INT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
545 case 23: ivbb = INT_VAR_ACTION_SIZE_MIN(iab,&tbl); break;
546 case 24: ivbb = INT_VAR_ACTION_SIZE_MAX(iab,&tbl); break;
547 case 25: ivbb = INT_VAR_CHB_SIZE_MIN(icb,&tbl); break;
548 case 26: ivbb = INT_VAR_CHB_SIZE_MAX(icb,&tbl); break;
549 case 27: ivbb = INT_VAR_REGRET_MIN_MIN(&tbl); break;
550 case 28: ivbb = INT_VAR_REGRET_MIN_MAX(&tbl); break;
551 case 29: ivbb = INT_VAR_REGRET_MAX_MIN(&tbl); break;
552 case 30: ivbb = INT_VAR_REGRET_MAX_MAX(&tbl); break;
553 }
554
555 switch (_rand(9U)) {
556 case 0U:
557 branch(*c, c->x, ivba, ivb); break;
558 case 1U:
559 branch(*c, c->x, ivbb, ivb); break;
560 case 2U:
561 branch(*c, c->x, tiebreak(ivba,ivbb), ivb); break;
562 case 3U:
563 branch(*c, c->x, tiebreak(ivbb,ivba), ivb); break;
564 case 4U:
565 branch(*c, c->x, tiebreak(ivba,ivba,ivbb), ivb); break;
566 case 5U:
567 branch(*c, c->x, tiebreak(ivba,ivbb,ivbb), ivb); break;
568 case 6U:
569 branch(*c, c->x, tiebreak(ivbb,ivba,ivba), ivb); break;
570 case 7U:
571 branch(*c, c->x, tiebreak(ivba,ivba,ivbb,ivba), ivb); break;
572 case 8U:
573 branch(*c, c->x, tiebreak(ivbb,ivba,ivbb,ivba), ivb); break;
574 }
575
576 }
578 results[solutions(c, o, _rand)].push_back
579 (RunInfo(int_var_branch_name[vara],
580 int_var_branch_name[varb],
581 int_val_branch_name[val],
582 o));
583 }
584 }
585 }
586 if (results.size() > 1)
587 goto failed;
588 delete root;
589 return true;
590 failed:
591 std::cout << "FAILURE" << std::endl;
592 for (map<int, vector<RunInfo> >::iterator it = results.begin();
593 it != results.end(); ++it) {
594 std::cout << "Number of solutions: " << it->first << std::endl;
595 for (unsigned int i = 0; i < it->second.size(); ++i)
596 std::cout << it->second[i] << " ";
597 std::cout << std::endl;
598 }
599
600 delete root;
601 return results.size() == 1;
602 }
603
604 BoolTest::BoolTest(const std::string& s, int a)
605 : Base("Bool::Branch::"+s), arity(a) {
606 }
607
608 bool
610 using std::map;
611 using std::vector;
612 using std::string;
613 using std::ostream;
614 using namespace Gecode;
615
616 // Results of tests run
617 map<int, vector<RunInfo> > results;
618 // Set up root space
619 BoolTestSpace* root = new BoolTestSpace(arity);
620 post(*root, root->x);
621 results.clear();
622
623 for (int vara = 0; vara<n_bool_var_branch; vara++) {
624 for (int varb = 1; varb<n_bool_var_branch; varb++) {
625 for (int val = 0; val<n_bool_val_branch; val++) {
626
627 Rnd r(1);
628
629 BoolValBranch bvb;
630 switch (val) {
631 case 0: bvb = BOOL_VAL_MIN(); break;
632 case 1: bvb = BOOL_VAL_MAX(); break;
633 case 2: bvb = BOOL_VAL_RND(r); break;
634 case 3: bvb = BOOL_VAL(&bool_val); break;
635 }
636
637 BoolTestSpace* c = static_cast<BoolTestSpace*>(root->clone());
638
639 if (vara == 0) {
640 for (int i=0; i<c->x.size(); i++)
641 branch(*c, c->x[i], bvb);
642 } else {
643
644
645 Rnd ra(1);
646 BoolVarBranch bvba;
647 BoolAction baa(*c, c->x, 0.9);
648 BoolCHB bca(*c, c->x);
649 switch (vara) {
650 case 0: bvba = BOOL_VAR_NONE(); break;
651 case 1: bvba = BOOL_VAR_NONE(); break;
652 case 2: bvba = BOOL_VAR_RND(ra); break;
653 case 3: bvba = BOOL_VAR_MERIT_MIN(&bool_merit); break;
654 case 4: bvba = BOOL_VAR_MERIT_MAX(&bool_merit); break;
655 case 5: bvba = BOOL_VAR_DEGREE_MIN(); break;
656 case 6: bvba = BOOL_VAR_DEGREE_MAX(); break;
657 case 7: bvba = BOOL_VAR_AFC_MIN(0.5); break;
658 case 8: bvba = BOOL_VAR_AFC_MAX(0.5); break;
659 case 9: bvba = BOOL_VAR_ACTION_MIN(baa); break;
660 case 10: bvba = BOOL_VAR_ACTION_MAX(baa); break;
661 case 11: bvba = BOOL_VAR_CHB_MIN(bca); break;
662 case 12: bvba = BOOL_VAR_CHB_MAX(bca); break;
663 }
664
665 Rnd rb(2);
666 BoolVarBranch bvbb;
667 BoolAction bab(*c, c->x, 0.9, true, true, &bool_merit);
668 BoolCHB bcb(*c, c->x, &bool_merit);
669 switch (varb) {
670 case 0: bvbb = BOOL_VAR_NONE(); break;
671 case 1: bvbb = BOOL_VAR_NONE(); break;
672 case 2: bvbb = BOOL_VAR_RND(rb); break;
673 case 3: bvbb = BOOL_VAR_MERIT_MIN(&bool_merit,&tbl); break;
674 case 4: bvbb = BOOL_VAR_MERIT_MAX(&bool_merit,&tbl); break;
675 case 5: bvbb = BOOL_VAR_DEGREE_MIN(&tbl); break;
676 case 6: bvbb = BOOL_VAR_DEGREE_MAX(&tbl); break;
677 case 7: bvbb = BOOL_VAR_AFC_MIN(0.5,&tbl); break;
678 case 8: bvbb = BOOL_VAR_AFC_MAX(0.5,&tbl); break;
679 case 9: bvbb = BOOL_VAR_ACTION_MIN(bab,&tbl); break;
680 case 10: bvbb = BOOL_VAR_ACTION_MAX(bab,&tbl); break;
681 case 11: bvbb = BOOL_VAR_CHB_MIN(bcb,&tbl); break;
682 case 12: bvbb = BOOL_VAR_CHB_MAX(bcb,&tbl); break;
683 }
684
685 switch (_rand(9U)) {
686 case 0U:
687 branch(*c, c->x, bvba, bvb); break;
688 case 1U:
689 branch(*c, c->x, bvbb, bvb); break;
690 case 2U:
691 branch(*c, c->x, tiebreak(bvba,bvbb), bvb); break;
692 case 3U:
693 branch(*c, c->x, tiebreak(bvbb,bvba), bvb); break;
694 case 4U:
695 branch(*c, c->x, tiebreak(bvba,bvba,bvbb), bvb); break;
696 case 5U:
697 branch(*c, c->x, tiebreak(bvba,bvbb,bvbb), bvb); break;
698 case 6U:
699 branch(*c, c->x, tiebreak(bvbb,bvba,bvba), bvb); break;
700 case 7U:
701 branch(*c, c->x, tiebreak(bvba,bvba,bvbb,bvba), bvb); break;
702 case 8U:
703 branch(*c, c->x, tiebreak(bvbb,bvba,bvbb,bvba), bvb); break;
704 }
705
706 }
708 results[solutions(c, o, _rand)].push_back
709 (RunInfo(int_var_branch_name[vara],
710 int_var_branch_name[varb],
711 int_val_branch_name[val],
712 o));
713 }
714 }
715 }
716 if (results.size() > 1)
717 goto failed;
718 delete root;
719 return true;
720 failed:
721 std::cout << "FAILURE" << std::endl;
722 for (map<int, vector<RunInfo> >::iterator it = results.begin();
723 it != results.end(); ++it) {
724 std::cout << "Number of solutions: " << it->first << std::endl;
725 for (unsigned int i = 0; i < it->second.size(); ++i)
726 std::cout << it->second[i] << " ";
727 std::cout << std::endl;
728 }
729
730 delete root;
731 return results.size() == 1;
732 }
733
734#ifdef GECODE_HAS_SET_VARS
735 SetTest::SetTest(TestTags tags, const std::string& s, int a,
736 const Gecode::IntSet& d)
737 : Base("Set::Branch::"+s,tags), arity(a), dom(d) {
738 }
739
740 SetTest::SetTest(const std::string& s, int a, const Gecode::IntSet& d)
741 : SetTest(TestTags::standard(),s,a,d) {
742 }
743
744 bool
746 using std::map;
747 using std::vector;
748 using std::string;
749 using std::ostream;
750 using namespace Gecode;
751
752 // Results of tests run
753 map<int, vector<RunInfo> > results;
754 // Set up root space
755 SetTestSpace* root = new SetTestSpace(arity,dom);
756 post(*root, root->x);
757 root->status();
758 results.clear();
759
760 for (int vara = 0; vara<n_set_var_branch; vara++) {
761 for (int varb = 1; varb<n_set_var_branch; varb++) {
762 for (int val = 0; val<n_set_val_branch; val++) {
763 Rnd r(1);
764
765 SetValBranch svb;
766 switch (val) {
767 case 0: svb = SET_VAL_MIN_INC(); break;
768 case 1: svb = SET_VAL_MIN_EXC(); break;
769 case 2: svb = SET_VAL_MED_INC(); break;
770 case 3: svb = SET_VAL_MED_EXC(); break;
771 case 4: svb = SET_VAL_MAX_INC(); break;
772 case 5: svb = SET_VAL_MAX_EXC(); break;
773 case 6: svb = SET_VAL_RND_INC(r); break;
774 case 7: svb = SET_VAL_RND_EXC(r); break;
775 case 8: svb = SET_VAL(&set_val); break;
776 }
777
778 SetTestSpace* c = static_cast<SetTestSpace*>(root->clone());
779
780 if (vara == 0) {
781 for (int i=0; i<c->x.size(); i++)
782 branch(*c, c->x[i], svb);
783 } else {
784 Rnd ra(1);
785 SetVarBranch svba;
786 SetAction saa(*c, c->x, 0.9);
787 SetCHB sca(*c, c->x);
788 switch (vara) {
789 case 0: break;
790 case 1: svba = SET_VAR_NONE(); break;
791 case 2: svba = SET_VAR_RND(ra); break;
792 case 3: svba = SET_VAR_MERIT_MIN(&set_merit); break;
793 case 4: svba = SET_VAR_MERIT_MAX(&set_merit); break;
794 case 5: svba = SET_VAR_DEGREE_MIN(); break;
795 case 6: svba = SET_VAR_DEGREE_MAX(); break;
796 case 7: svba = SET_VAR_AFC_MIN(0.5); break;
797 case 8: svba = SET_VAR_AFC_MAX(0.5); break;
798 case 9: svba = SET_VAR_ACTION_MIN(saa); break;
799 case 10: svba = SET_VAR_ACTION_MAX(saa); break;
800 case 11: svba = SET_VAR_CHB_MIN(sca); break;
801 case 12: svba = SET_VAR_CHB_MAX(sca); break;
802 case 13: svba = SET_VAR_MIN_MIN(); break;
803 case 14: svba = SET_VAR_MIN_MAX(); break;
804 case 15: svba = SET_VAR_MAX_MIN(); break;
805 case 16: svba = SET_VAR_MAX_MAX(); break;
806 case 17: svba = SET_VAR_SIZE_MIN(); break;
807 case 18: svba = SET_VAR_SIZE_MAX(); break;
808 case 19: svba = SET_VAR_DEGREE_SIZE_MIN(); break;
809 case 20: svba = SET_VAR_DEGREE_SIZE_MAX(); break;
810 case 21: svba = SET_VAR_AFC_SIZE_MIN(); break;
811 case 22: svba = SET_VAR_AFC_SIZE_MAX(); break;
812 case 23: svba = SET_VAR_ACTION_SIZE_MIN(saa); break;
813 case 24: svba = SET_VAR_ACTION_SIZE_MAX(saa); break;
814 case 25: svba = SET_VAR_CHB_SIZE_MIN(sca); break;
815 case 26: svba = SET_VAR_CHB_SIZE_MAX(sca); break;
816 }
817
818 Rnd rb(2);
819 SetVarBranch svbb;
820 SetAction sab(*c, c->x, 0.9, true, true, &set_merit);
821 SetCHB scb(*c, c->x, &set_merit);
822 switch (varb) {
823 case 0: break;
824 case 1: svbb = SET_VAR_NONE(); break;
825 case 2: svbb = SET_VAR_RND(rb); break;
826 case 3: svbb = SET_VAR_MERIT_MIN(&set_merit,&tbl); break;
827 case 4: svbb = SET_VAR_MERIT_MAX(&set_merit,&tbl); break;
828 case 5: svbb = SET_VAR_DEGREE_MIN(&tbl); break;
829 case 6: svbb = SET_VAR_DEGREE_MAX(&tbl); break;
830 case 7: svbb = SET_VAR_AFC_MIN(0.5,&tbl); break;
831 case 8: svbb = SET_VAR_AFC_MAX(0.5,&tbl); break;
832 case 9: svbb = SET_VAR_ACTION_MIN(sab,&tbl); break;
833 case 10: svbb = SET_VAR_ACTION_MAX(sab,&tbl); break;
834 case 11: svbb = SET_VAR_CHB_MIN(scb,&tbl); break;
835 case 12: svbb = SET_VAR_CHB_MAX(scb,&tbl); break;
836 case 13: svbb = SET_VAR_MIN_MIN(&tbl); break;
837 case 14: svbb = SET_VAR_MIN_MAX(&tbl); break;
838 case 15: svbb = SET_VAR_MAX_MIN(&tbl); break;
839 case 16: svbb = SET_VAR_MAX_MAX(&tbl); break;
840 case 17: svbb = SET_VAR_SIZE_MIN(&tbl); break;
841 case 18: svbb = SET_VAR_SIZE_MAX(&tbl); break;
842 case 19: svbb = SET_VAR_DEGREE_SIZE_MIN(&tbl); break;
843 case 20: svbb = SET_VAR_DEGREE_SIZE_MAX(&tbl); break;
844 case 21: svbb = SET_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
845 case 22: svbb = SET_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
846 case 23: svbb = SET_VAR_ACTION_SIZE_MIN(sab,&tbl); break;
847 case 24: svbb = SET_VAR_ACTION_SIZE_MAX(sab,&tbl); break;
848 case 25: svbb = SET_VAR_CHB_SIZE_MIN(scb,&tbl); break;
849 case 26: svbb = SET_VAR_CHB_SIZE_MAX(scb,&tbl); break;
850 }
851
852 switch (_rand(9U)) {
853 case 0U:
854 branch(*c, c->x, svba, svb); break;
855 case 1U:
856 branch(*c, c->x, svbb, svb); break;
857 case 2U:
858 branch(*c, c->x, tiebreak(svba,svbb), svb); break;
859 case 3U:
860 branch(*c, c->x, tiebreak(svbb,svba), svb); break;
861 case 4U:
862 branch(*c, c->x, tiebreak(svba,svba,svbb), svb); break;
863 case 5U:
864 branch(*c, c->x, tiebreak(svba,svbb,svbb), svb); break;
865 case 6U:
866 branch(*c, c->x, tiebreak(svbb,svba,svba), svb); break;
867 case 7U:
868 branch(*c, c->x, tiebreak(svba,svba,svbb,svba), svb); break;
869 case 8U:
870 branch(*c, c->x, tiebreak(svbb,svba,svbb,svba), svb); break;
871 }
872
873 }
875 results[solutions(c, o, _rand)].push_back
876 (RunInfo(set_var_branch_name[vara],
877 set_var_branch_name[varb],
878 set_val_branch_name[val],
879 o));
880 }
881 }
882 }
883 if (results.size() > 1)
884 goto failed;
885 delete root;
886 return true;
887 failed:
888 std::cout << "FAILURE" << std::endl;
889 for (map<int, vector<RunInfo> >::iterator it = results.begin();
890 it != results.end(); ++it) {
891 std::cout << "Number of solutions: " << it->first << std::endl;
892 for (unsigned int i = 0; i < it->second.size(); ++i)
893 std::cout << it->second[i] << " ";
894 std::cout << std::endl;
895 }
896
897 delete root;
898 return results.size() == 1;
899 }
900#endif
901
902#ifdef GECODE_HAS_FLOAT_VARS
903 FloatTest::FloatTest(const std::string& s, int a, const Gecode::FloatVal& d, int nbs)
904 : Base("Float::Branch::"+s), arity(a), dom(d), nbSols(nbs) {
905 }
906
907 bool
909 using std::map;
910 using std::vector;
911 using std::string;
912 using std::ostream;
913 using namespace Gecode;
914
915 // Results of tests run
916 map<int, vector<RunInfo> > results;
917 // Set up root space
919 post(*root, root->x);
920 root->status();
921 results.clear();
922
923 for (int vara = 0; vara<n_float_var_branch; vara++) {
924 for (int varb = 1; varb<n_float_var_branch; varb++) {
925 for (int val = 0; val<n_float_val_branch; val++) {
926 Rnd r(1);
927
928 FloatValBranch fvb;
929 switch (val) {
930 case 0: fvb = FLOAT_VAL_SPLIT_MIN(); break;
931 case 1: fvb = FLOAT_VAL_SPLIT_MAX(); break;
932 case 2: fvb = FLOAT_VAL_SPLIT_RND(r); break;
933 case 3: fvb = FLOAT_VAL(&float_val); break;
934 }
935
936 FloatTestSpace* c = static_cast<FloatTestSpace*>(root->clone());
937 if (vara == 0) {
938 for (int i=0; i<c->x.size(); i++)
939 branch(*c, c->x[i], fvb);
940 } else {
941 Rnd ra(1);
942 FloatVarBranch fvba;
943 FloatAction faa(*c, c->x, 0.9);
944 FloatCHB fca(*c, c->x);
945 switch (vara) {
946 case 0: break;
947 case 1: fvba = FLOAT_VAR_NONE(); break;
948 case 2: fvba = FLOAT_VAR_RND(ra); break;
949 case 3: fvba = FLOAT_VAR_MERIT_MIN(&float_merit); break;
950 case 4: fvba = FLOAT_VAR_MERIT_MAX(&float_merit); break;
951 case 5: fvba = FLOAT_VAR_DEGREE_MIN(); break;
952 case 6: fvba = FLOAT_VAR_DEGREE_MAX(); break;
953 case 7: fvba = FLOAT_VAR_AFC_MIN(0.5); break;
954 case 8: fvba = FLOAT_VAR_AFC_MAX(0.5); break;
955 case 9: fvba = FLOAT_VAR_ACTION_MIN(faa); break;
956 case 10: fvba = FLOAT_VAR_ACTION_MAX(faa); break;
957 case 11: fvba = FLOAT_VAR_CHB_MIN(fca); break;
958 case 12: fvba = FLOAT_VAR_CHB_MAX(fca); break;
959 case 13: fvba = FLOAT_VAR_MIN_MIN(); break;
960 case 14: fvba = FLOAT_VAR_MIN_MAX(); break;
961 case 15: fvba = FLOAT_VAR_MAX_MIN(); break;
962 case 16: fvba = FLOAT_VAR_MAX_MAX(); break;
963 case 17: fvba = FLOAT_VAR_SIZE_MIN(); break;
964 case 18: fvba = FLOAT_VAR_SIZE_MAX(); break;
965 case 19: fvba = FLOAT_VAR_DEGREE_SIZE_MIN(); break;
966 case 20: fvba = FLOAT_VAR_DEGREE_SIZE_MAX(); break;
967 case 21: fvba = FLOAT_VAR_AFC_SIZE_MIN(); break;
968 case 22: fvba = FLOAT_VAR_AFC_SIZE_MAX(); break;
969 case 23: fvba = FLOAT_VAR_ACTION_SIZE_MIN(faa); break;
970 case 24: fvba = FLOAT_VAR_ACTION_SIZE_MAX(faa); break;
971 case 25: fvba = FLOAT_VAR_CHB_SIZE_MIN(fca); break;
972 case 26: fvba = FLOAT_VAR_CHB_SIZE_MAX(fca); break;
973 }
974
975 Rnd rb(2);
976 FloatVarBranch fvbb;
977 FloatAction fab(*c, c->x, 0.9, true, true, &float_merit);
978 FloatCHB fcb(*c, c->x, &float_merit);
979 switch (varb) {
980 case 0: break;
981 case 1: fvbb = FLOAT_VAR_NONE(); break;
982 case 2: fvbb = FLOAT_VAR_RND(rb); break;
983 case 3: fvbb = FLOAT_VAR_MERIT_MIN(&float_merit,&tbl); break;
984 case 4: fvbb = FLOAT_VAR_MERIT_MAX(&float_merit,&tbl); break;
985 case 5: fvbb = FLOAT_VAR_DEGREE_MIN(&tbl); break;
986 case 6: fvbb = FLOAT_VAR_DEGREE_MAX(&tbl); break;
987 case 7: fvbb = FLOAT_VAR_AFC_MIN(0.5,&tbl); break;
988 case 8: fvbb = FLOAT_VAR_AFC_MAX(0.5,&tbl); break;
989 case 9: fvbb = FLOAT_VAR_ACTION_MIN(fab,&tbl); break;
990 case 10: fvbb = FLOAT_VAR_ACTION_MAX(fab,&tbl); break;
991 case 11: fvbb = FLOAT_VAR_CHB_MIN(fcb,&tbl); break;
992 case 12: fvbb = FLOAT_VAR_CHB_MAX(fcb,&tbl); break;
993 case 13: fvbb = FLOAT_VAR_MIN_MIN(&tbl); break;
994 case 14: fvbb = FLOAT_VAR_MIN_MAX(&tbl); break;
995 case 15: fvbb = FLOAT_VAR_MAX_MIN(&tbl); break;
996 case 16: fvbb = FLOAT_VAR_MAX_MAX(&tbl); break;
997 case 17: fvbb = FLOAT_VAR_SIZE_MIN(&tbl); break;
998 case 18: fvbb = FLOAT_VAR_SIZE_MAX(&tbl); break;
999 case 19: fvbb = FLOAT_VAR_DEGREE_SIZE_MIN(&tbl); break;
1000 case 20: fvbb = FLOAT_VAR_DEGREE_SIZE_MAX(&tbl); break;
1001 case 21: fvbb = FLOAT_VAR_AFC_SIZE_MIN(1.0,&tbl); break;
1002 case 22: fvbb = FLOAT_VAR_AFC_SIZE_MAX(1.0,&tbl); break;
1003 case 23: fvbb = FLOAT_VAR_ACTION_SIZE_MIN(fab,&tbl); break;
1004 case 24: fvbb = FLOAT_VAR_ACTION_SIZE_MAX(fab,&tbl); break;
1005 case 25: fvbb = FLOAT_VAR_CHB_SIZE_MIN(fcb,&tbl); break;
1006 case 26: fvbb = FLOAT_VAR_CHB_SIZE_MAX(fcb,&tbl); break;
1007 }
1008
1009 switch (_rand(9U)) {
1010 case 0U:
1011 branch(*c, c->x, fvba, fvb); break;
1012 case 1U:
1013 branch(*c, c->x, fvbb, fvb); break;
1014 case 2U:
1015 branch(*c, c->x, tiebreak(fvba,fvbb), fvb); break;
1016 case 3U:
1017 branch(*c, c->x, tiebreak(fvbb,fvba), fvb); break;
1018 case 4U:
1019 branch(*c, c->x, tiebreak(fvba,fvba,fvbb), fvb); break;
1020 case 5U:
1021 branch(*c, c->x, tiebreak(fvba,fvbb,fvbb), fvb); break;
1022 case 6U:
1023 branch(*c, c->x, tiebreak(fvbb,fvba,fvba), fvb); break;
1024 case 7U:
1025 branch(*c, c->x, tiebreak(fvba,fvba,fvbb,fvba), fvb); break;
1026 case 8U:
1027 branch(*c, c->x, tiebreak(fvbb,fvba,fvbb,fvba), fvb); break;
1028 }
1029
1030 }
1032 results[solutions(c, o, _rand, nbSols)].push_back
1033 (RunInfo(float_var_branch_name[vara],
1034 float_var_branch_name[varb],
1035 float_val_branch_name[val],
1036 o));
1037 }
1038 }
1039 }
1040 if (results.size() > 1)
1041 goto failed;
1042 delete root;
1043 return true;
1044 failed:
1045 std::cout << "FAILURE" << std::endl;
1046 for (map<int, vector<RunInfo> >::iterator it = results.begin();
1047 it != results.end(); ++it) {
1048 std::cout << "Number of solutions: " << it->first << std::endl;
1049 for (unsigned int i = 0; i < it->second.size(); ++i)
1050 std::cout << it->second[i] << " ";
1051 std::cout << std::endl;
1052 }
1053
1054 delete root;
1055 return results.size() == 1;
1056 }
1057#endif
1058
1059}}
1060
1061// STATISTICS: test-branch
int size(void) const
Return size of array (number of elements).
Definition array.hpp:1606
Recording actions for Boolean variables.
Definition int.hh:5516
Recording CHB for Boolean variables.
Definition int.hh:5617
Which values to select for branching first.
Definition int.hh:6004
Boolean variable array.
Definition int.hh:840
Which Boolean variable to select for branching.
Definition int.hh:5771
Boolean integer variables.
Definition int.hh:534
Depth-first search engine.
Definition search.hh:1211
Recording actions for float variables.
Definition float.hh:1557
Recording CHB for float variables.
Definition float.hh:1615
Value description class for branching.
Definition float.hh:1464
bool l
Whether to try the lower or upper half first.
Definition float.hh:1469
FloatNum n
The middle value for branching.
Definition float.hh:1467
Which values to select for branching first.
Definition float.hh:1828
Float value type.
Definition float.hh:329
Float variable array.
Definition float.hh:1030
Which variable to select for branching.
Definition float.hh:1676
Float variables.
Definition float.hh:865
Recording actions for integer variables.
Definition int.hh:5465
Passing integer arguments.
Definition int.hh:653
Recording CHB for integer variables.
Definition int.hh:5573
Integer sets.
Definition int.hh:179
Which values to select for branching first.
Definition int.hh:5969
Integer variable array.
Definition int.hh:792
Which integer variable to select for branching.
Definition int.hh:5685
Integer variables.
Definition int.hh:390
Random number generator.
Definition rnd.hpp:42
virtual T * next(void)
Return next solution (nullptr, if none exists or search has been stopped).
Definition base.hpp:46
Search engine options
Definition search.hh:848
unsigned int c_d
Create a clone after every c_d commits (commit distance).
Definition search.hh:863
unsigned int a_d
Create a clone during recomputation if distance is greater than a_d (adaptive distance).
Definition search.hh:865
Recording actions for set variables.
Definition set.hh:1190
Recording CHB for set variables.
Definition set.hh:1248
Which values to select for branching first.
Definition set.hh:1460
Set variable array
Definition set.hh:575
Which variable to select for branching.
Definition set.hh:1309
Iterator for the unknown ranges of a set variable.
Definition set.hh:337
Set variables
Definition set.hh:127
Computation spaces.
Definition core.hpp:1787
Gecode::Support::RandomGenerator _rand
Random number generator.
Definition test.hh:238
Base(std::string s)
Create and register a standard test with name s.
Definition test.cpp:125
TestTags tags(void) const
Return tags for test.
Definition test.hpp:95
Space for executing Boolean tests.
Definition branch.cpp:91
BoolTestSpace(BoolTestSpace &s)
Constructor for cloning s.
Definition branch.cpp:99
BoolTestSpace(int n)
Initialize test space.
Definition branch.cpp:96
Gecode::BoolVarArray x
Variables to be tested.
Definition branch.cpp:94
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition branch.cpp:104
BoolTest(const std::string &s, int a)
Construct and register test.
Definition branch.cpp:604
int arity
Number of variables.
Definition branch.hh:88
virtual bool run(void)
Perform test.
Definition branch.cpp:609
virtual void post(Gecode::Space &home, Gecode::BoolVarArray &x)=0
Post propagators on variables x.
Space for executing Float tests.
Definition branch.cpp:132
const int n_float_var_branch
Number of float variable selections.
Definition branch.cpp:360
Gecode::FloatNumBranch float_val(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch value function.
Definition branch.cpp:377
const char * float_val_branch_name[]
Names for float value selections.
Definition branch.cpp:367
FloatTestSpace(FloatTestSpace &s)
Constructor for cloning s.
Definition branch.cpp:140
double float_merit(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch merit function.
Definition branch.cpp:363
Gecode::FloatVarArray x
Variables to be tested.
Definition branch.cpp:135
const char * float_var_branch_name[]
Names for float variable selections.
Definition branch.cpp:330
const int n_float_val_branch
Number of float value selections.
Definition branch.cpp:374
FloatTestSpace(int n, Gecode::FloatVal &d)
Initialize test space.
Definition branch.cpp:137
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition branch.cpp:145
Gecode::FloatVal dom
Domain of variables.
Definition branch.hh:132
int arity
Number of variables.
Definition branch.hh:130
int nbSols
Maximum number of solutions searched during solving.
Definition branch.hh:134
FloatTest(const std::string &s, int a, const Gecode::FloatVal &d, int nbs)
Construct and register test.
Definition branch.cpp:903
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)=0
Post propagators on variables x.
virtual bool run(void)
Perform test.
Definition branch.cpp:908
Space for executing integer tests.
Definition branch.cpp:66
double bool_merit(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch merit function.
Definition branch.cpp:217
IntTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
Definition branch.cpp:75
const int n_bool_var_branch
Number of integer variable selections.
Definition branch.cpp:210
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition branch.cpp:85
const int n_int_var_branch
Number of integer variable selections.
Definition branch.cpp:191
Gecode::IntVarBranch varb
Definition branch.cpp:71
Gecode::IntValBranch val
Varlue selection criterion.
Definition branch.cpp:73
const char * bool_var_branch_name[]
Names for Boolean variable selections.
Definition branch.cpp:194
const int n_bool_val_branch
Number of Boolean value selections.
Definition branch.cpp:245
IntTestSpace(IntTestSpace &s)
Constructor for cloning s.
Definition branch.cpp:80
Gecode::IntVarBranch vara
Variable selection criteria.
Definition branch.cpp:71
const char * int_var_branch_name[]
Names for integer variable selections.
Definition branch.cpp:157
int int_val(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch value function.
Definition branch.cpp:248
const char * bool_val_branch_name[]
Names for Boolean value selections.
Definition branch.cpp:238
const int n_int_val_branch
Number of integer value selections.
Definition branch.cpp:235
Gecode::IntVarArray x
Variables to be tested.
Definition branch.cpp:69
double int_merit(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch merit function.
Definition branch.cpp:213
int bool_val(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch value function.
Definition branch.cpp:252
const char * int_val_branch_name[]
Names for integer value selections.
Definition branch.cpp:221
IntTest(const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test.
Definition branch.cpp:430
int arity
Number of variables.
Definition branch.hh:69
virtual bool run(void)
Perform test.
Definition branch.cpp:435
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)=0
Post propagators on variables x.
Gecode::IntSet dom
Domain of variables.
Definition branch.hh:71
Information about one test-run.
Definition branch.cpp:386
void print(std::ostream &o) const
Definition branch.cpp:394
unsigned int c_d
Definition branch.cpp:389
unsigned int a_d
Definition branch.cpp:389
RunInfo(const std::string &vara, const std::string &varb, const std::string &valname, const Gecode::Search::Options &o)
Definition branch.cpp:390
Space for executing Set tests.
Definition branch.cpp:111
const int n_set_var_branch
Number of set variable selections.
Definition branch.cpp:294
const char * set_var_branch_name[]
Names for set variable selections.
Definition branch.cpp:264
double set_merit(const Gecode::Space &, Gecode::SetVar, int)
Test function for branch merit function.
Definition branch.cpp:297
const int n_set_val_branch
Number of set value selections.
Definition branch.cpp:313
Gecode::SetVarArray x
Variables to be tested.
Definition branch.cpp:114
const char * set_val_branch_name[]
Names for set value selections.
Definition branch.cpp:301
int set_val(const Gecode::Space &, Gecode::SetVar x, int)
Test function for branch value function.
Definition branch.cpp:316
virtual Gecode::Space * copy(void)
Copy space during cloning.
Definition branch.cpp:124
SetTestSpace(SetTestSpace &s)
Constructor for cloning s.
Definition branch.cpp:119
SetTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
Definition branch.cpp:116
virtual void post(Gecode::Space &home, Gecode::SetVarArray &x)=0
Post propagators on variables x.
int arity
Number of variables.
Definition branch.hh:106
virtual bool run(void)
Perform test.
Definition branch.cpp:745
Gecode::IntSet dom
Domain of variables.
Definition branch.hh:108
SetTest(TestTags tags, const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test with explicitly assigned tags.
Definition branch.cpp:735
Set of test tags.
Definition test.hh:105
LinearCongruentialGenerator< 2147483647, 48271, 44488, 3399 > RandomGenerator
Default values for linear congruential generator.
Definition random.hpp:183
void branch(Home home, const FloatVarArgs &x, FloatVarBranch vars, FloatValBranch vals, FloatBranchFilter bf=nullptr, FloatVarValPrint vvp=nullptr)
Branch over x with variable selection vars and value selection vals.
Definition branch.cpp:39
Space(void)
Default constructor.
Definition core.cpp:121
T * bab(T *s, const Search::Options &o=Search::Options::def)
Perform depth-first branch-and-bound search for subclass T of space s and options o.
Definition bab.hpp:77
Space * clone(void) const
Clone space.
Definition core.hpp:3384
SpaceStatus status(StatusStatistics &stat)
Query space status.
Definition core.cpp:281
Gecode toplevel namespace
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree divided by domain size.
Definition var.hpp:222
SetVarBranch SET_VAR_MERIT_MAX(SetBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with highest merit according to branch merit function bm.
Definition var.hpp:111
FloatVarBranch FLOAT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree divided by domain size.
Definition var.hpp:217
SetValBranch SET_VAL_MED_INC(void)
Include median element (rounding downwards).
Definition val.hpp:65
FloatVarBranch FLOAT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking).
Definition var.hpp:112
FloatValBranch FLOAT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition val.hpp:60
BoolVarBranch BOOL_VAR_CHB_MIN(BoolCHB c, BranchTbl tbl=nullptr)
Select variable with lowest CHB Q-score.
Definition var.hpp:434
SetVarBranch SET_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest action divided by domain size with decay factor d.
Definition var.hpp:246
SetVarBranch SET_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest CHB Q-score divided by domain size.
Definition var.hpp:266
SetVarBranch SET_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest action divided by domain size with decay factor d.
Definition var.hpp:256
IntValBranch INT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition val.hpp:75
FloatVarBranch FLOAT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count with decay factor d.
Definition var.hpp:127
IntValBranch INT_VAL_RANGE_MIN(void)
Select the smallest range of the variable domain if it has several ranges, otherwise select values no...
Definition val.hpp:85
IntValBranch INT_VAL_RANGE_MAX(void)
Select the largest range of the variable domain if it has several ranges, otherwise select values gre...
Definition val.hpp:90
BoolValBranch BOOL_VAL(BoolBranchVal v, BoolBranchCommit c=nullptr)
Select value as defined by the value function v and commit function c Uses a commit function as defau...
Definition val.hpp:145
FloatVarBranch FLOAT_VAR_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest domain size.
Definition var.hpp:212
IntValBranch INT_VALUES_MAX(void)
Try all values starting from largest.
Definition val.hpp:105
IntVarBranch INT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:236
IntVarBranch INT_VAR_CHB_SIZE_MIN(IntCHB c, BranchTbl tbl=nullptr)
Select variable with smallest CHB Q-score divided by domain size.
Definition var.hpp:266
FloatVarBranch FLOAT_VAR_MAX_MAX(BranchTbl tbl=nullptr)
Select variable with largest max.
Definition var.hpp:202
SetVarBranch SET_VAR_NONE(void)
Select first unassigned variable.
Definition var.hpp:96
IntVarBranch INT_VAR_DEGREE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree.
Definition var.hpp:121
SetValBranch SET_VAL_RND_INC(Rnd r)
Include random element.
Definition val.hpp:85
FloatValBranch FLOAT_VAL_SPLIT_RND(Rnd r)
Select values randomly which are not greater or not smaller than mean of largest and smallest value.
Definition val.hpp:65
IntVarBranch INT_VAR_REGRET_MIN_MIN(BranchTbl tbl=nullptr)
Select variable with smallest min-regret.
Definition var.hpp:286
IntVarBranch INT_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with highest action with decay factor d.
Definition var.hpp:156
SetVarBranch SET_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree divided by domain size.
Definition var.hpp:221
FloatVarBranch FLOAT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smalllest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:227
FloatVarBranch FLOAT_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score divided by domain size.
Definition var.hpp:277
IntValBranch INT_VAL_MED(void)
Select greatest value not greater than the median.
Definition val.hpp:60
IntValBranch INT_VAL(IntBranchVal v, IntBranchCommit c=nullptr)
Select value as defined by the value function v and commit function c Uses a commit function as defau...
Definition val.hpp:95
TieBreak< VarBranch > tiebreak(VarBranch a, VarBranch b)
Combine variable selection criteria a and b for tie-breaking.
Definition tiebreak.hpp:80
IntVarBranch INT_VAR_REGRET_MIN_MAX(BranchTbl tbl=nullptr)
Select variable with largest min-regret.
Definition var.hpp:291
SetValBranch SET_VAL_RND_EXC(Rnd r)
Exclude random element.
Definition val.hpp:90
IntVarBranch INT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest action divided by domain size with decay factor d.
Definition var.hpp:256
SetVarBranch SET_VAR_CHB_MIN(BranchTbl tbl=nullptr)
Select variable with lowest CHB Q-score.
Definition var.hpp:166
BoolValBranch BOOL_VAL_MIN(void)
Select smallest value.
Definition val.hpp:130
BoolVarBranch BOOL_VAR_MERIT_MIN(BoolBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with least merit according to branch merit function bm.
Definition var.hpp:374
SetVarBranch SET_VAR_MIN_MAX(BranchTbl tbl=nullptr)
Select variable with largest minimum unknown element.
Definition var.hpp:191
SetVarBranch SET_VAR_CHB_MAX(BranchTbl tbl=nullptr)
Select variable with highest CHB Q-score.
Definition var.hpp:176
IntVarBranch INT_VAR_NONE(void)
Select first unassigned variable.
Definition var.hpp:96
IntVarBranch INT_VAR_CHB_MIN(IntCHB c, BranchTbl tbl=nullptr)
Select variable with lowest CHB Q-score.
Definition var.hpp:166
BoolVarBranch BOOL_VAR_NONE(void)
Select first unassigned variable.
Definition var.hpp:364
IntVarBranch INT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count with decay factor d.
Definition var.hpp:136
IntVarBranch INT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count with decay factor d.
Definition var.hpp:126
IntVarBranch INT_VAR_REGRET_MAX_MAX(BranchTbl tbl=nullptr)
Select variable with largest max-regret.
Definition var.hpp:301
SetValBranch SET_VAL(SetBranchVal v, SetBranchCommit c=nullptr)
Select value as defined by the value function v and commit function c.
Definition val.hpp:95
IntValBranch INT_VALUES_MIN(void)
Try all values starting from smallest.
Definition val.hpp:100
SetVarBranch SET_VAR_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest unknown set.
Definition var.hpp:206
SetVarBranch SET_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking).
Definition var.hpp:101
FloatVarBranch FLOAT_VAR_CHB_MIN(BranchTbl tbl=nullptr)
Select variable with lowest CHB Q-score.
Definition var.hpp:167
SetVarBranch SET_VAR_MAX_MAX(BranchTbl tbl=nullptr)
Select variable with largest maximum unknown element.
Definition var.hpp:201
IntVarBranch INT_VAR_CHB_MAX(IntCHB c, BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score.
Definition var.hpp:176
FloatVarBranch FLOAT_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest CHB Q-score divided by domain size.
Definition var.hpp:267
IntValBranch INT_VAL_MAX(void)
Select largest value.
Definition val.hpp:65
FloatVarBranch FLOAT_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with highest action with decay factor d.
Definition var.hpp:157
BoolValBranch BOOL_VAL_MAX(void)
Select largest value.
Definition val.hpp:135
BoolVarBranch BOOL_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking).
Definition var.hpp:369
BoolVarBranch BOOL_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with lowest action with decay factor d.
Definition var.hpp:414
FloatVarBranch FLOAT_VAR_CHB_MAX(BranchTbl tbl=nullptr)
Select variable with highest CHB Q-score.
Definition var.hpp:177
SetVarBranch SET_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count with decay factor d.
Definition var.hpp:136
FloatVarBranch FLOAT_VAR_MIN_MIN(BranchTbl tbl=nullptr)
Select variable with smallest min.
Definition var.hpp:187
BoolVarBranch BOOL_VAR_DEGREE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree.
Definition var.hpp:384
FloatValBranch FLOAT_VAL(FloatBranchVal v, FloatBranchCommit c=nullptr)
Definition val.hpp:70
SetVarBranch SET_VAR_MIN_MIN(BranchTbl tbl=nullptr)
Select variable with smallest minimum unknown element.
Definition var.hpp:186
FloatVarBranch FLOAT_VAR_MAX_MIN(BranchTbl tbl=nullptr)
Select variable with smallest max.
Definition var.hpp:197
FloatVarBranch FLOAT_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with lowest action with decay factor d.
Definition var.hpp:147
SetValBranch SET_VAL_MED_EXC(void)
Exclude median element (rounding downwards).
Definition val.hpp:70
SetValBranch SET_VAL_MAX_INC(void)
Include largest element.
Definition val.hpp:75
IntValBranch INT_VAL_SPLIT_MAX(void)
Select values greater than mean of smallest and largest value.
Definition val.hpp:80
IntVarBranch INT_VAR_MAX_MIN(BranchTbl tbl=nullptr)
Select variable with smallest max.
Definition var.hpp:196
IntValBranch INT_VAL_MIN(void)
Select smallest value.
Definition val.hpp:55
SetVarBranch SET_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score divided by domain size.
Definition var.hpp:276
SetVarBranch SET_VAR_DEGREE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree.
Definition var.hpp:116
SetVarBranch SET_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count with decay factor d.
Definition var.hpp:126
BoolVarBranch BOOL_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count with decay factor d.
Definition var.hpp:394
BoolVarBranch BOOL_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count with decay factor d.
Definition var.hpp:404
BoolVarBranch BOOL_VAR_CHB_MAX(BoolCHB c, BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score.
Definition var.hpp:444
SetVarBranch SET_VAR_MAX_MIN(BranchTbl tbl=nullptr)
Select variable with smallest maximum unknown element.
Definition var.hpp:196
FloatVarBranch FLOAT_VAR_NONE(void)
Select first unassigned variable.
Definition var.hpp:97
IntVarBranch INT_VAR_MAX_MAX(BranchTbl tbl=nullptr)
Select variable with largest max.
Definition var.hpp:201
SetVarBranch SET_VAR_DEGREE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree.
Definition var.hpp:121
IntVarBranch INT_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with lowest action with decay factor d.
Definition var.hpp:146
IntVarBranch INT_VAR_RND(Rnd r)
Select random variable (uniform distribution, for tie breaking).
Definition var.hpp:101
IntVarBranch INT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:226
SetValBranch SET_VAL_MIN_INC(void)
Include smallest element.
Definition val.hpp:55
FloatVarBranch FLOAT_VAR_DEGREE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree.
Definition var.hpp:122
IntVarBranch INT_VAR_DEGREE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree.
Definition var.hpp:116
SetVarBranch SET_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:226
SetValBranch SET_VAL_MAX_EXC(void)
Exclude largest element.
Definition val.hpp:80
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest action divided by domain size with decay factor d.
Definition var.hpp:257
BoolValBranch BOOL_VAL_RND(Rnd r)
Select random value.
Definition val.hpp:140
IntVarBranch INT_VAR_REGRET_MAX_MIN(BranchTbl tbl=nullptr)
Select variable with smallest max-regret.
Definition var.hpp:296
IntVarBranch INT_VAR_MERIT_MIN(IntBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with least merit according to branch merit function bm.
Definition var.hpp:106
IntVarBranch INT_VAR_CHB_SIZE_MAX(IntCHB c, BranchTbl tbl=nullptr)
Select variable with largest CHB Q-score divided by domain size.
Definition var.hpp:276
FloatVarBranch FLOAT_VAR_MIN_MAX(BranchTbl tbl=nullptr)
Select variable with largest min.
Definition var.hpp:192
SetVarBranch SET_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:236
IntVarBranch INT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree divided by domain size.
Definition var.hpp:221
SetVarBranch SET_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with lowest action with decay factor d.
Definition var.hpp:146
IntVarBranch INT_VAR_MERIT_MAX(IntBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with highest merit according to branch merit function bm.
Definition var.hpp:111
IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest domain size.
Definition var.hpp:206
BoolVarBranch BOOL_VAR_DEGREE_MAX(BranchTbl tbl=nullptr)
Select variable with largest degree.
Definition var.hpp:389
SetVarBranch SET_VAR_MERIT_MIN(SetBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with least merit according to branch merit function bm.
Definition var.hpp:106
FloatVarBranch FLOAT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count divided by domain size with decay factor d.
Definition var.hpp:237
FloatVarBranch FLOAT_VAR_MERIT_MIN(FloatBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with least merit according to branch merit function bm.
Definition var.hpp:102
IntVarBranch INT_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest action divided by domain size with decay factor d.
Definition var.hpp:246
FloatVarBranch FLOAT_VAR_DEGREE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree.
Definition var.hpp:117
BoolVarBranch BOOL_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with highest action with decay factor d.
Definition var.hpp:424
FloatValBranch FLOAT_VAL_SPLIT_MIN(void)
Select values not greater than mean of smallest and largest value.
Definition val.hpp:55
SetVarBranch SET_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree divided by domain size.
Definition var.hpp:216
FloatVarBranch FLOAT_VAR_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest domain size.
Definition var.hpp:207
IntVarBranch INT_VAR_MIN_MAX(BranchTbl tbl=nullptr)
Select variable with largest min.
Definition var.hpp:191
BoolVarBranch BOOL_VAR_MERIT_MAX(BoolBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with highest merit according to branch merit function bm.
Definition var.hpp:379
IntVarBranch INT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr)
Select variable with smallest degree divided by domain size.
Definition var.hpp:216
IntVarBranch INT_VAR_MIN_MIN(BranchTbl tbl=nullptr)
Select variable with smallest min.
Definition var.hpp:186
FloatVarBranch FLOAT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with largest accumulated failure count with decay factor d.
Definition var.hpp:137
SetValBranch SET_VAL_MIN_EXC(void)
Exclude smallest element.
Definition val.hpp:60
IntVarBranch INT_VAR_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest domain size.
Definition var.hpp:211
SetVarBranch SET_VAR_SIZE_MAX(BranchTbl tbl=nullptr)
Select variable with largest unknown set.
Definition var.hpp:211
IntValBranch INT_VAL_RND(Rnd r)
Select random value.
Definition val.hpp:70
SetVarBranch SET_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr)
Select variable with highest action with decay factor d.
Definition var.hpp:156
FloatVarBranch FLOAT_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr)
Select variable with smallest action divided by domain size with decay factor d.
Definition var.hpp:247
FloatVarBranch FLOAT_VAR_MERIT_MAX(FloatBranchMerit bm, BranchTbl tbl=nullptr)
Select variable with highest merit according to branch merit function bm.
Definition var.hpp:107
Tests for branchings.
Definition branch.cpp:58
int solutions(TestSpace *c, Gecode::Search::Options &o, Gecode::Support::RandomGenerator &rand, int maxNbSol=-1)
Find number of solutions.
Definition branch.cpp:412
double tbl(const Gecode::Space &, double w, double b)
Test function for tie-break limit function.
Definition branch.cpp:61
General test support.
Definition afc.cpp:41
Region r
Definition region.cpp:65
@ standard
Standard test suite.
Definition test.hh:100
std::ostream & operator<<(std::ostream &os, const Test::Branch::RunInfo &ri)
Definition branch.cpp:402