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, IntConLevel) {
00045 using namespace Int;
00046 if (home.failed()) return;
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, IntConLevel) {
00078 using namespace Int;
00079 if (home.failed()) return;
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 IntConLevel) {
00119 using namespace Int;
00120 if (home.failed()) return;
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 IntConLevel) {
00214 using namespace Int;
00215 if (home.failed()) return;
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 IntConLevel) {
00376 using namespace Int;
00377 if (home.failed()) return;
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 IntConLevel) {
00422 using namespace Int;
00423 if (home.failed()) return;
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, IntConLevel) {
00473 using namespace Int;
00474 if (home.failed() || ((irt != IRT_NQ) && (x.size() < 2)))
00475 return;
00476
00477 switch (irt) {
00478 case IRT_EQ:
00479 {
00480 ViewArray<BoolView> y(home,x);
00481 GECODE_ES_FAIL(Bool::NaryEq<BoolView>::post(home,y));
00482 }
00483 break;
00484 case IRT_NQ:
00485 {
00486 ViewArray<BoolView> y(home,x);
00487 GECODE_ES_FAIL((Rel::NaryNq<BoolView>::post(home,y)));
00488 }
00489 break;
00490 case IRT_LE:
00491 if (x.size() == 2) {
00492 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[0],x[1]));
00493 } else {
00494 home.fail();
00495 }
00496 break;
00497 case IRT_LQ:
00498 {
00499 ViewArray<BoolView> y(home,x);
00500 GECODE_ES_FAIL(Bool::NaryLq<BoolView>::post(home,y));
00501 }
00502 break;
00503 case IRT_GR:
00504 if (x.size() == 2) {
00505 GECODE_ES_FAIL(Bool::Le<BoolView>::post(home,x[1],x[0]));
00506 } else {
00507 home.fail();
00508 }
00509 break;
00510 case IRT_GQ:
00511 {
00512 ViewArray<BoolView> y(home,x.size());
00513 for (int i=x.size(); i--; )
00514 y[i] = x[x.size()-1-i];
00515 GECODE_ES_FAIL(Bool::NaryLq<BoolView>::post(home,y));
00516 }
00517 for (int i=x.size()-1; i--; )
00518 GECODE_ES_FAIL(Bool::Lq<BoolView>::post(home,x[i+1],x[i]));
00519 break;
00520 default:
00521 throw UnknownRelation("Int::rel");
00522 }
00523 }
00524
00525 void
00526 rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
00527 IntConLevel) {
00528 using namespace Int;
00529 if (x.size() != y.size())
00530 throw ArgumentSizeMismatch("Int::rel");
00531 if (home.failed()) return;
00532
00533 switch (irt) {
00534 case IRT_GR:
00535 {
00536 ViewArray<BoolView> xv(home,x), yv(home,y);
00537 GECODE_ES_FAIL(Rel::LexLqLe<BoolView>::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>::post(home,xv,yv,true));
00544 }
00545 break;
00546 case IRT_GQ:
00547 {
00548 ViewArray<BoolView> xv(home,x), yv(home,y);
00549 GECODE_ES_FAIL(Rel::LexLqLe<BoolView>::post(home,yv,xv,false));
00550 }
00551 break;
00552 case IRT_LQ:
00553 {
00554 ViewArray<BoolView> xv(home,x), yv(home,y);
00555 GECODE_ES_FAIL(Rel::LexLqLe<BoolView>::post(home,xv,yv,false));
00556 }
00557 break;
00558 case IRT_EQ:
00559 for (int i=x.size(); i--; ) {
00560 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>
00561 ::post(home,x[i],y[i])));
00562 }
00563 break;
00564 case IRT_NQ:
00565 {
00566 ViewArray<BoolView> xv(home,x), yv(home,y);
00567 GECODE_ES_FAIL(Rel::LexNq<BoolView>::post(home,xv,yv));
00568 }
00569 break;
00570 default:
00571 throw UnknownRelation("Int::rel");
00572 }
00573 }
00574
00575 void
00576 rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
00577 IntConLevel) {
00578 using namespace Int;
00579 if (home.failed()) return;
00580 switch (o) {
00581 case BOT_AND:
00582 {
00583 NegBoolView n0(x0); NegBoolView n1(x1); NegBoolView n2(x2);
00584 GECODE_ES_FAIL((Bool::Or<NegBoolView,NegBoolView,NegBoolView>
00585 ::post(home,n0,n1,n2)));
00586 }
00587 break;
00588 case BOT_OR:
00589 GECODE_ES_FAIL((Bool::Or<BoolView,BoolView,BoolView>
00590 ::post(home,x0,x1,x2)));
00591 break;
00592 case BOT_IMP:
00593 {
00594 NegBoolView n0(x0);
00595 GECODE_ES_FAIL((Bool::Or<NegBoolView,BoolView,BoolView>
00596 ::post(home,n0,x1,x2)));
00597 }
00598 break;
00599 case BOT_EQV:
00600 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,BoolView>
00601 ::post(home,x0,x1,x2)));
00602 break;
00603 case BOT_XOR:
00604 {
00605 NegBoolView n2(x2);
00606 GECODE_ES_FAIL((Bool::Eqv<BoolView,BoolView,NegBoolView>
00607 ::post(home,x0,x1,n2)));
00608 }
00609 break;
00610 default:
00611 throw UnknownOperation("Int::rel");
00612 }
00613 }
00614
00615 void
00616 rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
00617 IntConLevel) {
00618 using namespace Int;
00619 if (home.failed()) return;
00620 if (n == 0) {
00621 switch (o) {
00622 case BOT_AND:
00623 {
00624 NegBoolView n0(x0); NegBoolView n1(x1);
00625 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,NegBoolView>
00626 ::post(home,n0,n1)));
00627 }
00628 break;
00629 case BOT_OR:
00630 {
00631 BoolView b0(x0); BoolView b1(x1);
00632 GECODE_ME_FAIL(b0.zero(home));
00633 GECODE_ME_FAIL(b1.zero(home));
00634 }
00635 break;
00636 case BOT_IMP:
00637 {
00638 BoolView b0(x0); BoolView b1(x1);
00639 GECODE_ME_FAIL(b0.one(home));
00640 GECODE_ME_FAIL(b1.zero(home));
00641 }
00642 break;
00643 case BOT_EQV:
00644 {
00645 NegBoolView n0(x0);
00646 GECODE_ES_FAIL((Bool::Eq<NegBoolView,BoolView>::post(home,n0,x1)));
00647 }
00648 break;
00649 case BOT_XOR:
00650 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>::post(home,x0,x1)));
00651 break;
00652 default:
00653 throw UnknownOperation("Int::rel");
00654 }
00655 } else if (n == 1) {
00656 switch (o) {
00657 case BOT_AND:
00658 {
00659 BoolView b0(x0); BoolView b1(x1);
00660 GECODE_ME_FAIL(b0.one(home));
00661 GECODE_ME_FAIL(b1.one(home));
00662 }
00663 break;
00664 case BOT_OR:
00665 GECODE_ES_FAIL((Bool::BinOrTrue<BoolView,BoolView>::post(home,x0,x1)));
00666 break;
00667 case BOT_IMP:
00668 {
00669 NegBoolView n0(x0);
00670 GECODE_ES_FAIL((Bool::BinOrTrue<NegBoolView,BoolView>
00671 ::post(home,n0,x1)));
00672 }
00673 break;
00674 case BOT_EQV:
00675 GECODE_ES_FAIL((Bool::Eq<BoolView,BoolView>::post(home,x0,x1)));
00676 break;
00677 case BOT_XOR:
00678 {
00679 NegBoolView n0(x0);
00680 GECODE_ES_FAIL((Bool::Eq<NegBoolView,BoolView>::post(home,n0,x1)));
00681 }
00682 break;
00683 default:
00684 throw UnknownOperation("Int::rel");
00685 }
00686 } else {
00687 throw NotZeroOne("Int::rel");
00688 }
00689 }
00690
00691 void
00692 rel(Home home, BoolOpType o, const BoolVarArgs& x, BoolVar y,
00693 IntConLevel) {
00694 using namespace Int;
00695 if (home.failed()) return;
00696 int m = x.size();
00697 Region r(home);
00698 switch (o) {
00699 case BOT_AND:
00700 {
00701 ViewArray<NegBoolView> b(home,m);
00702 for (int i=m; i--; ) {
00703 NegBoolView nb(x[i]); b[i]=nb;
00704 }
00705 NegBoolView ny(y);
00706 b.unique(home);
00707 GECODE_ES_FAIL((Bool::NaryOr<NegBoolView,NegBoolView>
00708 ::post(home,b,ny)));
00709 }
00710 break;
00711 case BOT_OR:
00712 {
00713 ViewArray<BoolView> b(home,x);
00714 b.unique(home);
00715 GECODE_ES_FAIL((Bool::NaryOr<BoolView,BoolView>::post(home,b,y)));
00716 }
00717 break;
00718 case BOT_IMP:
00719 if (m < 2) {
00720 throw TooFewArguments("Int::rel");
00721 } else {
00722 ViewArray<NegBoolView> a(home,x.size()-1);
00723 for (int i=x.size()-1; i--; )
00724 a[i]=NegBoolView(x[i]);
00725 ViewArray<BoolView> b(home,1);
00726 b[0]=x[x.size()-1];
00727 GECODE_ES_FAIL((Bool::Clause<BoolView,NegBoolView>
00728 ::post(home,b,a,y)));
00729 }
00730 break;
00731 case BOT_EQV:
00732 {
00733 ViewArray<BoolView> xy(home, x.size() + 1);
00734 for (int i=x.size(); i--; )
00735 xy[i] = x[i];
00736 xy[x.size()] = y;
00737 GECODE_ES_FAIL(Bool::NaryEqv::post(home,xy,0));
00738 }
00739 break;
00740 case BOT_XOR:
00741 {
00742 ViewArray<BoolView> xy(home, x.size() + 1);
00743 for (int i=x.size(); i--; )
00744 xy[i] = x[i];
00745 xy[x.size()] = y;
00746 GECODE_ES_FAIL(Bool::NaryEqv::post(home,xy,1));
00747 }
00748 break;
00749 default:
00750 throw UnknownOperation("Int::rel");
00751 }
00752 }
00753
00754 void
00755 rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
00756 IntConLevel) {
00757 using namespace Int;
00758 if ((n < 0) || (n > 1))
00759 throw NotZeroOne("Int::rel");
00760 if (home.failed()) return;
00761 int m = x.size();
00762 Region r(home);
00763 switch (o) {
00764 case BOT_AND:
00765 if (n == 0) {
00766 ViewArray<NegBoolView> b(home,m);
00767 for (int i=m; i--; ) {
00768 NegBoolView nb(x[i]); b[i]=nb;
00769 }
00770 b.unique(home);
00771 GECODE_ES_FAIL(Bool::NaryOrTrue<NegBoolView>::post(home,b));
00772 } else {
00773 for (int i=m; i--; ) {
00774 BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
00775 }
00776 }
00777 break;
00778 case BOT_OR:
00779 if (n == 0) {
00780 for (int i=m; i--; ) {
00781 BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
00782 }
00783 } else {
00784 ViewArray<BoolView> b(home,x);
00785 b.unique(home);
00786 GECODE_ES_FAIL(Bool::NaryOrTrue<BoolView>::post(home,b));
00787 }
00788 break;
00789 case BOT_IMP:
00790 if (m < 2) {
00791 throw TooFewArguments("Int::rel");
00792 } else if (n == 0) {
00793 for (int i=m-1; i--; )
00794 GECODE_ME_FAIL(BoolView(x[i]).one(home));
00795 GECODE_ME_FAIL(BoolView(x[m-1]).zero(home));
00796 } else {
00797 ViewArray<NegBoolView> a(home,x.size()-1);
00798 for (int i=x.size()-1; i--; )
00799 a[i]=NegBoolView(x[i]);
00800 ViewArray<BoolView> b(home,1);
00801 b[0]=x[x.size()-1];
00802 GECODE_ES_FAIL((Bool::ClauseTrue<BoolView,NegBoolView>
00803 ::post(home,b,a)));
00804 }
00805 break;
00806 case BOT_EQV:
00807 {
00808 ViewArray<BoolView> b(home,x);
00809 GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,n));
00810 }
00811 break;
00812 case BOT_XOR:
00813 {
00814 ViewArray<BoolView> b(home,x);
00815 GECODE_ES_FAIL(Bool::NaryEqv::post(home,b,1^n));
00816 }
00817 break;
00818 default:
00819 throw UnknownOperation("Int::rel");
00820 }
00821 }
00822
00823 void
00824 clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
00825 int n, IntConLevel) {
00826 using namespace Int;
00827 if ((n < 0) || (n > 1))
00828 throw NotZeroOne("Int::rel");
00829 if (home.failed()) return;
00830 switch (o) {
00831 case BOT_AND:
00832 if (n == 0) {
00833 ViewArray<NegBoolView> xv(home,x.size());
00834 for (int i=x.size(); i--; ) {
00835 NegBoolView n(x[i]); xv[i]=n;
00836 }
00837 ViewArray<BoolView> yv(home,y);
00838 xv.unique(home); yv.unique(home);
00839 GECODE_ES_FAIL((Bool::ClauseTrue<NegBoolView,BoolView>
00840 ::post(home,xv,yv)));
00841 } else {
00842 for (int i=x.size(); i--; ) {
00843 BoolView b(x[i]); GECODE_ME_FAIL(b.one(home));
00844 }
00845 for (int i=y.size(); i--; ) {
00846 BoolView b(y[i]); GECODE_ME_FAIL(b.zero(home));
00847 }
00848 }
00849 break;
00850 case BOT_OR:
00851 if (n == 0) {
00852 for (int i=x.size(); i--; ) {
00853 BoolView b(x[i]); GECODE_ME_FAIL(b.zero(home));
00854 }
00855 for (int i=y.size(); i--; ) {
00856 BoolView b(y[i]); GECODE_ME_FAIL(b.one(home));
00857 }
00858 } else {
00859 ViewArray<BoolView> xv(home,x);
00860 ViewArray<NegBoolView> yv(home,y.size());
00861 for (int i=y.size(); i--; ) {
00862 NegBoolView n(y[i]); yv[i]=n;
00863 }
00864 xv.unique(home); yv.unique(home);
00865 GECODE_ES_FAIL((Bool::ClauseTrue<BoolView,NegBoolView>
00866 ::post(home,xv,yv)));
00867 }
00868 break;
00869 default:
00870 throw IllegalOperation("Int::clause");
00871 }
00872 }
00873
00874 void
00875 clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
00876 BoolVar z, IntConLevel) {
00877 using namespace Int;
00878 if (home.failed()) return;
00879 switch (o) {
00880 case BOT_AND:
00881 {
00882 ViewArray<NegBoolView> xv(home,x.size());
00883 for (int i=x.size(); i--; ) {
00884 NegBoolView n(x[i]); xv[i]=n;
00885 }
00886 ViewArray<BoolView> yv(home,y);
00887 xv.unique(home); yv.unique(home);
00888 NegBoolView nz(z);
00889 GECODE_ES_FAIL((Bool::Clause<NegBoolView,BoolView>
00890 ::post(home,xv,yv,nz)));
00891 }
00892 break;
00893 case BOT_OR:
00894 {
00895 ViewArray<BoolView> xv(home,x);
00896 ViewArray<NegBoolView> yv(home,y.size());
00897 for (int i=y.size(); i--; ) {
00898 NegBoolView n(y[i]); yv[i]=n;
00899 }
00900 xv.unique(home); yv.unique(home);
00901 GECODE_ES_FAIL((Bool::Clause<BoolView,NegBoolView>
00902 ::post(home,xv,yv,z)));
00903 }
00904 break;
00905 default:
00906 throw IllegalOperation("Int::clause");
00907 }
00908 }
00909
00910 void
00911 ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z,
00912 IntConLevel icl) {
00913 using namespace Int;
00914 if (home.failed()) return;
00915 if (icl == ICL_BND) {
00916 GECODE_ES_FAIL(Bool::IteBnd<IntView>::post(home,b,x,y,z));
00917 } else {
00918 GECODE_ES_FAIL(Bool::IteDom<IntView>::post(home,b,x,y,z));
00919 }
00920 }
00921
00922 }
00923
00924