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 #include <gecode/int/bool.hh>
00035 #include <gecode/int/rel.hh>
00036
00037 namespace Gecode {
00038
00039 void
00040 rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, IntPropLevel) {
00041 using namespace Int;
00042 GECODE_POST;
00043 switch (irt) {
00044 case IRT_EQ:
00045 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00046 ::post(home,x0,x1)));
00047 break;
00048 case IRT_NQ:
00049 {
00050 NegBoolView n1(x1);
00051 GECODE_ES_FAIL((Bool::Eq<BoolView,NegBoolView>
00052 ::post(home,x0,n1)));
00053 }
00054 break;
00055 case IRT_GQ:
00056 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,x1,x0));
00057 break;
00058 case IRT_LQ:
00059 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,x0,x1));
00060 break;
00061 case IRT_GR:
00062 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x1,x0));
00063 break;
00064 case IRT_LE:
00065 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x0,x1));
00066 break;
00067 default:
00068 throw UnknownRelation("Int::rel");
00069 }
00070 }
00071
00072 void
00073 rel(Home home, BoolVar x0, IntRelType irt, int n, IntPropLevel) {
00074 using namespace Int;
00075 GECODE_POST;
00076 BoolView x(x0);
00077 if (n == 0) {
00078 switch (irt) {
00079 case IRT_LQ:
00080 case IRT_EQ:
00081 GECODE_ME_FAIL(x.zero(home)); break;
00082 case IRT_NQ:
00083 case IRT_GR:
00084 GECODE_ME_FAIL(x.one(home)); break;
00085 case IRT_LE:
00086 home.fail(); break;
00087 case IRT_GQ:
00088 break;
00089 default:
00090 throw UnknownRelation("Int::rel");
00091 }
00092 } else if (n == 1) {
00093 switch (irt) {
00094 case IRT_GQ:
00095 case IRT_EQ:
00096 GECODE_ME_FAIL(x.one(home)); break;
00097 case IRT_NQ:
00098 case IRT_LE:
00099 GECODE_ME_FAIL(x.zero(home)); break;
00100 case IRT_GR:
00101 home.fail(); break;
00102 case IRT_LQ:
00103 break;
00104 default:
00105 throw UnknownRelation("Int::rel");
00106 }
00107 } else {
00108 throw NotZeroOne("Int::rel");
00109 }
00110 }
00111
00112 void
00113 rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r,
00114 IntPropLevel) {
00115 using namespace Int;
00116 GECODE_POST;
00117 switch (irt) {
00118 case IRT_EQ:
00119 switch (r.mode()) {
00120 case RM_EQV:
00121 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,BoolView>
00122 ::post(home,x0,x1,r.var())));
00123 break;
00124 case RM_IMP:
00125 GECODE_ES_FAIL((Rel::ReEqBnd<BoolView,BoolView,RM_IMP>
00126 ::post(home,x0,x1,r.var())));
00127 break;
00128 case RM_PMI:
00129 GECODE_ES_FAIL((Rel::ReEqBnd<BoolView,BoolView,RM_PMI>
00130 ::post(home,x0,x1,r.var())));
00131 break;
00132 default: throw UnknownReifyMode("Int::rel");
00133 }
00134 break;
00135 case IRT_NQ:
00136 {
00137 NegBoolView nr(r.var());
00138 switch (r.mode()) {
00139 case RM_EQV:
00140 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,NegBoolView>
00141 ::post(home,x0,x1,nr)));
00142 break;
00143 case RM_IMP:
00144 GECODE_ES_FAIL((Rel::ReEqBnd<BoolView,NegBoolView,RM_PMI>
00145 ::post(home,x0,x1,nr)));
00146 break;
00147 case RM_PMI:
00148 GECODE_ES_FAIL((Rel::ReEqBnd<BoolView,NegBoolView,RM_IMP>
00149 ::post(home,x0,x1,nr)));
00150 break;
00151 default: throw UnknownReifyMode("Int::rel");
00152 }
00153 }
00154 break;
00155 case IRT_GQ:
00156 std::swap(x0,x1);
00157 case IRT_LQ:
00158 switch (r.mode()) {
00159 case RM_EQV:
00160 {
00161 NegBoolView n0(x0);
00162 GECODE_ES_FAIL((Bool::Or<NegBoolView,BoolView,BoolView>
00163 ::post(home,n0,x1,r.var())));
00164 }
00165 break;
00166 case RM_IMP:
00167 GECODE_ES_FAIL((Rel::ReLq<BoolView,BoolView,RM_IMP>
00168 ::post(home,x0,x1,r.var())));
00169 break;
00170 case RM_PMI:
00171 GECODE_ES_FAIL((Rel::ReLq<BoolView,BoolView,RM_PMI>
00172 ::post(home,x0,x1,r.var())));
00173 break;
00174 default: throw UnknownReifyMode("Int::rel");
00175 }
00176 break;
00177 case IRT_LE:
00178 std::swap(x0,x1);
00179 case IRT_GR:
00180 {
00181 NegBoolView nr(r.var());
00182 switch (r.mode()) {
00183 case RM_EQV:
00184 {
00185 NegBoolView n0(x0);
00186 GECODE_ES_FAIL((Bool::Or<NegBoolView,BoolView,NegBoolView>
00187 ::post(home,n0,x1,nr)));
00188 }
00189 break;
00190 case RM_IMP:
00191 GECODE_ES_FAIL((Rel::ReLq<BoolView,NegBoolView,RM_PMI>
00192 ::post(home,x0,x1,nr)));
00193 break;
00194 case RM_PMI:
00195 GECODE_ES_FAIL((Rel::ReLq<BoolView,NegBoolView,RM_IMP>
00196 ::post(home,x0,x1,nr)));
00197 break;
00198 default: throw UnknownReifyMode("Int::rel");
00199 }
00200 }
00201 break;
00202 default:
00203 throw UnknownRelation("Int::rel");
00204 }
00205 }
00206
00207 void
00208 rel(Home home, BoolVar x0, IntRelType irt, int n, Reify r,
00209 IntPropLevel) {
00210 using namespace Int;
00211 GECODE_POST;
00212 BoolView x(x0);
00213 BoolView y(r.var());
00214 if (n == 0) {
00215 switch (irt) {
00216 case IRT_LQ:
00217 case IRT_EQ:
00218 switch (r.mode()) {
00219 case RM_EQV:
00220 {
00221 NegBoolView ny(y);
00222 GECODE_ES_FAIL((Bool::Eq<BoolView,NegBoolView>
00223 ::post(home,x,ny)));
00224 }
00225 break;
00226 case RM_IMP:
00227 {
00228 NegBoolView nx(x); NegBoolView ny(y);
00229 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,NegBoolView>
00230 ::post(home,nx,ny)));
00231 }
00232 break;
00233 case RM_PMI:
00234 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,BoolView>
00235 ::post(home,x,y)));
00236 break;
00237 default: throw UnknownReifyMode("Int::rel");
00238 }
00239 break;
00240 case IRT_NQ:
00241 case IRT_GR:
00242 switch (r.mode()) {
00243 case RM_EQV:
00244 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00245 ::post(home,x,y)));
00246 break;
00247 case RM_IMP:
00248 {
00249 NegBoolView ny(y);
00250 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,NegBoolView>
00251 ::post(home,x,ny)));
00252 }
00253 break;
00254 case RM_PMI:
00255 {
00256 NegBoolView nx(x);
00257 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,BoolView>
00258 ::post(home,nx,y)));
00259 }
00260 break;
00261 default: throw UnknownReifyMode("Int::rel");
00262 }
00263 break;
00264 case IRT_LE:
00265 switch (r.mode()) {
00266 case RM_EQV:
00267 case RM_IMP:
00268 GECODE_ME_FAIL(y.zero(home));
00269 break;
00270 case RM_PMI:
00271 break;
00272 default: throw UnknownReifyMode("Int::rel");
00273 }
00274 break;
00275 case IRT_GQ:
00276 switch (r.mode()) {
00277 case RM_EQV:
00278 case RM_PMI:
00279 GECODE_ME_FAIL(y.one(home));
00280 break;
00281 case RM_IMP:
00282 break;
00283 default: throw UnknownReifyMode("Int::rel");
00284 }
00285 break;
00286 default:
00287 throw UnknownRelation("Int::rel");
00288 }
00289 } else if (n == 1) {
00290 switch (irt) {
00291 case IRT_NQ:
00292 case IRT_LE:
00293 switch (r.mode()) {
00294 case RM_EQV:
00295 {
00296 NegBoolView ny(y);
00297 GECODE_ES_FAIL((Bool::Eq<BoolView,NegBoolView>
00298 ::post(home,x,ny)));
00299 }
00300 break;
00301 case RM_IMP:
00302 {
00303 NegBoolView nx(x); NegBoolView ny(y);
00304 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,NegBoolView>
00305 ::post(home,nx,ny)));
00306 }
00307 break;
00308 case RM_PMI:
00309 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,BoolView>
00310 ::post(home,x,y)));
00311 break;
00312 default: throw UnknownReifyMode("Int::rel");
00313 }
00314 break;
00315 case IRT_EQ:
00316 case IRT_GQ:
00317 switch (r.mode()) {
00318 case RM_EQV:
00319 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00320 ::post(home,x,y)));
00321 break;
00322 case RM_IMP:
00323 {
00324 NegBoolView ny(y);
00325 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,NegBoolView>
00326 ::post(home,x,ny)));
00327 }
00328 break;
00329 case RM_PMI:
00330 {
00331 NegBoolView nx(x);
00332 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,BoolView>
00333 ::post(home,nx,y)));
00334 }
00335 break;
00336 default: throw UnknownReifyMode("Int::rel");
00337 }
00338 break;
00339 case IRT_GR:
00340 switch (r.mode()) {
00341 case RM_EQV:
00342 case RM_IMP:
00343 GECODE_ME_FAIL(y.zero(home));
00344 break;
00345 case RM_PMI:
00346 break;
00347 default: throw UnknownReifyMode("Int::rel");
00348 }
00349 break;
00350 case IRT_LQ:
00351 switch (r.mode()) {
00352 case RM_EQV:
00353 case RM_PMI:
00354 GECODE_ME_FAIL(y.one(home));
00355 break;
00356 case RM_IMP:
00357 break;
00358 default: throw UnknownReifyMode("Int::rel");
00359 }
00360 break;
00361 default:
00362 throw UnknownRelation("Int::rel");
00363 }
00364 } else {
00365 throw NotZeroOne("Int::rel");
00366 }
00367 }
00368
00369 void
00370 rel(Home home, const BoolVarArgs& x, IntRelType irt, BoolVar y,
00371 IntPropLevel) {
00372 using namespace Int;
00373 GECODE_POST;
00374 switch (irt) {
00375 case IRT_EQ:
00376 for (int i=x.size(); i--; ) {
00377 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00378 ::post(home,x[i],y)));
00379 }
00380 break;
00381 case IRT_NQ:
00382 {
00383 NegBoolView n(y);
00384 for (int i=x.size(); i--; ) {
00385 GECODE_ES_FAIL((Bool::Eq<BoolView,NegBoolView>
00386 ::post(home,x[i],n)));
00387 }
00388 }
00389 break;
00390 case IRT_GQ:
00391 for (int i=x.size(); i--; ) {
00392 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,y,x[i]));
00393 }
00394 break;
00395 case IRT_LQ:
00396 for (int i=x.size(); i--; ) {
00397 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,x[i],y));
00398 }
00399 break;
00400 case IRT_GR:
00401 for (int i=x.size(); i--; ) {
00402 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,y,x[i]));
00403 }
00404 break;
00405 case IRT_LE:
00406 for (int i=x.size(); i--; ) {
00407 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[i],y));
00408 }
00409 break;
00410 default:
00411 throw UnknownRelation("Int::rel");
00412 }
00413 }
00414
00415 void
00416 rel(Home home, const BoolVarArgs& x, IntRelType irt, int n,
00417 IntPropLevel) {
00418 using namespace Int;
00419 GECODE_POST;
00420 if (n == 0) {
00421 switch (irt) {
00422 case IRT_LQ:
00423 case IRT_EQ:
00424 for (int i=x.size(); i--; ) {
00425 BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
00426 }
00427 break;
00428 case IRT_NQ:
00429 case IRT_GR:
00430 for (int i=x.size(); i--; ) {
00431 BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
00432 }
00433 break;
00434 case IRT_LE:
00435 home.fail(); break;
00436 case IRT_GQ:
00437 break;
00438 default:
00439 throw UnknownRelation("Int::rel");
00440 }
00441 } else if (n == 1) {
00442 switch (irt) {
00443 case IRT_GQ:
00444 case IRT_EQ:
00445 for (int i=x.size(); i--; ) {
00446 BoolView xi(x[i]); GECODE_ME_FAIL(xi.one(home));
00447 }
00448 break;
00449 case IRT_NQ:
00450 case IRT_LE:
00451 for (int i=x.size(); i--; ) {
00452 BoolView xi(x[i]); GECODE_ME_FAIL(xi.zero(home));
00453 }
00454 break;
00455 case IRT_GR:
00456 home.fail(); break;
00457 case IRT_LQ:
00458 break;
00459 default:
00460 throw UnknownRelation("Int::rel");
00461 }
00462 } else {
00463 throw NotZeroOne("Int::rel");
00464 }
00465 }
00466
00467 void
00468 rel(Home home, const BoolVarArgs& x, IntRelType irt, IntPropLevel) {
00469 using namespace Int;
00470 GECODE_POST;
00471 if ((irt != IRT_NQ) && (x.size() < 2))
00472 return;
00473
00474 switch (irt) {
00475 case IRT_EQ:
00476 {
00477 ViewArray<BoolView> y(home,x);
00478 GECODE_ES_FAIL(Bool::NaryEq<BoolView>::post(home,y));
00479 }
00480 break;
00481 case IRT_NQ:
00482 {
00483 ViewArray<BoolView> y(home,x);
00484 GECODE_ES_FAIL((Rel::NaryNq<BoolView>::post(home,y)));
00485 }
00486 break;
00487 case IRT_LE:
00488 if (x.size() == 2) {
00489 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[0],x[1]));
00490 } else {
00491 home.fail();
00492 }
00493 break;
00494 case IRT_LQ:
00495 {
00496 ViewArray<BoolView> y(home,x);
00497 GECODE_ES_FAIL(Bool::NaryLq<BoolView>::post(home,y));
00498 }
00499 break;
00500 case IRT_GR:
00501 if (x.size() == 2) {
00502 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[1],x[0]));
00503 } else {
00504 home.fail();
00505 }
00506 break;
00507 case IRT_GQ:
00508 {
00509 ViewArray<BoolView> y(home,x.size());
00510 for (int i=x.size(); i--; )
00511 y[i] = x[x.size()-1-i];
00512 GECODE_ES_FAIL(Bool::NaryLq<BoolView>::post(home,y));
00513 }
00514 for (int i=x.size()-1; i--; )
00515 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,x[i+1],x[i]));
00516 break;
00517 default:
00518 throw UnknownRelation("Int::rel");
00519 }
00520 }
00521
00522 void
00523 rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
00524 IntPropLevel) {
00525 using namespace Int;
00526 GECODE_POST;
00527
00528 switch (irt) {
00529 case IRT_GR:
00530 {
00531 ViewArray<BoolView> xv(home,x), yv(home,y);
00532 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,BoolView>
00533 ::post(home,yv,xv,true)));
00534 }
00535 break;
00536 case IRT_LE:
00537 {
00538 ViewArray<BoolView> xv(home,x), yv(home,y);
00539 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,BoolView>
00540 ::post(home,xv,yv,true)));
00541 }
00542 break;
00543 case IRT_GQ:
00544 {
00545 ViewArray<BoolView> xv(home,x), yv(home,y);
00546 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,BoolView>
00547 ::post(home,yv,xv,false)));
00548 }
00549 break;
00550 case IRT_LQ:
00551 {
00552 ViewArray<BoolView> xv(home,x), yv(home,y);
00553 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,BoolView>
00554 ::post(home,xv,yv,false)));
00555 }
00556 break;
00557 case IRT_EQ:
00558 for (int i=x.size(); i--; ) {
00559 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00560 ::post(home,x[i],y[i])));
00561 }
00562 break;
00563 case IRT_NQ:
00564 {
00565 ViewArray<BoolView> xv(home,x), yv(home,y);
00566 GECODE_ES_FAIL((Rel::LexNq<BoolView,BoolView>
00567 ::post(home,xv,yv)));
00568 }
00569 break;
00570 default:
00571 throw UnknownRelation("Int::rel");
00572 }
00573 }
00574
00575 namespace {
00576
00578 ViewArray<Int::ConstIntView>
00579 viewarray(Space& home, const IntArgs& x) {
00580 ViewArray<Int::ConstIntView> xv(home, x.size());
00581 for (int i = x.size(); i--; ) {
00582 if ((x[i] != 0) && (x[i] != 1))
00583 throw Int::NotZeroOne("Int::rel");
00584 xv[i] = Int::ConstIntView(x[i]);
00585 }
00586 return xv;
00587 }
00588
00589 }
00590
00591 void
00592 rel(Home home, const BoolVarArgs& x, IntRelType irt, const IntArgs& y,
00593 IntPropLevel) {
00594 using namespace Int;
00595 GECODE_POST;
00596
00597 switch (irt) {
00598 case IRT_GR:
00599 {
00600 ViewArray<BoolView> xv(home,x);
00601 ViewArray<ConstIntView> yv(viewarray(home,y));
00602 GECODE_ES_FAIL((Rel::LexLqLe<ConstIntView,BoolView>
00603 ::post(home,yv,xv,true)));
00604 }
00605 break;
00606 case IRT_LE:
00607 {
00608 ViewArray<BoolView> xv(home,x);
00609 ViewArray<ConstIntView> yv(viewarray(home,y));
00610 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,ConstIntView>
00611 ::post(home,xv,yv,true)));
00612 }
00613 break;
00614 case IRT_GQ:
00615 {
00616 ViewArray<BoolView> xv(home,x);
00617 ViewArray<ConstIntView> yv(viewarray(home,y));
00618 GECODE_ES_FAIL((Rel::LexLqLe<ConstIntView,BoolView>
00619 ::post(home,yv,xv,false)));
00620 }
00621 break;
00622 case IRT_LQ:
00623 {
00624 ViewArray<BoolView> xv(home,x);
00625 ViewArray<ConstIntView> yv(viewarray(home,y));
00626 GECODE_ES_FAIL((Rel::LexLqLe<BoolView,ConstIntView>
00627 ::post(home,xv,yv,false)));
00628 }
00629 break;
00630 case IRT_EQ:
00631 if (x.size() != y.size()) {
00632 home.fail();
00633 } else {
00634 for (int i=x.size(); i--; )
00635 GECODE_ME_FAIL(BoolView(x[i]).eq(home,y[i]));
00636 }
00637 break;
00638 case IRT_NQ:
00639 {
00640 ViewArray<BoolView> xv(home,x);
00641 ViewArray<ConstIntView> yv(viewarray(home,y));
00642 GECODE_ES_FAIL((Rel::LexNq<BoolView,ConstIntView>
00643 ::post(home,xv,yv)));
00644 }
00645 break;
00646 default:
00647 throw UnknownRelation("Int::rel");
00648 }
00649 }
00650
00651 void
00652 rel(Home home, const IntArgs& x, IntRelType irt, const BoolVarArgs& y,
00653 IntPropLevel ipl) {
00654 rel(home,y,irt,x,ipl);
00655 }
00656
00657 void
00658 rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
00659 IntPropLevel) {
00660 using namespace Int;
00661 GECODE_POST;
00662 switch (o) {
00663 case BOT_AND:
00664 {
00665 NegBoolView n0(x0); NegBoolView n1(x1); NegBoolView n2(x2);
00666 GECODE_ES_FAIL((Bool::Or<NegBoolView,NegBoolView,NegBoolView>
00667 ::post(home,n0,n1,n2)));
00668 }
00669 break;
00670 case BOT_OR:
00671 GECODE_ES_FAIL((Bool::Or<BoolView,BoolView,BoolView>
00672 ::post(home,x0,x1,x2)));
00673 break;
00674 case BOT_IMP:
00675 {
00676 NegBoolView n0(x0);
00677 GECODE_ES_FAIL((Bool::Or<NegBoolView,BoolView,BoolView>
00678 ::post(home,n0,x1,x2)));
00679 }
00680 break;
00681 case BOT_EQV:
00682 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,BoolView>
00683 ::post(home,x0,x1,x2)));
00684 break;
00685 case BOT_XOR:
00686 {
00687 NegBoolView n2(x2);
00688 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,NegBoolView>
00689 ::post(home,x0,x1,n2)));
00690 }
00691 break;
00692 default:
00693 throw UnknownOperation("Int::rel");
00694 }
00695 }
00696
00697 void
00698 rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
00699 IntPropLevel) {
00700 using namespace Int;
00701 GECODE_POST;
00702 if (n == 0) {
00703 switch (o) {
00704 case BOT_AND:
00705 {
00706 NegBoolView n0(x0); NegBoolView n1(x1);
00707 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,NegBoolView>
00708 ::post(home,n0,n1)));
00709 }
00710 break;
00711 case BOT_OR:
00712 {
00713 BoolView b0(x0); BoolView b1(x1);
00714 GECODE_ME_FAIL(b0.zero(home));
00715 GECODE_ME_FAIL(b1.zero(home));
00716 }
00717 break;
00718 case BOT_IMP:
00719 {
00720 BoolView b0(x0); BoolView b1(x1);
00721 GECODE_ME_FAIL(b0.one(home));
00722 GECODE_ME_FAIL(b1.zero(home));
00723 }
00724 break;
00725 case BOT_EQV:
00726 {
00727 NegBoolView n0(x0);
00728 GECODE_ES_FAIL((Bool::Eq<NegBoolView,BoolView>::post(home,n0,x1)));
00729 }
00730 break;
00731 case BOT_XOR:
00732 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>::post(home,x0,x1)));
00733 break;
00734 default:
00735 throw UnknownOperation("Int::rel");
00736 }
00737 } else if (n == 1) {
00738 switch (o) {
00739 case BOT_AND:
00740 {
00741 BoolView b0(x0); BoolView b1(x1);
00742 GECODE_ME_FAIL(b0.one(home));
00743 GECODE_ME_FAIL(b1.one(home));
00744 }
00745 break;
00746 case BOT_OR:
00747 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,BoolView>::post(home,x0,x1)));
00748 break;
00749 case BOT_IMP:
00750 {
00751 NegBoolView n0(x0);
00752 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,BoolView>
00753 ::post(home,n0,x1)));
00754 }
00755 break;
00756 case BOT_EQV:
00757 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>::post(home,x0,x1)));
00758 break;
00759 case BOT_XOR:
00760 {
00761 NegBoolView n0(x0);
00762 GECODE_ES_FAIL((Bool::Eq<NegBoolView,BoolView>::post(home,n0,x1)));
00763 }
00764 break;
00765 default:
00766 throw UnknownOperation("Int::rel");
00767 }
00768 } else {
00769 throw NotZeroOne("Int::rel");
00770 }
00771 }
00772
00773 void
00774 rel(Home home, BoolOpType o, const BoolVarArgs& x, BoolVar y,
00775 IntPropLevel) {
00776 using namespace Int;
00777 GECODE_POST;
00778 int m = x.size();
00779 Region r;
00780 switch (o) {
00781 case BOT_AND:
00782 {
00783 ViewArray<NegBoolView> b(home,m);
00784 for (int i=m; i--; ) {
00785 NegBoolView nb(x[i]); b[i]=nb;
00786 }
00787 NegBoolView ny(y);
00788 b.unique();
00789 GECODE_ES_FAIL((Bool::NaryOr<NegBoolView,NegBoolView>
00790 ::post(home,b,ny)));
00791 }
00792 break;
00793 case BOT_OR:
00794 {
00795 ViewArray<BoolView> b(home,x);
00796 b.unique();
00797 GECODE_ES_FAIL((Bool::NaryOr<BoolView,BoolView>::post(home,b,y)));
00798 }
00799 break;
00800 case BOT_IMP:
00801 if (m < 2) {
00802 throw TooFewArguments("Int::rel");
00803 } else {
00804 ViewArray<NegBoolView> a(home,x.size()-1);
00805 for (int i=x.size()-1; i--; )
00806 a[i]=NegBoolView(x[i]);
00807 ViewArray<BoolView> b(home,1);
00808 b[0]=x[x.size()-1];
00809 GECODE_ES_FAIL((Bool::Clause<BoolView,NegBoolView>
00810 ::post(home,b,a,y)));
00811 }
00812 break;
00813 case BOT_EQV:
00814 {
00815 ViewArray<BoolView> xy(home, x.size() + 1);
00816 for (int i=x.size(); i--; )
00817 xy[i] = x[i];
00818 xy[x.size()] = y;
00819 GECODE_ES_FAIL(Bool::NaryEqv::post(home,xy,0));
00820 }
00821 break;
00822 case BOT_XOR:
00823 {
00824 ViewArray<BoolView> xy(home, x.size() + 1);
00825 for (int i=x.size(); i--; )
00826 xy[i] = x[i];
00827 xy[x.size()] = y;
00828 GECODE_ES_FAIL(Bool::NaryEqv::post(home,xy,1));
00829 }
00830 break;
00831 default:
00832 throw UnknownOperation("Int::rel");
00833 }
00834 }
00835
00836 void
00837 rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
00838 IntPropLevel) {
00839 using namespace Int;
00840 if ((n < 0) || (n > 1))
00841 throw NotZeroOne("Int::rel");
00842 GECODE_POST;
00843 int m = x.size();
00844 Region r;
00845 switch (o) {
00846 case BOT_AND:
00847 if (n == 0) {
00848 ViewArray<NegBoolView> b(home,m);
00849 for (int i=m; i--; ) {
00850 NegBoolView nb(x[i]); b[i]=nb;
00851 }
00852 b.unique();
00853 GECODE_ES_FAIL(Bool::NaryOrTrue<NegBoolView>::post(home,b));
00854 } else {
00855 for (int i=m; i--; ) {
00856 BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
00857 }
00858 }
00859 break;
00860 case BOT_OR:
00861 if (n == 0) {
00862 for (int i=m; i--; ) {
00863 BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
00864 }
00865 } else {
00866 ViewArray<BoolView> b(home,x);
00867 b.unique();
00868 GECODE_ES_FAIL(Bool::NaryOrTrue<BoolView>::post(home,b));
00869 }
00870 break;
00871 case BOT_IMP:
00872 if (m < 2) {
00873 throw TooFewArguments("Int::rel");
00874 } else if (n == 0) {
00875 for (int i=m-1; i--; )
00876 GECODE_ME_FAIL(BoolView(x[i]).one(home));
00877 GECODE_ME_FAIL(BoolView(x[m-1]).zero(home));
00878 } else {
00879 ViewArray<NegBoolView> a(home,x.size()-1);
00880 for (int i=x.size()-1; i--; )
00881 a[i]=NegBoolView(x[i]);
00882 ViewArray<BoolView> b(home,1);
00883 b[0]=x[x.size()-1];
00884 GECODE_ES_FAIL((Bool::ClauseTrue<BoolView,NegBoolView>
00885 ::post(home,b,a)));
00886 }
00887 break;
00888 case BOT_EQV:
00889 {
00890 ViewArray<BoolView> b(home,x);
00891 GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,n));
00892 }
00893 break;
00894 case BOT_XOR:
00895 {
00896 ViewArray<BoolView> b(home,x);
00897 GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,1^n));
00898 }
00899 break;
00900 default:
00901 throw UnknownOperation("Int::rel");
00902 }
00903 }
00904
00905 void
00906 clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
00907 int n, IntPropLevel) {
00908 using namespace Int;
00909 if ((n < 0) || (n > 1))
00910 throw NotZeroOne("Int::rel");
00911 GECODE_POST;
00912 switch (o) {
00913 case BOT_AND:
00914 if (n == 0) {
00915 ViewArray<NegBoolView> xv(home,x.size());
00916 for (int i=x.size(); i--; ) {
00917 NegBoolView nxi(x[i]); xv[i]=nxi;
00918 }
00919 ViewArray<BoolView> yv(home,y);
00920 xv.unique(); yv.unique();
00921 GECODE_ES_FAIL((Bool::ClauseTrue<NegBoolView,BoolView>
00922 ::post(home,xv,yv)));
00923 } else {
00924 for (int i=x.size(); i--; ) {
00925 BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
00926 }
00927 for (int i=y.size(); i--; ) {
00928 BoolView b(y[i]); GECODE_ME_FAIL(b.zero(home));
00929 }
00930 }
00931 break;
00932 case BOT_OR:
00933 if (n == 0) {
00934 for (int i=x.size(); i--; ) {
00935 BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
00936 }
00937 for (int i=y.size(); i--; ) {
00938 BoolView b(y[i]); GECODE_ME_FAIL(b.one(home));
00939 }
00940 } else {
00941 ViewArray<BoolView> xv(home,x);
00942 ViewArray<NegBoolView> yv(home,y.size());
00943 for (int i=y.size(); i--; ) {
00944 NegBoolView nyi(y[i]); yv[i]=nyi;
00945 }
00946 xv.unique(); yv.unique();
00947 GECODE_ES_FAIL((Bool::ClauseTrue<BoolView,NegBoolView>
00948 ::post(home,xv,yv)));
00949 }
00950 break;
00951 default:
00952 throw IllegalOperation("Int::clause");
00953 }
00954 }
00955
00956 void
00957 clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
00958 BoolVar z, IntPropLevel) {
00959 using namespace Int;
00960 GECODE_POST;
00961 switch (o) {
00962 case BOT_AND:
00963 {
00964 ViewArray<NegBoolView> xv(home,x.size());
00965 for (int i=x.size(); i--; ) {
00966 NegBoolView n(x[i]); xv[i]=n;
00967 }
00968 ViewArray<BoolView> yv(home,y);
00969 xv.unique(); yv.unique();
00970 NegBoolView nz(z);
00971 GECODE_ES_FAIL((Bool::Clause<NegBoolView,BoolView>
00972 ::post(home,xv,yv,nz)));
00973 }
00974 break;
00975 case BOT_OR:
00976 {
00977 ViewArray<BoolView> xv(home,x);
00978 ViewArray<NegBoolView> yv(home,y.size());
00979 for (int i=y.size(); i--; ) {
00980 NegBoolView n(y[i]); yv[i]=n;
00981 }
00982 xv.unique(); yv.unique();
00983 GECODE_ES_FAIL((Bool::Clause<BoolView,NegBoolView>
00984 ::post(home,xv,yv,z)));
00985 }
00986 break;
00987 default:
00988 throw IllegalOperation("Int::clause");
00989 }
00990 }
00991
00992 void
00993 ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z,
00994 IntPropLevel ipl) {
00995 using namespace Int;
00996 GECODE_POST;
00997 if (vbd(ipl) == IPL_BND) {
00998 GECODE_ES_FAIL((Bool::IteBnd<IntView,IntView,IntView>
00999 ::post(home,b,x,y,z)));
01000 } else {
01001 GECODE_ES_FAIL((Bool::IteDom<IntView,IntView,IntView>
01002 ::post(home,b,x,y,z)));
01003 }
01004 }
01005
01006 void
01007 ite(Home home, BoolVar b, BoolVar x, BoolVar y, BoolVar z,
01008 IntPropLevel) {
01009 using namespace Int;
01010 GECODE_POST;
01011 GECODE_ES_FAIL((Bool::IteBnd<BoolView,BoolView,BoolView>
01012 ::post(home,b,x,y,z)));
01013 }
01014
01015 }
01016
01017