49#ifdef GECODE_HAS_SET_VARS
52#ifdef GECODE_HAS_FLOAT_VARS
58namespace Test {
namespace Branch {
62 return (w + (
b-w)/2.0);
97 :
x(*this,
n, 0, 1) {}
109#ifdef GECODE_HAS_SET_VARS
117 :
x(*this,
n,
Gecode::IntSet::empty, d) {}
130#ifdef GECODE_HAS_FLOAT_VARS
138 :
x(*this,
n, d.min(), d.max()) {}
157 const char* int_var_branch_name[] = {
163 "INT_VAR_DEGREE_MIN",
164 "INT_VAR_DEGREE_MAX",
167 "INT_VAR_ACTION_MIN",
168 "INT_VAR_ACTION_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"
191 const int n_int_var_branch =
192 sizeof(int_var_branch_name)/
sizeof(
const char*);
194 const char* bool_var_branch_name[] = {
198 "BOOL_VAR_MERIT_MIN",
199 "BOOL_VAR_MERIT_MAX",
200 "BOOL_VAR_DEGREE_MIN",
201 "BOOL_VAR_DEGREE_MAX",
204 "BOOL_VAR_ACTION_MIN",
205 "BOOL_VAR_ACTION_MAX",
210 const int n_bool_var_branch =
211 sizeof(bool_var_branch_name)/
sizeof(
const char*);
221 const char* int_val_branch_name[] = {
235 const int n_int_val_branch =
236 sizeof(int_val_branch_name)/
sizeof(
const char*);
238 const char* bool_val_branch_name[] = {
245 const int n_bool_val_branch =
246 sizeof(bool_val_branch_name)/
sizeof(
const char*);
257#ifdef GECODE_HAS_SET_VARS
264 const char* set_var_branch_name[] = {
270 "SET_VAR_DEGREE_MIN",
271 "SET_VAR_DEGREE_MAX",
274 "SET_VAR_ACTION_MIN",
275 "SET_VAR_ACTION_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"
294 const int n_set_var_branch =
295 sizeof(set_var_branch_name)/
sizeof(
const char*);
301 const char* set_val_branch_name[] = {
313 const int n_set_val_branch =
314 sizeof(set_val_branch_name)/
sizeof(
const char*);
323#ifdef GECODE_HAS_FLOAT_VARS
330 const char* float_var_branch_name[] = {
334 "FLOAT_VAR_MERIT_MIN",
335 "FLOAT_VAR_MERIT_MAX",
336 "FLOAT_VAR_DEGREE_MIN",
337 "FLOAT_VAR_DEGREE_MAX",
340 "FLOAT_VAR_ACTION_MIN",
341 "FLOAT_VAR_ACTION_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"
360 const int n_float_var_branch =
361 sizeof(float_var_branch_name)/
sizeof(
const char*);
364 return static_cast<double>(
x.degree());
367 const char* float_val_branch_name[] = {
368 "FLOAT_VAL_SPLIT_MIN",
369 "FLOAT_VAL_SPLIT_MAX",
370 "FLOAT_VAL_SPLIT_RND",
374 const int n_float_val_branch =
375 sizeof(float_val_branch_name)/
sizeof(
const char*);
390 RunInfo(
const std::string& vara,
const std::string& varb,
391 const std::string& valname,
395 o <<
"(" <<
var <<
", " <<
val <<
", " <<
a_d <<
", " <<
c_d <<
")";
408namespace Test {
namespace Branch {
411 template<
class TestSpace>
422 if (ex == NULL)
break;
425 if ((maxNbSol >= 0) && (maxNbSol == s))
break;
431 :
Base(
"Int::Branch::"+s), arity(
a), dom(d) {
443 map<int, vector<RunInfo> > results;
446 post(*root, root->
x);
450 for (
int i=
arity; i--; )
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++) {
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;
475 if ((vara == 0) && (val < 11)) {
476 for (
int i=0; i<c->
x.size(); i++)
477 branch(*c, c->
x[i], ivb);
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;
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;
557 branch(*c, c->
x, ivba, ivb);
break;
559 branch(*c, c->
x, ivbb, ivb);
break;
561 branch(*c, c->
x, tiebreak(ivba,ivbb), ivb);
break;
563 branch(*c, c->
x, tiebreak(ivbb,ivba), ivb);
break;
565 branch(*c, c->
x, tiebreak(ivba,ivba,ivbb), ivb);
break;
567 branch(*c, c->
x, tiebreak(ivba,ivbb,ivbb), ivb);
break;
569 branch(*c, c->
x, tiebreak(ivbb,ivba,ivba), ivb);
break;
571 branch(*c, c->
x, tiebreak(ivba,ivba,ivbb,ivba), ivb);
break;
573 branch(*c, c->
x, tiebreak(ivbb,ivba,ivbb,ivba), ivb);
break;
579 (
RunInfo(int_var_branch_name[vara],
580 int_var_branch_name[varb],
581 int_val_branch_name[val],
586 if (results.size() > 1)
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;
601 return results.size() == 1;
605 :
Base(
"Bool::Branch::"+s), arity(
a) {
617 map<int, vector<RunInfo> > results;
620 post(*root, root->
x);
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++) {
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;
640 for (
int i=0; i<c->
x.size(); i++)
641 branch(*c, c->
x[i], bvb);
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;
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;
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;
687 branch(*c, c->
x, bvba, bvb);
break;
689 branch(*c, c->
x, bvbb, bvb);
break;
691 branch(*c, c->
x, tiebreak(bvba,bvbb), bvb);
break;
693 branch(*c, c->
x, tiebreak(bvbb,bvba), bvb);
break;
695 branch(*c, c->
x, tiebreak(bvba,bvba,bvbb), bvb);
break;
697 branch(*c, c->
x, tiebreak(bvba,bvbb,bvbb), bvb);
break;
699 branch(*c, c->
x, tiebreak(bvbb,bvba,bvba), bvb);
break;
701 branch(*c, c->
x, tiebreak(bvba,bvba,bvbb,bvba), bvb);
break;
703 branch(*c, c->
x, tiebreak(bvbb,bvba,bvbb,bvba), bvb);
break;
709 (
RunInfo(int_var_branch_name[vara],
710 int_var_branch_name[varb],
711 int_val_branch_name[val],
716 if (results.size() > 1)
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;
731 return results.size() == 1;
734#ifdef GECODE_HAS_SET_VARS
736 :
Base(
"Set::Branch::"+s), arity(
a), dom(d) {
748 map<int, vector<RunInfo> > results;
751 post(*root, root->
x);
755 for (
int vara = 0; vara<n_set_var_branch; vara++) {
756 for (
int varb = 1; varb<n_set_var_branch; varb++) {
757 for (
int val = 0; val<n_set_val_branch; val++) {
762 case 0: svb = SET_VAL_MIN_INC();
break;
763 case 1: svb = SET_VAL_MIN_EXC();
break;
764 case 2: svb = SET_VAL_MED_INC();
break;
765 case 3: svb = SET_VAL_MED_EXC();
break;
766 case 4: svb = SET_VAL_MAX_INC();
break;
767 case 5: svb = SET_VAL_MAX_EXC();
break;
768 case 6: svb = SET_VAL_RND_INC(
r);
break;
769 case 7: svb = SET_VAL_RND_EXC(
r);
break;
770 case 8: svb = SET_VAL(&
set_val);
break;
776 for (
int i=0; i<c->
x.size(); i++)
777 branch(*c, c->
x[i], svb);
785 case 1: svba = SET_VAR_NONE();
break;
786 case 2: svba = SET_VAR_RND(ra);
break;
787 case 3: svba = SET_VAR_MERIT_MIN(&
set_merit);
break;
788 case 4: svba = SET_VAR_MERIT_MAX(&
set_merit);
break;
789 case 5: svba = SET_VAR_DEGREE_MIN();
break;
790 case 6: svba = SET_VAR_DEGREE_MAX();
break;
791 case 7: svba = SET_VAR_AFC_MIN(0.5);
break;
792 case 8: svba = SET_VAR_AFC_MAX(0.5);
break;
793 case 9: svba = SET_VAR_ACTION_MIN(saa);
break;
794 case 10: svba = SET_VAR_ACTION_MAX(saa);
break;
795 case 11: svba = SET_VAR_CHB_MIN(sca);
break;
796 case 12: svba = SET_VAR_CHB_MAX(sca);
break;
797 case 13: svba = SET_VAR_MIN_MIN();
break;
798 case 14: svba = SET_VAR_MIN_MAX();
break;
799 case 15: svba = SET_VAR_MAX_MIN();
break;
800 case 16: svba = SET_VAR_MAX_MAX();
break;
801 case 17: svba = SET_VAR_SIZE_MIN();
break;
802 case 18: svba = SET_VAR_SIZE_MAX();
break;
803 case 19: svba = SET_VAR_DEGREE_SIZE_MIN();
break;
804 case 20: svba = SET_VAR_DEGREE_SIZE_MAX();
break;
805 case 21: svba = SET_VAR_AFC_SIZE_MIN();
break;
806 case 22: svba = SET_VAR_AFC_SIZE_MAX();
break;
807 case 23: svba = SET_VAR_ACTION_SIZE_MIN(saa);
break;
808 case 24: svba = SET_VAR_ACTION_SIZE_MAX(saa);
break;
809 case 25: svba = SET_VAR_CHB_SIZE_MIN(sca);
break;
810 case 26: svba = SET_VAR_CHB_SIZE_MAX(sca);
break;
819 case 1: svbb = SET_VAR_NONE();
break;
820 case 2: svbb = SET_VAR_RND(rb);
break;
821 case 3: svbb = SET_VAR_MERIT_MIN(&
set_merit,&
tbl);
break;
822 case 4: svbb = SET_VAR_MERIT_MAX(&
set_merit,&
tbl);
break;
823 case 5: svbb = SET_VAR_DEGREE_MIN(&
tbl);
break;
824 case 6: svbb = SET_VAR_DEGREE_MAX(&
tbl);
break;
825 case 7: svbb = SET_VAR_AFC_MIN(0.5,&
tbl);
break;
826 case 8: svbb = SET_VAR_AFC_MAX(0.5,&
tbl);
break;
827 case 9: svbb = SET_VAR_ACTION_MIN(sab,&
tbl);
break;
828 case 10: svbb = SET_VAR_ACTION_MAX(sab,&
tbl);
break;
829 case 11: svbb = SET_VAR_CHB_MIN(scb,&
tbl);
break;
830 case 12: svbb = SET_VAR_CHB_MAX(scb,&
tbl);
break;
831 case 13: svbb = SET_VAR_MIN_MIN(&
tbl);
break;
832 case 14: svbb = SET_VAR_MIN_MAX(&
tbl);
break;
833 case 15: svbb = SET_VAR_MAX_MIN(&
tbl);
break;
834 case 16: svbb = SET_VAR_MAX_MAX(&
tbl);
break;
835 case 17: svbb = SET_VAR_SIZE_MIN(&
tbl);
break;
836 case 18: svbb = SET_VAR_SIZE_MAX(&
tbl);
break;
837 case 19: svbb = SET_VAR_DEGREE_SIZE_MIN(&
tbl);
break;
838 case 20: svbb = SET_VAR_DEGREE_SIZE_MAX(&
tbl);
break;
839 case 21: svbb = SET_VAR_AFC_SIZE_MIN(1.0,&
tbl);
break;
840 case 22: svbb = SET_VAR_AFC_SIZE_MAX(1.0,&
tbl);
break;
841 case 23: svbb = SET_VAR_ACTION_SIZE_MIN(sab,&
tbl);
break;
842 case 24: svbb = SET_VAR_ACTION_SIZE_MAX(sab,&
tbl);
break;
843 case 25: svbb = SET_VAR_CHB_SIZE_MIN(scb,&
tbl);
break;
844 case 26: svbb = SET_VAR_CHB_SIZE_MAX(scb,&
tbl);
break;
849 branch(*c, c->
x, svba, svb);
break;
851 branch(*c, c->
x, svbb, svb);
break;
853 branch(*c, c->
x, tiebreak(svba,svbb), svb);
break;
855 branch(*c, c->
x, tiebreak(svbb,svba), svb);
break;
857 branch(*c, c->
x, tiebreak(svba,svba,svbb), svb);
break;
859 branch(*c, c->
x, tiebreak(svba,svbb,svbb), svb);
break;
861 branch(*c, c->
x, tiebreak(svbb,svba,svba), svb);
break;
863 branch(*c, c->
x, tiebreak(svba,svba,svbb,svba), svb);
break;
865 branch(*c, c->
x, tiebreak(svbb,svba,svbb,svba), svb);
break;
871 (
RunInfo(set_var_branch_name[vara],
872 set_var_branch_name[varb],
873 set_val_branch_name[val],
878 if (results.size() > 1)
883 std::cout <<
"FAILURE" << std::endl;
884 for (map<
int, vector<RunInfo> >::iterator it = results.begin();
885 it != results.end(); ++it) {
886 std::cout <<
"Number of solutions: " << it->first << std::endl;
887 for (
unsigned int i = 0; i < it->second.
size(); ++i)
888 std::cout << it->second[i] <<
" ";
889 std::cout << std::endl;
893 return results.size() == 1;
897#ifdef GECODE_HAS_FLOAT_VARS
899 :
Base(
"Float::Branch::"+s), arity(
a), dom(d), nbSols(nbs) {
911 map<int, vector<RunInfo> > results;
914 post(*root, root->
x);
918 for (
int vara = 0; vara<n_float_var_branch; vara++) {
919 for (
int varb = 1; varb<n_float_var_branch; varb++) {
920 for (
int val = 0; val<n_float_val_branch; val++) {
925 case 0: fvb = FLOAT_VAL_SPLIT_MIN();
break;
926 case 1: fvb = FLOAT_VAL_SPLIT_MAX();
break;
927 case 2: fvb = FLOAT_VAL_SPLIT_RND(
r);
break;
928 case 3: fvb = FLOAT_VAL(&
float_val);
break;
933 for (
int i=0; i<c->
x.size(); i++)
934 branch(*c, c->
x[i], fvb);
942 case 1: fvba = FLOAT_VAR_NONE();
break;
943 case 2: fvba = FLOAT_VAR_RND(ra);
break;
944 case 3: fvba = FLOAT_VAR_MERIT_MIN(&
float_merit);
break;
945 case 4: fvba = FLOAT_VAR_MERIT_MAX(&
float_merit);
break;
946 case 5: fvba = FLOAT_VAR_DEGREE_MIN();
break;
947 case 6: fvba = FLOAT_VAR_DEGREE_MAX();
break;
948 case 7: fvba = FLOAT_VAR_AFC_MIN(0.5);
break;
949 case 8: fvba = FLOAT_VAR_AFC_MAX(0.5);
break;
950 case 9: fvba = FLOAT_VAR_ACTION_MIN(faa);
break;
951 case 10: fvba = FLOAT_VAR_ACTION_MAX(faa);
break;
952 case 11: fvba = FLOAT_VAR_CHB_MIN(fca);
break;
953 case 12: fvba = FLOAT_VAR_CHB_MAX(fca);
break;
954 case 13: fvba = FLOAT_VAR_MIN_MIN();
break;
955 case 14: fvba = FLOAT_VAR_MIN_MAX();
break;
956 case 15: fvba = FLOAT_VAR_MAX_MIN();
break;
957 case 16: fvba = FLOAT_VAR_MAX_MAX();
break;
958 case 17: fvba = FLOAT_VAR_SIZE_MIN();
break;
959 case 18: fvba = FLOAT_VAR_SIZE_MAX();
break;
960 case 19: fvba = FLOAT_VAR_DEGREE_SIZE_MIN();
break;
961 case 20: fvba = FLOAT_VAR_DEGREE_SIZE_MAX();
break;
962 case 21: fvba = FLOAT_VAR_AFC_SIZE_MIN();
break;
963 case 22: fvba = FLOAT_VAR_AFC_SIZE_MAX();
break;
964 case 23: fvba = FLOAT_VAR_ACTION_SIZE_MIN(faa);
break;
965 case 24: fvba = FLOAT_VAR_ACTION_SIZE_MAX(faa);
break;
966 case 25: fvba = FLOAT_VAR_CHB_SIZE_MIN(fca);
break;
967 case 26: fvba = FLOAT_VAR_CHB_SIZE_MAX(fca);
break;
976 case 1: fvbb = FLOAT_VAR_NONE();
break;
977 case 2: fvbb = FLOAT_VAR_RND(rb);
break;
980 case 5: fvbb = FLOAT_VAR_DEGREE_MIN(&
tbl);
break;
981 case 6: fvbb = FLOAT_VAR_DEGREE_MAX(&
tbl);
break;
982 case 7: fvbb = FLOAT_VAR_AFC_MIN(0.5,&
tbl);
break;
983 case 8: fvbb = FLOAT_VAR_AFC_MAX(0.5,&
tbl);
break;
984 case 9: fvbb = FLOAT_VAR_ACTION_MIN(fab,&
tbl);
break;
985 case 10: fvbb = FLOAT_VAR_ACTION_MAX(fab,&
tbl);
break;
986 case 11: fvbb = FLOAT_VAR_CHB_MIN(fcb,&
tbl);
break;
987 case 12: fvbb = FLOAT_VAR_CHB_MAX(fcb,&
tbl);
break;
988 case 13: fvbb = FLOAT_VAR_MIN_MIN(&
tbl);
break;
989 case 14: fvbb = FLOAT_VAR_MIN_MAX(&
tbl);
break;
990 case 15: fvbb = FLOAT_VAR_MAX_MIN(&
tbl);
break;
991 case 16: fvbb = FLOAT_VAR_MAX_MAX(&
tbl);
break;
992 case 17: fvbb = FLOAT_VAR_SIZE_MIN(&
tbl);
break;
993 case 18: fvbb = FLOAT_VAR_SIZE_MAX(&
tbl);
break;
994 case 19: fvbb = FLOAT_VAR_DEGREE_SIZE_MIN(&
tbl);
break;
995 case 20: fvbb = FLOAT_VAR_DEGREE_SIZE_MAX(&
tbl);
break;
996 case 21: fvbb = FLOAT_VAR_AFC_SIZE_MIN(1.0,&
tbl);
break;
997 case 22: fvbb = FLOAT_VAR_AFC_SIZE_MAX(1.0,&
tbl);
break;
998 case 23: fvbb = FLOAT_VAR_ACTION_SIZE_MIN(fab,&
tbl);
break;
999 case 24: fvbb = FLOAT_VAR_ACTION_SIZE_MAX(fab,&
tbl);
break;
1000 case 25: fvbb = FLOAT_VAR_CHB_SIZE_MIN(fcb,&
tbl);
break;
1001 case 26: fvbb = FLOAT_VAR_CHB_SIZE_MAX(fcb,&
tbl);
break;
1006 branch(*c, c->
x, fvba, fvb);
break;
1008 branch(*c, c->
x, fvbb, fvb);
break;
1010 branch(*c, c->
x, tiebreak(fvba,fvbb), fvb);
break;
1012 branch(*c, c->
x, tiebreak(fvbb,fvba), fvb);
break;
1014 branch(*c, c->
x, tiebreak(fvba,fvba,fvbb), fvb);
break;
1016 branch(*c, c->
x, tiebreak(fvba,fvbb,fvbb), fvb);
break;
1018 branch(*c, c->
x, tiebreak(fvbb,fvba,fvba), fvb);
break;
1020 branch(*c, c->
x, tiebreak(fvba,fvba,fvbb,fvba), fvb);
break;
1022 branch(*c, c->
x, tiebreak(fvbb,fvba,fvbb,fvba), fvb);
break;
1028 (
RunInfo(float_var_branch_name[vara],
1029 float_var_branch_name[varb],
1030 float_val_branch_name[val],
1035 if (results.size() > 1)
1040 std::cout <<
"FAILURE" << std::endl;
1041 for (map<
int, vector<RunInfo> >::iterator it = results.begin();
1042 it != results.end(); ++it) {
1043 std::cout <<
"Number of solutions: " << it->first << std::endl;
1044 for (
unsigned int i = 0; i < it->second.
size(); ++i)
1045 std::cout << it->second[i] <<
" ";
1046 std::cout << std::endl;
1050 return results.size() == 1;
struct Gecode::@603::NNF::@65::@66 b
For binary nodes (and, or, eqv)
int n
Number of negative literals for node type.
struct Gecode::@603::NNF::@65::@67 a
For atomic nodes.
Node * x
Pointer to corresponding Boolean expression node.
int size(void) const
Return size of array (number of elements)
Recording actions for Boolean variables.
Recording CHB for Boolean variables.
Which values to select for branching first.
Which Boolean variable to select for branching.
Boolean integer variables.
Depth-first search engine.
Recording actions for float variables.
Recording CHB for float variables.
Value description class for branching.
bool l
Whether to try the lower or upper half first.
FloatNum n
The middle value for branching.
Which values to select for branching first.
FloatValImpType x
Implementation of float value.
Which variable to select for branching.
Recording actions for integer variables.
Passing integer arguments.
Recording CHB for integer variables.
Which values to select for branching first.
Which integer variable to select for branching.
virtual T * next(void)
Return next solution (NULL, if none exists or search has been stopped)
unsigned int c_d
Create a clone after every c_d commits (commit distance)
unsigned int a_d
Create a clone during recomputation if distance is greater than a_d (adaptive distance)
Recording actions for set variables.
Recording CHB for set variables.
Which values to select for branching first.
Which variable to select for branching.
Iterator for the unknown ranges of a set variable.
void update(Space &home, VarArray< Var > &a)
Update array to be a clone of array a.
Base class for all tests to be run
static Gecode::Support::RandomGenerator rand
Random number generator.
Space for executing Boolean tests.
BoolTestSpace(BoolTestSpace &s)
Constructor for cloning s.
BoolTestSpace(int n)
Initialize test space.
Gecode::BoolVarArray x
Variables to be tested.
virtual Gecode::Space * copy(void)
Copy space during cloning.
BoolTest(const std::string &s, int a)
Construct and register test.
int arity
Number of variables.
virtual bool run(void)
Perform test.
virtual void post(Gecode::Space &home, Gecode::BoolVarArray &x)=0
Post propagators on variables x.
Space for executing Float tests.
Gecode::FloatNumBranch float_val(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch value function.
FloatTestSpace(FloatTestSpace &s)
Constructor for cloning s.
double float_merit(const Gecode::Space &, Gecode::FloatVar x, int)
Test function for branch merit function.
Gecode::FloatVarArray x
Variables to be tested.
FloatTestSpace(int n, Gecode::FloatVal &d)
Initialize test space.
virtual Gecode::Space * copy(void)
Copy space during cloning.
Gecode::FloatVal dom
Domain of variables.
int arity
Number of variables.
int nbSols
Maximum number of solutions searched during solving.
FloatTest(const std::string &s, int a, const Gecode::FloatVal &d, int nbs)
Construct and register test.
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)=0
Post propagators on variables x.
virtual bool run(void)
Perform test.
Space for executing integer tests.
double bool_merit(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch merit function.
IntTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
virtual Gecode::Space * copy(void)
Copy space during cloning.
Gecode::IntVarBranch varb
Gecode::IntValBranch val
Varlue selection criterion.
IntTestSpace(IntTestSpace &s)
Constructor for cloning s.
Gecode::IntVarBranch vara
Variable selection criteria.
int int_val(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch value function.
Gecode::IntVarArray x
Variables to be tested.
double int_merit(const Gecode::Space &, Gecode::IntVar x, int)
Test function for branch merit function.
int bool_val(const Gecode::Space &, Gecode::BoolVar x, int)
Test function for branch value function.
IntTest(const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test.
int arity
Number of variables.
virtual bool run(void)
Perform test.
virtual void post(Gecode::Space &home, Gecode::IntVarArray &x)=0
Post propagators on variables x.
Gecode::IntSet dom
Domain of variables.
Information about one test-run.
void print(std::ostream &o) const
RunInfo(const std::string &vara, const std::string &varb, const std::string &valname, const Gecode::Search::Options &o)
Space for executing Set tests.
double set_merit(const Gecode::Space &, Gecode::SetVar, int)
Test function for branch merit function.
Gecode::SetVarArray x
Variables to be tested.
int set_val(const Gecode::Space &, Gecode::SetVar x, int)
Test function for branch value function.
virtual Gecode::Space * copy(void)
Copy space during cloning.
SetTestSpace(SetTestSpace &s)
Constructor for cloning s.
SetTestSpace(int n, Gecode::IntSet &d)
Initialize test space.
virtual void post(Gecode::Space &home, Gecode::SetVarArray &x)=0
Post propagators on variables x.
int arity
Number of variables.
SetTest(const std::string &s, int a, const Gecode::IntSet &d)
Construct and register test.
virtual bool run(void)
Perform test.
Gecode::IntSet dom
Domain of variables.
Space(void)
Default constructor.
SpaceStatus status(StatusStatistics &stat=unused_status)
Query space status.
Space * clone(CloneStatistics &stat=unused_clone) const
Clone space.
Gecode toplevel namespace
double tbl(const Gecode::Space &, double w, double b)
Test function for tie-break limit function.
int solutions(TestSpace *c, Gecode::Search::Options &o, int maxNbSol=-1)
Find number of solutions.
std::ostream & operator<<(std::ostream &os, const Test::Branch::RunInfo &ri)