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