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 namespace Gecode { namespace Int { namespace Rel {
00035
00036
00037
00038
00039
00040
00041 template<class View0, class View1>
00042 forceinline
00043 EqVal<View0,View1>::EqVal(Home home, View0 x0, View1 x1)
00044 : MixBinaryPropagator<View0,PC_INT_VAL,View1,PC_INT_VAL>(home,x0,x1) {}
00045
00046 template<class View0, class View1>
00047 ExecStatus
00048 EqVal<View0,View1>::post(Home home, View0 x0, View1 x1){
00049 if (x0.assigned()) {
00050 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00051 } else if (x1.assigned()) {
00052 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00053 } else if (x0 != x1) {
00054 (void) new (home) EqVal<View0,View1>(home,x0,x1);
00055 }
00056 return ES_OK;
00057 }
00058
00059 template<class View0, class View1>
00060 forceinline
00061 EqVal<View0,View1>::EqVal(Space& home, EqVal<View0,View1>& p)
00062 : MixBinaryPropagator<View0,PC_INT_VAL,View1,PC_INT_VAL>(home,p) {}
00063
00064 template<class View0, class View1>
00065 forceinline
00066 EqVal<View0,View1>::EqVal(Space& home, Propagator& p,
00067 View0 x0, View1 x1)
00068 : MixBinaryPropagator<View0,PC_INT_VAL,View1,PC_INT_VAL>(home,p,
00069 x0,x1) {}
00070
00071 template<class View0, class View1>
00072 Actor*
00073 EqVal<View0,View1>::copy(Space& home) {
00074 return new (home) EqVal<View0,View1>(home,*this);
00075 }
00076
00077 template<class View0, class View1>
00078 PropCost
00079 EqVal<View0,View1>::cost(const Space&, const ModEventDelta&) const {
00080 return PropCost::unary(PropCost::LO);
00081 }
00082
00083 template<class View0, class View1>
00084 ExecStatus
00085 EqVal<View0,View1>::propagate(Space& home, const ModEventDelta&) {
00086 if (x0.assigned()) {
00087 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00088 } else {
00089 assert(x1.assigned());
00090 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00091 }
00092 return home.ES_SUBSUMED(*this);
00093 }
00094
00095
00096
00097
00098
00099
00100
00101 template<class View0, class View1>
00102 forceinline
00103 EqBnd<View0,View1>::EqBnd(Home home, View0 x0, View1 x1)
00104 : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,x0,x1) {}
00105
00106 template<class View0, class View1>
00107 ExecStatus
00108 EqBnd<View0,View1>::post(Home home, View0 x0, View1 x1){
00109 if (x0.assigned()) {
00110 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00111 } else if (x1.assigned()) {
00112 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00113 } else if (x0 != x1) {
00114 GECODE_ME_CHECK(x0.lq(home,x1.max()));
00115 GECODE_ME_CHECK(x1.lq(home,x0.max()));
00116 GECODE_ME_CHECK(x0.gq(home,x1.min()));
00117 GECODE_ME_CHECK(x1.gq(home,x0.min()));
00118 (void) new (home) EqBnd<View0,View1>(home,x0,x1);
00119 }
00120 return ES_OK;
00121 }
00122
00123 template<class View0, class View1>
00124 forceinline
00125 EqBnd<View0,View1>::EqBnd(Space& home, EqBnd<View0,View1>& p)
00126 : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,p) {}
00127
00128 template<class View0, class View1>
00129 forceinline
00130 EqBnd<View0,View1>::EqBnd(Space& home, Propagator& p,
00131 View0 x0, View1 x1)
00132 : MixBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,p,
00133 x0,x1) {}
00134
00135 template<class View0, class View1>
00136 Actor*
00137 EqBnd<View0,View1>::copy(Space& home) {
00138 return new (home) EqBnd<View0,View1>(home,*this);
00139 }
00140
00141 template<class View0, class View1>
00142 ExecStatus
00143 EqBnd<View0,View1>::propagate(Space& home, const ModEventDelta&) {
00144 if (x0.assigned()) {
00145 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00146 } else if (x1.assigned()) {
00147 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00148 } else {
00149 do {
00150 GECODE_ME_CHECK(x0.gq(home,x1.min()));
00151 GECODE_ME_CHECK(x1.gq(home,x0.min()));
00152 } while (x0.min() != x1.min());
00153 do {
00154 GECODE_ME_CHECK(x0.lq(home,x1.max()));
00155 GECODE_ME_CHECK(x1.lq(home,x0.max()));
00156 } while (x0.max() != x1.max());
00157 if (!x0.assigned())
00158 return ES_FIX;
00159 }
00160 assert(x0.assigned() && x1.assigned());
00161 return home.ES_SUBSUMED(*this);
00162 }
00163
00164
00165
00166
00167
00168
00169 template<class View0, class View1>
00170 forceinline
00171 EqDom<View0,View1>::EqDom(Home home, View0 x0, View1 x1)
00172 : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,x0,x1) {}
00173
00174 template<class View0, class View1>
00175 ExecStatus
00176 EqDom<View0,View1>::post(Home home, View0 x0, View1 x1){
00177 if (x0.assigned()) {
00178 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00179 } else if (x1.assigned()) {
00180 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00181 } else if (x0 != x1) {
00182 GECODE_ME_CHECK(x0.lq(home,x1.max()));
00183 GECODE_ME_CHECK(x1.lq(home,x0.max()));
00184 GECODE_ME_CHECK(x0.gq(home,x1.min()));
00185 GECODE_ME_CHECK(x1.gq(home,x0.min()));
00186 (void) new (home) EqDom<View0,View1>(home,x0,x1);
00187 }
00188 return ES_OK;
00189 }
00190
00191
00192 template<class View0, class View1>
00193 forceinline
00194 EqDom<View0,View1>::EqDom(Space& home, EqDom<View0,View1>& p)
00195 : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,p) {}
00196
00197 template<class View0, class View1>
00198 forceinline
00199 EqDom<View0,View1>::EqDom(Space& home, Propagator& p,
00200 View0 x0, View1 x1)
00201 : MixBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,p,
00202 x0,x1) {}
00203
00204 template<class View0, class View1>
00205 Actor*
00206 EqDom<View0,View1>::copy(Space& home) {
00207 return new (home) EqDom<View0,View1>(home,*this);
00208 }
00209
00210 template<class View0, class View1>
00211 PropCost
00212 EqDom<View0,View1>::cost(const Space&, const ModEventDelta& med) const {
00213 if ((View0::me(med) == ME_INT_VAL) || (View1::me(med) == ME_INT_VAL))
00214 return PropCost::unary(PropCost::LO);
00215 else if ((View0::me(med) == ME_INT_DOM) || (View1::me(med) == ME_INT_DOM))
00216 return PropCost::binary(PropCost::LO);
00217 else
00218 return PropCost::binary(PropCost::HI);
00219 }
00220
00221 template<class View0, class View1>
00222 ExecStatus
00223 EqDom<View0,View1>::propagate(Space& home, const ModEventDelta& med) {
00224 if (x0.assigned()) {
00225 GECODE_ME_CHECK(x1.eq(home,x0.val()));
00226 return home.ES_SUBSUMED(*this);
00227 }
00228 if (x1.assigned()) {
00229 GECODE_ME_CHECK(x0.eq(home,x1.val()));
00230 return home.ES_SUBSUMED(*this);
00231 }
00232 if ((View0::me(med) != ME_INT_DOM) && (View1::me(med) != ME_INT_DOM)) {
00233 do {
00234 GECODE_ME_CHECK(x0.gq(home,x1.min()));
00235 GECODE_ME_CHECK(x1.gq(home,x0.min()));
00236 } while (x0.min() != x1.min());
00237 do {
00238 GECODE_ME_CHECK(x0.lq(home,x1.max()));
00239 GECODE_ME_CHECK(x1.lq(home,x0.max()));
00240 } while (x0.max() != x1.max());
00241 if (x0.assigned())
00242 return home.ES_SUBSUMED(*this);
00243 if (x0.range() && x1.range())
00244 return ES_FIX;
00245 return home.ES_FIX_PARTIAL(*this,View0::med(ME_INT_DOM));
00246 }
00247 ViewRanges<View0> r0(x0);
00248 GECODE_ME_CHECK(x1.inter_r(home,r0,shared(x0,x1)));
00249 ViewRanges<View1> r1(x1);
00250 GECODE_ME_CHECK(x0.narrow_r(home,r1,shared(x0,x1)));
00251 if (x0.assigned())
00252 return home.ES_SUBSUMED(*this);
00253 return ES_FIX;
00254 }
00255
00256
00257
00258
00259
00260
00261
00262
00263 template<class View>
00264 forceinline
00265 NaryEqDom<View>::NaryEqDom(Home home, ViewArray<View>& x)
00266 : NaryPropagator<View,PC_INT_DOM>(home,x) {}
00267
00268 template<class View>
00269 ExecStatus
00270 NaryEqDom<View>::post(Home home, ViewArray<View>& x) {
00271 x.unique();
00272 if (x.size() == 2) {
00273 return EqDom<View,View>::post(home,x[0],x[1]);
00274 } else if (x.size() > 2) {
00275 int l = x[0].min();
00276 int u = x[0].max();
00277 for (int i=1; i<x.size(); i++) {
00278 l = std::max(l,x[i].min());
00279 u = std::min(u,x[i].max());
00280 }
00281 for (int i=0; i<x.size(); i++) {
00282 GECODE_ME_CHECK(x[i].gq(home,l));
00283 GECODE_ME_CHECK(x[i].lq(home,u));
00284 }
00285 (void) new (home) NaryEqDom<View>(home,x);
00286 }
00287 return ES_OK;
00288 }
00289
00290 template<class View>
00291 forceinline
00292 NaryEqDom<View>::NaryEqDom(Space& home, NaryEqDom<View>& p)
00293 : NaryPropagator<View,PC_INT_DOM>(home,p) {}
00294
00295 template<class View>
00296 Actor*
00297 NaryEqDom<View>::copy(Space& home) {
00298 return new (home) NaryEqDom<View>(home,*this);
00299 }
00300
00301 template<class View>
00302 PropCost
00303 NaryEqDom<View>::cost(const Space&, const ModEventDelta& med) const {
00304 if (View::me(med) == ME_INT_VAL)
00305 return PropCost::unary(PropCost::LO);
00306 else
00307 return PropCost::linear((View::me(med) == ME_INT_DOM) ?
00308 PropCost::LO : PropCost::HI, x.size());
00309 }
00310
00311 template<class View>
00312 ExecStatus
00313 NaryEqDom<View>::propagate(Space& home, const ModEventDelta& med) {
00314 assert(x.size() > 2);
00315
00316 ModEvent me = View::me(med);
00317 if (me == ME_INT_VAL) {
00318
00319 for (int i=0; ; i++)
00320 if (x[i].assigned()) {
00321 int n = x[i].val();
00322 x.move_lst(i);
00323 for (int j=0; j<x.size(); j++)
00324 GECODE_ME_CHECK(x[j].eq(home,n));
00325 return home.ES_SUBSUMED(*this);
00326 }
00327 GECODE_NEVER;
00328 }
00329
00330 if (me == ME_INT_BND) {
00331 {
00332
00333 int mn = x[0].min();
00334 restart_min:
00335 for (int i=0; i<x.size(); i++) {
00336 GECODE_ME_CHECK(x[i].gq(home,mn));
00337 if (mn < x[i].min()) {
00338 mn = x[i].min();
00339 goto restart_min;
00340 }
00341 }
00342 }
00343 {
00344
00345 int mx = x[0].max();
00346 restart_max:
00347 for (int i=0; i<x.size(); i++) {
00348 GECODE_ME_CHECK(x[i].lq(home,mx));
00349 if (mx > x[i].max()) {
00350 mx = x[i].max();
00351 goto restart_max;
00352 }
00353 }
00354 }
00355 if (x[0].assigned())
00356 return home.ES_SUBSUMED(*this);
00357 return home.ES_FIX_PARTIAL(*this,View::med(ME_INT_DOM));
00358 }
00359
00360 int n = x.size();
00361
00362 Region re;
00363 ViewRanges<View>* i_x = re.alloc<ViewRanges<View> >(n);
00364 for (int i=0; i<n; i++) {
00365 ViewRanges<View> i_xi(x[i]);
00366 i_x[i] = i_xi;
00367 }
00368 Iter::Ranges::NaryInter r(re,i_x,n);
00369
00370 if (!r())
00371 return ES_FAILED;
00372 ++r;
00373 if (!r()) {
00374 r.reset();
00375 for (int i=0; i<n; i++) {
00376 GECODE_ME_CHECK(x[i].gq(home,r.min()));
00377 GECODE_ME_CHECK(x[i].lq(home,r.max()));
00378 }
00379 } else {
00380 for (int i=0; i<n; i++) {
00381 r.reset();
00382 GECODE_ME_CHECK(x[i].narrow_r(home,r,false));
00383 }
00384 }
00385 return ES_FIX;
00386 }
00387
00388
00389
00390
00391
00392
00393
00394
00395 template<class View>
00396 forceinline
00397 NaryEqBnd<View>::NaryEqBnd(Home home, ViewArray<View>& x)
00398 : NaryPropagator<View,PC_INT_BND>(home,x) {}
00399
00400 template<class View>
00401 ExecStatus
00402 NaryEqBnd<View>::post(Home home, ViewArray<View>& x) {
00403 x.unique();
00404 if (x.size() == 2) {
00405 return EqBnd<View,View>::post(home,x[0],x[1]);
00406 } else if (x.size() > 2) {
00407 int l = x[0].min();
00408 int u = x[0].max();
00409 for (int i=1; i<x.size(); i++) {
00410 l = std::max(l,x[i].min());
00411 u = std::min(u,x[i].max());
00412 }
00413 for (int i=0; i<x.size(); i++) {
00414 GECODE_ME_CHECK(x[i].gq(home,l));
00415 GECODE_ME_CHECK(x[i].lq(home,u));
00416 }
00417 (void) new (home) NaryEqBnd<View>(home,x);
00418 }
00419 return ES_OK;
00420 }
00421
00422 template<class View>
00423 forceinline
00424 NaryEqBnd<View>::NaryEqBnd(Space& home, NaryEqBnd<View>& p)
00425 : NaryPropagator<View,PC_INT_BND>(home,p) {}
00426
00427 template<class View>
00428 Actor*
00429 NaryEqBnd<View>::copy(Space& home) {
00430 return new (home) NaryEqBnd<View>(home,*this);
00431 }
00432
00433 template<class View>
00434 PropCost
00435 NaryEqBnd<View>::cost(const Space&, const ModEventDelta& med) const {
00436 if (View::me(med) == ME_INT_VAL)
00437 return PropCost::unary(PropCost::LO);
00438 else
00439 return PropCost::linear(PropCost::LO, x.size());
00440 }
00441
00442 template<class View>
00443 ExecStatus
00444 NaryEqBnd<View>::propagate(Space& home, const ModEventDelta& med) {
00445 assert(x.size() > 2);
00446 if (View::me(med) == ME_INT_VAL) {
00447
00448 for (int i = 0; ; i++)
00449 if (x[i].assigned()) {
00450 int n = x[i].val();
00451 x.move_lst(i);
00452 for (int j=0; j<x.size(); j++)
00453 GECODE_ME_CHECK(x[j].eq(home,n));
00454 return home.ES_SUBSUMED(*this);
00455 }
00456 GECODE_NEVER;
00457 }
00458
00459 int mn = x[0].min();
00460 restart_min:
00461 for (int i=0; i<x.size(); i++) {
00462 GECODE_ME_CHECK(x[i].gq(home,mn));
00463 if (mn < x[i].min()) {
00464 mn = x[i].min();
00465 goto restart_min;
00466 }
00467 }
00468 int mx = x[0].max();
00469 restart_max:
00470 for (int i=0; i<x.size(); i++) {
00471 GECODE_ME_CHECK(x[i].lq(home,mx));
00472 if (mx > x[i].max()) {
00473 mx = x[i].max();
00474 goto restart_max;
00475 }
00476 }
00477 return x[0].assigned() ? home.ES_SUBSUMED(*this) : ES_FIX;
00478 }
00479
00480
00481
00482
00483
00484
00485
00486
00487 template<class View, class CtrlView, ReifyMode rm>
00488 forceinline
00489 ReEqDom<View,CtrlView,rm>::ReEqDom(Home home, View x0, View x1, CtrlView b)
00490 : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,x0,x1,b) {}
00491
00492 template<class View, class CtrlView, ReifyMode rm>
00493 ExecStatus
00494 ReEqDom<View,CtrlView,rm>::post(Home home, View x0, View x1, CtrlView b) {
00495 if (b.one()) {
00496 if (rm == RM_PMI)
00497 return ES_OK;
00498 return EqDom<View,View>::post(home,x0,x1);
00499 }
00500 if (b.zero()) {
00501 if (rm == RM_IMP)
00502 return ES_OK;
00503 return Nq<View,View>::post(home,x0,x1);
00504 }
00505 if (x0 != x1) {
00506 (void) new (home) ReEqDom(home,x0,x1,b);
00507 } else if (rm != RM_IMP) {
00508 GECODE_ME_CHECK(b.one(home));
00509 }
00510 return ES_OK;
00511 }
00512
00513
00514 template<class View, class CtrlView, ReifyMode rm>
00515 forceinline
00516 ReEqDom<View,CtrlView,rm>::ReEqDom(Space& home, ReEqDom& p)
00517 : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,p) {}
00518
00519 template<class View, class CtrlView, ReifyMode rm>
00520 Actor*
00521 ReEqDom<View,CtrlView,rm>::copy(Space& home) {
00522 return new (home) ReEqDom<View,CtrlView,rm>(home,*this);
00523 }
00524
00525 template<class View, class CtrlView, ReifyMode rm>
00526 ExecStatus
00527 ReEqDom<View,CtrlView,rm>::propagate(Space& home, const ModEventDelta&) {
00528 if (b.one()) {
00529 if (rm == RM_PMI)
00530 return home.ES_SUBSUMED(*this);
00531 GECODE_REWRITE(*this,(EqDom<View,View>::post(home(*this),x0,x1)));
00532 }
00533 if (b.zero()) {
00534 if (rm == RM_IMP)
00535 return home.ES_SUBSUMED(*this);
00536 GECODE_REWRITE(*this,(Nq<View,View>::post(home(*this),x0,x1)));
00537 }
00538 switch (rtest_eq_dom(x0,x1)) {
00539 case RT_TRUE:
00540 if (rm != RM_IMP)
00541 GECODE_ME_CHECK(b.one_none(home));
00542 break;
00543 case RT_FALSE:
00544 if (rm != RM_PMI)
00545 GECODE_ME_CHECK(b.zero_none(home));
00546 break;
00547 case RT_MAYBE:
00548 return ES_FIX;
00549 default: GECODE_NEVER;
00550 }
00551 return home.ES_SUBSUMED(*this);
00552 }
00553
00554
00555
00556
00557
00558
00559
00560
00561 template<class View, class CtrlView, ReifyMode rm>
00562 forceinline
00563 ReEqBnd<View,CtrlView,rm>::ReEqBnd(Home home, View x0, View x1, CtrlView b)
00564 : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,x0,x1,b) {}
00565
00566 template<class View, class CtrlView, ReifyMode rm>
00567 ExecStatus
00568 ReEqBnd<View,CtrlView,rm>::post(Home home, View x0, View x1, CtrlView b){
00569 if (b.one()) {
00570 if (rm == RM_PMI)
00571 return ES_OK;
00572 return EqBnd<View,View>::post(home,x0,x1);
00573 }
00574 if (b.zero()) {
00575 if (rm == RM_IMP)
00576 return ES_OK;
00577 return Nq<View,View>::post(home,x0,x1);
00578 }
00579 if (x0 != x1) {
00580 (void) new (home) ReEqBnd(home,x0,x1,b);
00581 } else if (rm != RM_IMP) {
00582 GECODE_ME_CHECK(b.one(home));
00583 }
00584 return ES_OK;
00585 }
00586
00587
00588 template<class View, class CtrlView, ReifyMode rm>
00589 forceinline
00590 ReEqBnd<View,CtrlView,rm>::ReEqBnd(Space& home, ReEqBnd& p)
00591 : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,p) {}
00592
00593 template<class View, class CtrlView, ReifyMode rm>
00594 Actor*
00595 ReEqBnd<View,CtrlView,rm>::copy(Space& home) {
00596 return new (home) ReEqBnd<View,CtrlView,rm>(home,*this);
00597 }
00598
00599 template<class View, class CtrlView, ReifyMode rm>
00600 ExecStatus
00601 ReEqBnd<View,CtrlView,rm>::propagate(Space& home, const ModEventDelta&) {
00602 if (b.one()) {
00603 if (rm == RM_PMI)
00604 return home.ES_SUBSUMED(*this);
00605 GECODE_REWRITE(*this,(EqBnd<View,View>::post(home(*this),x0,x1)));
00606 }
00607 if (b.zero()) {
00608 if (rm == RM_IMP)
00609 return home.ES_SUBSUMED(*this);
00610 GECODE_REWRITE(*this,(Nq<View,View>::post(home(*this),x0,x1)));
00611 }
00612 switch (rtest_eq_bnd(x0,x1)) {
00613 case RT_TRUE:
00614 if (rm != RM_IMP)
00615 GECODE_ME_CHECK(b.one_none(home));
00616 break;
00617 case RT_FALSE:
00618 if (rm != RM_PMI)
00619 GECODE_ME_CHECK(b.zero_none(home));
00620 break;
00621 case RT_MAYBE:
00622 return ES_FIX;
00623 default: GECODE_NEVER;
00624 }
00625 return home.ES_SUBSUMED(*this);
00626 }
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636 template<class View, class CtrlView, ReifyMode rm>
00637 forceinline
00638 ReEqDomInt<View,CtrlView,rm>::ReEqDomInt
00639 (Home home, View x, int c0, CtrlView b)
00640 : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,x,b), c(c0) {}
00641
00642 template<class View, class CtrlView, ReifyMode rm>
00643 ExecStatus
00644 ReEqDomInt<View,CtrlView,rm>::post(Home home, View x, int c, CtrlView b) {
00645 if (b.one()) {
00646 if (rm != RM_PMI)
00647 GECODE_ME_CHECK(x.eq(home,c));
00648 } else if (b.zero()) {
00649 if (rm != RM_IMP)
00650 GECODE_ME_CHECK(x.nq(home,c));
00651 } else if (x.assigned()) {
00652 assert(b.none());
00653 if (x.val() == c) {
00654 if (rm != RM_IMP)
00655 GECODE_ME_CHECK(b.one_none(home));
00656 } else {
00657 if (rm != RM_PMI)
00658 GECODE_ME_CHECK(b.zero_none(home));
00659 }
00660 } else {
00661 (void) new (home) ReEqDomInt(home,x,c,b);
00662 }
00663 return ES_OK;
00664 }
00665
00666
00667 template<class View, class CtrlView, ReifyMode rm>
00668 forceinline
00669 ReEqDomInt<View,CtrlView,rm>::ReEqDomInt(Space& home, ReEqDomInt& p)
00670 : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,p), c(p.c) {}
00671
00672 template<class View, class CtrlView, ReifyMode rm>
00673 Actor*
00674 ReEqDomInt<View,CtrlView,rm>::copy(Space& home) {
00675 return new (home) ReEqDomInt<View,CtrlView,rm>(home,*this);
00676 }
00677
00678 template<class View, class CtrlView, ReifyMode rm>
00679 ExecStatus
00680 ReEqDomInt<View,CtrlView,rm>::propagate(Space& home, const ModEventDelta&) {
00681 if (b.one()) {
00682 if (rm != RM_PMI)
00683 GECODE_ME_CHECK(x0.eq(home,c));
00684 } else if (b.zero()) {
00685 if (rm != RM_IMP)
00686 GECODE_ME_CHECK(x0.nq(home,c));
00687 } else {
00688 switch (rtest_eq_dom(x0,c)) {
00689 case RT_TRUE:
00690 if (rm != RM_IMP)
00691 GECODE_ME_CHECK(b.one_none(home));
00692 break;
00693 case RT_FALSE:
00694 if (rm != RM_PMI)
00695 GECODE_ME_CHECK(b.zero_none(home));
00696 break;
00697 case RT_MAYBE:
00698 return ES_FIX;
00699 default: GECODE_NEVER;
00700 }
00701 }
00702 return home.ES_SUBSUMED(*this);
00703 }
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713 template<class View, class CtrlView, ReifyMode rm>
00714 forceinline
00715 ReEqBndInt<View,CtrlView,rm>::ReEqBndInt
00716 (Home home, View x, int c0, CtrlView b)
00717 : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,x,b), c(c0) {}
00718
00719 template<class View, class CtrlView, ReifyMode rm>
00720 ExecStatus
00721 ReEqBndInt<View,CtrlView,rm>::post(Home home, View x, int c, CtrlView b) {
00722 if (b.one()) {
00723 if (rm != RM_PMI)
00724 GECODE_ME_CHECK(x.eq(home,c));
00725 } else if (b.zero()) {
00726 if (rm != RM_IMP)
00727 GECODE_ME_CHECK(x.nq(home,c));
00728 } else if (x.assigned()) {
00729 assert(b.none());
00730 if (x.val() == c) {
00731 if (rm != RM_IMP)
00732 GECODE_ME_CHECK(b.one_none(home));
00733 } else {
00734 if (rm != RM_PMI)
00735 GECODE_ME_CHECK(b.zero_none(home));
00736 }
00737 } else {
00738 (void) new (home) ReEqBndInt(home,x,c,b);
00739 }
00740 return ES_OK;
00741 }
00742
00743
00744 template<class View, class CtrlView, ReifyMode rm>
00745 forceinline
00746 ReEqBndInt<View,CtrlView,rm>::ReEqBndInt(Space& home, ReEqBndInt& p)
00747 : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,p), c(p.c) {}
00748
00749 template<class View, class CtrlView, ReifyMode rm>
00750 Actor*
00751 ReEqBndInt<View,CtrlView,rm>::copy(Space& home) {
00752 return new (home) ReEqBndInt<View,CtrlView,rm>(home,*this);
00753 }
00754
00755 template<class View, class CtrlView, ReifyMode rm>
00756 ExecStatus
00757 ReEqBndInt<View,CtrlView,rm>::propagate(Space& home, const ModEventDelta&) {
00758 if (b.one()) {
00759 if (rm != RM_PMI)
00760 GECODE_ME_CHECK(x0.eq(home,c));
00761 } else if (b.zero()) {
00762 if (rm != RM_IMP)
00763 GECODE_ME_CHECK(x0.nq(home,c));
00764 } else {
00765 switch (rtest_eq_bnd(x0,c)) {
00766 case RT_TRUE:
00767 if (rm != RM_IMP)
00768 GECODE_ME_CHECK(b.one_none(home));
00769 break;
00770 case RT_FALSE:
00771 if (rm != RM_PMI)
00772 GECODE_ME_CHECK(b.zero_none(home));
00773 break;
00774 case RT_MAYBE:
00775 return ES_FIX;
00776 default: GECODE_NEVER;
00777 }
00778 }
00779 return home.ES_SUBSUMED(*this);
00780 }
00781
00782 }}}
00783
00784