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 <algorithm>
00039
00040 #include <gecode/int/rel.hh>
00041 #include <gecode/int/linear.hh>
00042 #include <gecode/int/div.hh>
00043
00044 namespace Gecode { namespace Int { namespace Linear {
00045
00047 forceinline void
00048 eliminate(Term<IntView>* t, int &n, long long int& d) {
00049 for (int i=n; i--; )
00050 if (t[i].x.assigned()) {
00051 long long int ax = t[i].a * static_cast<long long int>(t[i].x.val());
00052 if (Limits::overflow_sub(d,ax))
00053 throw OutOfLimits("Int::linear");
00054 d=d-ax; t[i]=t[--n];
00055 }
00056 }
00057
00059 forceinline void
00060 rewrite(IntRelType &irt, long long int &d,
00061 Term<IntView>* &t_p, int &n_p,
00062 Term<IntView>* &t_n, int &n_n) {
00063 switch (irt) {
00064 case IRT_EQ: case IRT_NQ: case IRT_LQ:
00065 break;
00066 case IRT_LE:
00067 d--; irt = IRT_LQ;
00068 break;
00069 case IRT_GR:
00070 d++;
00071
00072 case IRT_GQ:
00073 irt = IRT_LQ;
00074 std::swap(n_p,n_n); std::swap(t_p,t_n); d = -d;
00075 break;
00076 default:
00077 throw UnknownRelation("Int::linear");
00078 }
00079 }
00080
00082 forceinline bool
00083 precision(Term<IntView>* t_p, int n_p,
00084 Term<IntView>* t_n, int n_n,
00085 long long int d) {
00086 long long int sl = 0;
00087 long long int su = 0;
00088
00089 for (int i = n_p; i--; ) {
00090 long long int axmin =
00091 t_p[i].a * static_cast<long long int>(t_p[i].x.min());
00092 if (Limits::overflow_add(sl,axmin))
00093 throw OutOfLimits("Int::linear");
00094 sl = sl + axmin;
00095 long long int axmax =
00096 t_p[i].a * static_cast<long long int>(t_p[i].x.max());
00097 if (Limits::overflow_add(sl,axmax))
00098 throw OutOfLimits("Int::linear");
00099 su = su + axmax;
00100 }
00101 for (int i = n_n; i--; ) {
00102 long long int axmax =
00103 t_n[i].a * static_cast<long long int>(t_n[i].x.max());
00104 if (Limits::overflow_sub(sl,axmax))
00105 throw OutOfLimits("Int::linear");
00106 sl = sl - axmax;
00107 long long int axmin =
00108 t_n[i].a * static_cast<long long int>(t_n[i].x.min());
00109 if (Limits::overflow_sub(su,axmin))
00110 throw OutOfLimits("Int::linear");
00111 su = su - axmin;
00112 }
00113
00114 bool is_ip = (sl >= Limits::min) && (su <= Limits::max);
00115
00116 if (Limits::overflow_sub(sl,d))
00117 throw OutOfLimits("Int::linear");
00118 sl = sl - d;
00119 if (Limits::overflow_sub(su,d))
00120 throw OutOfLimits("Int::linear");
00121 su = su - d;
00122
00123 is_ip = is_ip && (sl >= Limits::min) && (su <= Limits::max);
00124
00125 for (int i = n_p; i--; ) {
00126 long long int axmin =
00127 t_p[i].a * static_cast<long long int>(t_p[i].x.min());
00128 if (Limits::overflow_sub(sl,axmin))
00129 throw OutOfLimits("Int::linear");
00130 if (sl - axmin < Limits::min)
00131 is_ip = false;
00132 long long int axmax =
00133 t_p[i].a * static_cast<long long int>(t_p[i].x.max());
00134 if (Limits::overflow_sub(su,axmax))
00135 throw OutOfLimits("Int::linear");
00136 if (su - axmax > Limits::max)
00137 is_ip = false;
00138 }
00139 for (int i = n_n; i--; ) {
00140 long long int axmin =
00141 t_n[i].a * static_cast<long long int>(t_n[i].x.min());
00142 if (Limits::overflow_add(sl,axmin))
00143 throw OutOfLimits("Int::linear");
00144 if (sl + axmin < Limits::min)
00145 is_ip = false;
00146 long long int axmax =
00147 t_n[i].a * static_cast<long long int>(t_n[i].x.max());
00148 if (Limits::overflow_add(su,axmax))
00149 throw OutOfLimits("Int::linear");
00150 if (su + axmax > Limits::max)
00151 is_ip = false;
00152 }
00153 return is_ip;
00154 }
00155
00160 template<class Val, class View>
00161 forceinline void
00162 post_nary(Home home,
00163 ViewArray<View>& x, ViewArray<View>& y, IntRelType irt, Val c) {
00164 switch (irt) {
00165 case IRT_EQ:
00166 GECODE_ES_FAIL((Eq<Val,View,View >::post(home,x,y,c)));
00167 break;
00168 case IRT_NQ:
00169 GECODE_ES_FAIL((Nq<Val,View,View >::post(home,x,y,c)));
00170 break;
00171 case IRT_LQ:
00172 GECODE_ES_FAIL((Lq<Val,View,View >::post(home,x,y,c)));
00173 break;
00174 default: GECODE_NEVER;
00175 }
00176 }
00177
00178
00180 #define GECODE_INT_PL_BIN(CLASS) \
00181 switch (n_p) { \
00182 case 2: \
00183 GECODE_ES_FAIL((CLASS<int,IntView,IntView>::post \
00184 (home,t_p[0].x,t_p[1].x,c))); \
00185 break; \
00186 case 1: \
00187 GECODE_ES_FAIL((CLASS<int,IntView,MinusView>::post \
00188 (home,t_p[0].x,MinusView(t_n[0].x),c))); \
00189 break; \
00190 case 0: \
00191 GECODE_ES_FAIL((CLASS<int,MinusView,MinusView>::post \
00192 (home,MinusView(t_n[0].x),MinusView(t_n[1].x),c))); \
00193 break; \
00194 default: GECODE_NEVER; \
00195 }
00196
00198 #define GECODE_INT_PL_TER(CLASS) \
00199 switch (n_p) { \
00200 case 3: \
00201 GECODE_ES_FAIL((CLASS<int,IntView,IntView,IntView>::post \
00202 (home,t_p[0].x,t_p[1].x,t_p[2].x,c))); \
00203 break; \
00204 case 2: \
00205 GECODE_ES_FAIL((CLASS<int,IntView,IntView,MinusView>::post \
00206 (home,t_p[0].x,t_p[1].x, \
00207 MinusView(t_n[0].x),c))); \
00208 break; \
00209 case 1: \
00210 GECODE_ES_FAIL((CLASS<int,IntView,MinusView,MinusView>::post \
00211 (home,t_p[0].x, \
00212 MinusView(t_n[0].x),MinusView(t_n[1].x),c))); \
00213 break; \
00214 case 0: \
00215 GECODE_ES_FAIL((CLASS<int,MinusView,MinusView,MinusView>::post \
00216 (home,MinusView(t_n[0].x), \
00217 MinusView(t_n[1].x),MinusView(t_n[2].x),c))); \
00218 break; \
00219 default: GECODE_NEVER; \
00220 }
00221
00222 void
00223 post(Home home, Term<IntView>* t, int n, IntRelType irt, int c,
00224 IntPropLevel ipl) {
00225
00226 Limits::check(c,"Int::linear");
00227
00228 long long int d = c;
00229
00230 eliminate(t,n,d);
00231
00232 Term<IntView> *t_p, *t_n;
00233 int n_p, n_n, gcd=1;
00234 bool is_unit = normalize<IntView>(t,n,t_p,n_p,t_n,n_n,gcd);
00235
00236 rewrite(irt,d,t_p,n_p,t_n,n_n);
00237
00238
00239 if (gcd > 1) {
00240 switch (irt) {
00241 case IRT_EQ:
00242 if ((d % gcd) != 0) {
00243 home.fail();
00244 return;
00245 }
00246 d /= gcd;
00247 break;
00248 case IRT_NQ:
00249 if ((d % gcd) != 0)
00250 return;
00251 d /= gcd;
00252 break;
00253 case IRT_LQ:
00254 d = floor_div_xp(d,static_cast<long long int>(gcd));
00255 break;
00256 default: GECODE_NEVER;
00257 }
00258 }
00259
00260 if (n == 0) {
00261 switch (irt) {
00262 case IRT_EQ: if (d != 0) home.fail(); break;
00263 case IRT_NQ: if (d == 0) home.fail(); break;
00264 case IRT_LQ: if (d < 0) home.fail(); break;
00265 default: GECODE_NEVER;
00266 }
00267 return;
00268 }
00269
00270 if (n == 1) {
00271 if (n_p == 1) {
00272 LLongScaleView y(t_p[0].a,t_p[0].x);
00273 switch (irt) {
00274 case IRT_EQ: GECODE_ME_FAIL(y.eq(home,d)); break;
00275 case IRT_NQ: GECODE_ME_FAIL(y.nq(home,d)); break;
00276 case IRT_LQ: GECODE_ME_FAIL(y.lq(home,d)); break;
00277 default: GECODE_NEVER;
00278 }
00279 } else {
00280 LLongScaleView y(t_n[0].a,t_n[0].x);
00281 switch (irt) {
00282 case IRT_EQ: GECODE_ME_FAIL(y.eq(home,-d)); break;
00283 case IRT_NQ: GECODE_ME_FAIL(y.nq(home,-d)); break;
00284 case IRT_LQ: GECODE_ME_FAIL(y.gq(home,-d)); break;
00285 default: GECODE_NEVER;
00286 }
00287 }
00288 return;
00289 }
00290
00291 bool is_ip = precision(t_p,n_p,t_n,n_n,d);
00292
00293 if (is_unit && is_ip &&
00294 (vbd(ipl) != IPL_DOM) && (vbd(ipl) != IPL_DEF)) {
00295
00296 c = static_cast<int>(d);
00297 if (n == 2) {
00298 switch (irt) {
00299 case IRT_EQ: GECODE_INT_PL_BIN(EqBin); break;
00300 case IRT_NQ: GECODE_INT_PL_BIN(NqBin); break;
00301 case IRT_LQ: GECODE_INT_PL_BIN(LqBin); break;
00302 default: GECODE_NEVER;
00303 }
00304 } else if (n == 3) {
00305 switch (irt) {
00306 case IRT_EQ: GECODE_INT_PL_TER(EqTer); break;
00307 case IRT_NQ: GECODE_INT_PL_TER(NqTer); break;
00308 case IRT_LQ: GECODE_INT_PL_TER(LqTer); break;
00309 default: GECODE_NEVER;
00310 }
00311 } else {
00312 ViewArray<IntView> x(home,n_p);
00313 for (int i = n_p; i--; )
00314 x[i] = t_p[i].x;
00315 ViewArray<IntView> y(home,n_n);
00316 for (int i = n_n; i--; )
00317 y[i] = t_n[i].x;
00318 post_nary<int,IntView>(home,x,y,irt,c);
00319 }
00320 } else if (is_ip) {
00321 if ((n==2) && is_unit &&
00322 ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) &&
00323 (irt == IRT_EQ)) {
00324
00325 c = static_cast<int>(d);
00326 if (c == 0) {
00327 switch (n_p) {
00328 case 2: {
00329 IntView x(t_p[0].x);
00330 MinusView y(t_p[1].x);
00331 GECODE_ES_FAIL(
00332 (Rel::EqDom<IntView,MinusView>::post(home,x,y)));
00333 break;
00334 }
00335 case 1: {
00336 IntView x(t_p[0].x);
00337 IntView y(t_n[0].x);
00338 GECODE_ES_FAIL(
00339 (Rel::EqDom<IntView,IntView>::post(home,x,y)));
00340 break;
00341 }
00342 case 0: {
00343 IntView x(t_n[0].x);
00344 MinusView y(t_n[1].x);
00345 GECODE_ES_FAIL(
00346 (Rel::EqDom<IntView,MinusView>::post(home,x,y)));
00347 break;
00348 }
00349 default:
00350 GECODE_NEVER;
00351 }
00352 } else {
00353 switch (n_p) {
00354 case 2: {
00355 MinusView x(t_p[0].x);
00356 OffsetView y(t_p[1].x, -c);
00357 GECODE_ES_FAIL(
00358 (Rel::EqDom<MinusView,OffsetView>::post(home,x,y)));
00359 break;
00360 }
00361 case 1: {
00362 IntView x(t_p[0].x);
00363 OffsetView y(t_n[0].x, c);
00364 GECODE_ES_FAIL(
00365 (Rel::EqDom<IntView,OffsetView>::post(home,x,y)));
00366 break;
00367 }
00368 case 0: {
00369 MinusView x(t_n[0].x);
00370 OffsetView y(t_n[1].x, c);
00371 GECODE_ES_FAIL(
00372 (Rel::EqDom<MinusView,OffsetView>::post(home,x,y)));
00373 break;
00374 }
00375 default:
00376 GECODE_NEVER;
00377 }
00378 }
00379 } else {
00380
00381 c = static_cast<int>(d);
00382 ViewArray<IntScaleView> x(home,n_p);
00383 for (int i = n_p; i--; )
00384 x[i] = IntScaleView(t_p[i].a,t_p[i].x);
00385 ViewArray<IntScaleView> y(home,n_n);
00386 for (int i = n_n; i--; )
00387 y[i] = IntScaleView(t_n[i].a,t_n[i].x);
00388 if ((vbd(ipl) == IPL_DOM) && (irt == IRT_EQ)) {
00389 GECODE_ES_FAIL((DomEq<int,IntScaleView>::post(home,x,y,c)));
00390 } else {
00391 post_nary<int,IntScaleView>(home,x,y,irt,c);
00392 }
00393 }
00394 } else {
00395
00396 ViewArray<LLongScaleView> x(home,n_p);
00397 for (int i = n_p; i--; )
00398 x[i] = LLongScaleView(t_p[i].a,t_p[i].x);
00399 ViewArray<LLongScaleView> y(home,n_n);
00400 for (int i = n_n; i--; )
00401 y[i] = LLongScaleView(t_n[i].a,t_n[i].x);
00402 if ((vbd(ipl) == IPL_DOM) && (irt == IRT_EQ)) {
00403 GECODE_ES_FAIL((DomEq<long long int,LLongScaleView>
00404 ::post(home,x,y,d)));
00405 } else {
00406 post_nary<long long int,LLongScaleView>(home,x,y,irt,d);
00407 }
00408 }
00409 }
00410
00411 #undef GECODE_INT_PL_BIN
00412 #undef GECODE_INT_PL_TER
00413
00414
00419 template<class Val, class View>
00420 forceinline void
00421 post_nary(Home home,
00422 ViewArray<View>& x, ViewArray<View>& y,
00423 IntRelType irt, Val c, Reify r) {
00424 switch (irt) {
00425 case IRT_EQ:
00426 switch (r.mode()) {
00427 case RM_EQV:
00428 GECODE_ES_FAIL((ReEq<Val,View,View,BoolView,RM_EQV>::
00429 post(home,x,y,c,r.var())));
00430 break;
00431 case RM_IMP:
00432 GECODE_ES_FAIL((ReEq<Val,View,View,BoolView,RM_IMP>::
00433 post(home,x,y,c,r.var())));
00434 break;
00435 case RM_PMI:
00436 GECODE_ES_FAIL((ReEq<Val,View,View,BoolView,RM_PMI>::
00437 post(home,x,y,c,r.var())));
00438 break;
00439 default: GECODE_NEVER;
00440 }
00441 break;
00442 case IRT_NQ:
00443 {
00444 NegBoolView n(r.var());
00445 switch (r.mode()) {
00446 case RM_EQV:
00447 GECODE_ES_FAIL((ReEq<Val,View,View,NegBoolView,RM_EQV>::
00448 post(home,x,y,c,n)));
00449 break;
00450 case RM_IMP:
00451 GECODE_ES_FAIL((ReEq<Val,View,View,NegBoolView,RM_PMI>::
00452 post(home,x,y,c,n)));
00453 break;
00454 case RM_PMI:
00455 GECODE_ES_FAIL((ReEq<Val,View,View,NegBoolView,RM_IMP>::
00456 post(home,x,y,c,n)));
00457 break;
00458 default: GECODE_NEVER;
00459 }
00460 }
00461 break;
00462 case IRT_LQ:
00463 switch (r.mode()) {
00464 case RM_EQV:
00465 GECODE_ES_FAIL((ReLq<Val,View,View,RM_EQV>::
00466 post(home,x,y,c,r.var())));
00467 break;
00468 case RM_IMP:
00469 GECODE_ES_FAIL((ReLq<Val,View,View,RM_IMP>::
00470 post(home,x,y,c,r.var())));
00471 break;
00472 case RM_PMI:
00473 GECODE_ES_FAIL((ReLq<Val,View,View,RM_PMI>::
00474 post(home,x,y,c,r.var())));
00475 break;
00476 default: GECODE_NEVER;
00477 }
00478 break;
00479 default: GECODE_NEVER;
00480 }
00481 }
00482
00483 template<class CtrlView>
00484 forceinline void
00485 posteqint(Home home, IntView& x, int c, CtrlView b, ReifyMode rm,
00486 IntPropLevel ipl) {
00487 if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00488 switch (rm) {
00489 case RM_EQV:
00490 GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,CtrlView,RM_EQV>::
00491 post(home,x,c,b)));
00492 break;
00493 case RM_IMP:
00494 GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,CtrlView,RM_IMP>::
00495 post(home,x,c,b)));
00496 break;
00497 case RM_PMI:
00498 GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,CtrlView,RM_PMI>::
00499 post(home,x,c,b)));
00500 break;
00501 default: GECODE_NEVER;
00502 }
00503 } else {
00504 switch (rm) {
00505 case RM_EQV:
00506 GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,CtrlView,RM_EQV>::
00507 post(home,x,c,b)));
00508 break;
00509 case RM_IMP:
00510 GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,CtrlView,RM_IMP>::
00511 post(home,x,c,b)));
00512 break;
00513 case RM_PMI:
00514 GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,CtrlView,RM_PMI>::
00515 post(home,x,c,b)));
00516 break;
00517 default: GECODE_NEVER;
00518 }
00519 }
00520 }
00521
00522 void
00523 post(Home home,
00524 Term<IntView>* t, int n, IntRelType irt, int c, Reify r,
00525 IntPropLevel ipl) {
00526 Limits::check(c,"Int::linear");
00527 long long int d = c;
00528
00529 eliminate(t,n,d);
00530
00531 Term<IntView> *t_p, *t_n;
00532 int n_p, n_n, gcd=1;
00533 bool is_unit = normalize<IntView>(t,n,t_p,n_p,t_n,n_n,gcd);
00534
00535 rewrite(irt,d,t_p,n_p,t_n,n_n);
00536
00537
00538 if (gcd > 1) {
00539 switch (irt) {
00540 case IRT_EQ:
00541 if ((d % gcd) != 0) {
00542 if (r.mode() != RM_PMI)
00543 GECODE_ME_FAIL(BoolView(r.var()).zero(home));
00544 return;
00545 }
00546 d /= gcd;
00547 break;
00548 case IRT_NQ:
00549 if ((d % gcd) != 0) {
00550 if (r.mode() != RM_IMP)
00551 GECODE_ME_FAIL(BoolView(r.var()).one(home));
00552 return;
00553 }
00554 d /= gcd;
00555 break;
00556 case IRT_LQ:
00557 d = floor_div_xp(d,static_cast<long long int>(gcd));
00558 break;
00559 default: GECODE_NEVER;
00560 }
00561 }
00562
00563 if (n == 0) {
00564 bool fail = false;
00565 switch (irt) {
00566 case IRT_EQ: fail = (d != 0); break;
00567 case IRT_NQ: fail = (d == 0); break;
00568 case IRT_LQ: fail = (0 > d); break;
00569 default: GECODE_NEVER;
00570 }
00571 if (fail) {
00572 if (r.mode() != RM_PMI)
00573 GECODE_ME_FAIL(BoolView(r.var()).zero(home));
00574 } else {
00575 if (r.mode() != RM_IMP)
00576 GECODE_ME_FAIL(BoolView(r.var()).one(home));
00577 }
00578 return;
00579 }
00580
00581 bool is_ip = precision(t_p,n_p,t_n,n_n,d);
00582
00583 if (is_unit && is_ip) {
00584 c = static_cast<int>(d);
00585 if (n == 1) {
00586 switch (irt) {
00587 case IRT_EQ:
00588 if (n_p == 1) {
00589 posteqint<BoolView>(home,t_p[0].x,c,r.var(),r.mode(),ipl);
00590 } else {
00591 posteqint<BoolView>(home,t_p[0].x,-c,r.var(),r.mode(),ipl);
00592 }
00593 break;
00594 case IRT_NQ:
00595 {
00596 NegBoolView nb(r.var());
00597 ReifyMode rm = r.mode();
00598 switch (rm) {
00599 case RM_IMP: rm = RM_PMI; break;
00600 case RM_PMI: rm = RM_IMP; break;
00601 default: ;
00602 }
00603 if (n_p == 1) {
00604 posteqint<NegBoolView>(home,t_p[0].x,c,nb,rm,ipl);
00605 } else {
00606 posteqint<NegBoolView>(home,t_p[0].x,-c,nb,rm,ipl);
00607 }
00608 }
00609 break;
00610 case IRT_LQ:
00611 if (n_p == 1) {
00612 switch (r.mode()) {
00613 case RM_EQV:
00614 GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_EQV>::
00615 post(home,t_p[0].x,c,r.var())));
00616 break;
00617 case RM_IMP:
00618 GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_IMP>::
00619 post(home,t_p[0].x,c,r.var())));
00620 break;
00621 case RM_PMI:
00622 GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_PMI>::
00623 post(home,t_p[0].x,c,r.var())));
00624 break;
00625 default: GECODE_NEVER;
00626 }
00627 } else {
00628 NegBoolView nb(r.var());
00629 switch (r.mode()) {
00630 case RM_EQV:
00631 GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_EQV>::
00632 post(home,t_n[0].x,-c-1,nb)));
00633 break;
00634 case RM_IMP:
00635 GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_PMI>::
00636 post(home,t_n[0].x,-c-1,nb)));
00637 break;
00638 case RM_PMI:
00639 GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_IMP>::
00640 post(home,t_n[0].x,-c-1,nb)));
00641 break;
00642 default: GECODE_NEVER;
00643 }
00644 }
00645 break;
00646 default: GECODE_NEVER;
00647 }
00648 } else if (n == 2) {
00649 switch (irt) {
00650 case IRT_EQ:
00651 switch (n_p) {
00652 case 2:
00653 switch (r.mode()) {
00654 case RM_EQV:
00655 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_EQV>::
00656 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00657 break;
00658 case RM_IMP:
00659 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_IMP>::
00660 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00661 break;
00662 case RM_PMI:
00663 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_PMI>::
00664 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00665 break;
00666 default: GECODE_NEVER;
00667 }
00668 break;
00669 case 1:
00670 switch (r.mode()) {
00671 case RM_EQV:
00672 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,BoolView,RM_EQV>::
00673 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00674 r.var())));
00675 break;
00676 case RM_IMP:
00677 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,BoolView,RM_IMP>::
00678 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00679 r.var())));
00680 break;
00681 case RM_PMI:
00682 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,BoolView,RM_PMI>::
00683 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00684 r.var())));
00685 break;
00686 default: GECODE_NEVER;
00687 }
00688 break;
00689 case 0:
00690 switch (r.mode()) {
00691 case RM_EQV:
00692 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_EQV>::
00693 post(home,t_n[0].x,t_n[1].x,-c,r.var())));
00694 break;
00695 case RM_IMP:
00696 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_IMP>::
00697 post(home,t_n[0].x,t_n[1].x,-c,r.var())));
00698 break;
00699 case RM_PMI:
00700 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,BoolView,RM_PMI>::
00701 post(home,t_n[0].x,t_n[1].x,-c,r.var())));
00702 break;
00703 default: GECODE_NEVER;
00704 }
00705 break;
00706 default: GECODE_NEVER;
00707 }
00708 break;
00709 case IRT_NQ:
00710 {
00711 NegBoolView nb(r.var());
00712 switch (n_p) {
00713 case 2:
00714 switch (r.mode()) {
00715 case RM_EQV:
00716 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_EQV>::
00717 post(home,t_p[0].x,t_p[1].x,c,nb)));
00718 break;
00719 case RM_IMP:
00720 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_PMI>::
00721 post(home,t_p[0].x,t_p[1].x,c,nb)));
00722 break;
00723 case RM_PMI:
00724 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_IMP>::
00725 post(home,t_p[0].x,t_p[1].x,c,nb)));
00726 break;
00727 default: GECODE_NEVER;
00728 }
00729 break;
00730 case 1:
00731 switch (r.mode()) {
00732 case RM_EQV:
00733 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,NegBoolView,RM_EQV>::
00734 post(home,t_p[0].x,MinusView(t_n[0].x),c,nb)));
00735 break;
00736 case RM_IMP:
00737 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,NegBoolView,RM_PMI>::
00738 post(home,t_p[0].x,MinusView(t_n[0].x),c,nb)));
00739 break;
00740 case RM_PMI:
00741 GECODE_ES_FAIL((ReEqBin<int,IntView,MinusView,NegBoolView,RM_IMP>::
00742 post(home,t_p[0].x,MinusView(t_n[0].x),c,nb)));
00743 break;
00744 default: GECODE_NEVER;
00745 }
00746 break;
00747 case 0:
00748 switch (r.mode()) {
00749 case RM_EQV:
00750 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_EQV>::
00751 post(home,t_p[0].x,t_p[1].x,-c,nb)));
00752 break;
00753 case RM_IMP:
00754 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_PMI>::
00755 post(home,t_p[0].x,t_p[1].x,-c,nb)));
00756 break;
00757 case RM_PMI:
00758 GECODE_ES_FAIL((ReEqBin<int,IntView,IntView,NegBoolView,RM_IMP>::
00759 post(home,t_p[0].x,t_p[1].x,-c,nb)));
00760 break;
00761 default: GECODE_NEVER;
00762 }
00763 break;
00764 default: GECODE_NEVER;
00765 }
00766 }
00767 break;
00768 case IRT_LQ:
00769 switch (n_p) {
00770 case 2:
00771 switch (r.mode()) {
00772 case RM_EQV:
00773 GECODE_ES_FAIL((ReLqBin<int,IntView,IntView,RM_EQV>::
00774 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00775 break;
00776 case RM_IMP:
00777 GECODE_ES_FAIL((ReLqBin<int,IntView,IntView,RM_IMP>::
00778 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00779 break;
00780 case RM_PMI:
00781 GECODE_ES_FAIL((ReLqBin<int,IntView,IntView,RM_PMI>::
00782 post(home,t_p[0].x,t_p[1].x,c,r.var())));
00783 break;
00784 default: GECODE_NEVER;
00785 }
00786 break;
00787 case 1:
00788 switch (r.mode()) {
00789 case RM_EQV:
00790 GECODE_ES_FAIL((ReLqBin<int,IntView,MinusView,RM_EQV>::
00791 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00792 r.var())));
00793 break;
00794 case RM_IMP:
00795 GECODE_ES_FAIL((ReLqBin<int,IntView,MinusView,RM_IMP>::
00796 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00797 r.var())));
00798 break;
00799 case RM_PMI:
00800 GECODE_ES_FAIL((ReLqBin<int,IntView,MinusView,RM_PMI>::
00801 post(home,t_p[0].x,MinusView(t_n[0].x),c,
00802 r.var())));
00803 break;
00804 default: GECODE_NEVER;
00805 }
00806 break;
00807 case 0:
00808 switch (r.mode()) {
00809 case RM_EQV:
00810 GECODE_ES_FAIL((ReLqBin<int,MinusView,MinusView,RM_EQV>::
00811 post(home,MinusView(t_n[0].x),
00812 MinusView(t_n[1].x),c,r.var())));
00813 break;
00814 case RM_IMP:
00815 GECODE_ES_FAIL((ReLqBin<int,MinusView,MinusView,RM_IMP>::
00816 post(home,MinusView(t_n[0].x),
00817 MinusView(t_n[1].x),c,r.var())));
00818 break;
00819 case RM_PMI:
00820 GECODE_ES_FAIL((ReLqBin<int,MinusView,MinusView,RM_PMI>::
00821 post(home,MinusView(t_n[0].x),
00822 MinusView(t_n[1].x),c,r.var())));
00823 break;
00824 default: GECODE_NEVER;
00825 }
00826 break;
00827 default: GECODE_NEVER;
00828 }
00829 break;
00830 default: GECODE_NEVER;
00831 }
00832 } else {
00833 ViewArray<IntView> x(home,n_p);
00834 for (int i = n_p; i--; )
00835 x[i] = t_p[i].x;
00836 ViewArray<IntView> y(home,n_n);
00837 for (int i = n_n; i--; )
00838 y[i] = t_n[i].x;
00839 post_nary<int,IntView>(home,x,y,irt,c,r);
00840 }
00841 } else if (is_ip) {
00842
00843 c = static_cast<int>(d);
00844 ViewArray<IntScaleView> x(home,n_p);
00845 for (int i = n_p; i--; )
00846 x[i] = IntScaleView(t_p[i].a,t_p[i].x);
00847 ViewArray<IntScaleView> y(home,n_n);
00848 for (int i = n_n; i--; )
00849 y[i] = IntScaleView(t_n[i].a,t_n[i].x);
00850 post_nary<int,IntScaleView>(home,x,y,irt,c,r);
00851 } else {
00852
00853 ViewArray<LLongScaleView> x(home,n_p);
00854 for (int i = n_p; i--; )
00855 x[i] = LLongScaleView(t_p[i].a,t_p[i].x);
00856 ViewArray<LLongScaleView> y(home,n_n);
00857 for (int i = n_n; i--; )
00858 y[i] = LLongScaleView(t_n[i].a,t_n[i].x);
00859 post_nary<long long int,LLongScaleView>(home,x,y,irt,d,r);
00860 }
00861 }
00862
00863 }}}
00864
00865
