rel.cpp

00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Christian Schulte <schulte@gecode.org>
00005  *
00006  *  Copyright:
00007  *     Christian Schulte, 2002
00008  *
00009  *  Last modified:
00010  *     $Date: 2016-11-08 17:23:24 +0100 (Tue, 08 Nov 2016) $ by $Author: schulte $
00011  *     $Revision: 15253 $
00012  *
00013  *  This file is part of Gecode, the generic constraint
00014  *  development environment:
00015  *     http://www.gecode.org
00016  *
00017  *  Permission is hereby granted, free of charge, to any person obtaining
00018  *  a copy of this software and associated documentation files (the
00019  *  "Software"), to deal in the Software without restriction, including
00020  *  without limitation the rights to use, copy, modify, merge, publish,
00021  *  distribute, sublicense, and/or sell copies of the Software, and to
00022  *  permit persons to whom the Software is furnished to do so, subject to
00023  *  the following conditions:
00024  *
00025  *  The above copyright notice and this permission notice shall be
00026  *  included in all copies or substantial portions of the Software.
00027  *
00028  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00029  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00030  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00031  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00032  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00033  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00034  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00035  *
00036  */
00037 
00038 #include <gecode/int/rel.hh>
00039 #include <gecode/int/bool.hh>
00040 
00041 #include <algorithm>
00042 
00043 namespace Gecode {
00044 
00045   void
00046   rel(Home home, IntVar x0, IntRelType irt, int n, IntPropLevel) {
00047     using namespace Int;
00048     Limits::check(n,"Int::rel");
00049     GECODE_POST;
00050     IntView x(x0);
00051     switch (irt) {
00052     case IRT_EQ: GECODE_ME_FAIL(x.eq(home,n)); break;
00053     case IRT_NQ: GECODE_ME_FAIL(x.nq(home,n)); break;
00054     case IRT_LQ: GECODE_ME_FAIL(x.lq(home,n)); break;
00055     case IRT_LE: GECODE_ME_FAIL(x.le(home,n)); break;
00056     case IRT_GQ: GECODE_ME_FAIL(x.gq(home,n)); break;
00057     case IRT_GR: GECODE_ME_FAIL(x.gr(home,n)); break;
00058     default: throw UnknownRelation("Int::rel");
00059     }
00060   }
00061 
00062   void
00063   rel(Home home, const IntVarArgs& x, IntRelType irt, int n, IntPropLevel) {
00064     using namespace Int;
00065     Limits::check(n,"Int::rel");
00066     GECODE_POST;
00067     switch (irt) {
00068     case IRT_EQ:
00069       for (int i=x.size(); i--; ) {
00070         IntView xi(x[i]); GECODE_ME_FAIL(xi.eq(home,n));
00071       }
00072       break;
00073     case IRT_NQ:
00074       for (int i=x.size(); i--; ) {
00075         IntView xi(x[i]); GECODE_ME_FAIL(xi.nq(home,n));
00076       }
00077       break;
00078     case IRT_LQ:
00079       for (int i=x.size(); i--; ) {
00080         IntView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,n));
00081       }
00082       break;
00083     case IRT_LE:
00084       for (int i=x.size(); i--; ) {
00085         IntView xi(x[i]); GECODE_ME_FAIL(xi.le(home,n));
00086       }
00087       break;
00088     case IRT_GQ:
00089       for (int i=x.size(); i--; ) {
00090         IntView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,n));
00091       }
00092       break;
00093     case IRT_GR:
00094       for (int i=x.size(); i--; ) {
00095         IntView xi(x[i]); GECODE_ME_FAIL(xi.gr(home,n));
00096       }
00097       break;
00098     default:
00099       throw UnknownRelation("Int::rel");
00100     }
00101   }
00102 
00103   void
00104   rel(Home home, IntVar x0, IntRelType irt, IntVar x1, IntPropLevel ipl) {
00105     using namespace Int;
00106     GECODE_POST;
00107     switch (irt) {
00108     case IRT_EQ:
00109       if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00110         GECODE_ES_FAIL((Rel::EqDom<IntView,IntView>::post(home,x0,x1)));
00111       } else {
00112         GECODE_ES_FAIL((Rel::EqBnd<IntView,IntView>::post(home,x0,x1)));
00113       }
00114       break;
00115     case IRT_NQ:
00116       GECODE_ES_FAIL((Rel::Nq<IntView,IntView>::post(home,x0,x1))); break;
00117     case IRT_GQ:
00118       std::swap(x0,x1); // Fall through
00119     case IRT_LQ:
00120       GECODE_ES_FAIL((Rel::Lq<IntView,IntView>::post(home,x0,x1))); break;
00121     case IRT_GR:
00122       std::swap(x0,x1); // Fall through
00123     case IRT_LE:
00124       GECODE_ES_FAIL((Rel::Le<IntView,IntView>::post(home,x0,x1))); break;
00125     default:
00126       throw UnknownRelation("Int::rel");
00127     }
00128   }
00129 
00130   void
00131   rel(Home home, const IntVarArgs& x, IntRelType irt, IntVar y,
00132       IntPropLevel ipl) {
00133     using namespace Int;
00134     GECODE_POST;
00135     switch (irt) {
00136     case IRT_EQ:
00137       {
00138         ViewArray<IntView> xv(home,x.size()+1);
00139         xv[x.size()]=y;
00140         for (int i=x.size(); i--; )
00141           xv[i]=x[i];
00142         if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00143           GECODE_ES_FAIL(Rel::NaryEqDom<IntView>::post(home,xv));
00144         } else {
00145           GECODE_ES_FAIL(Rel::NaryEqBnd<IntView>::post(home,xv));
00146         }
00147       }
00148       break;
00149     case IRT_NQ:
00150       for (int i=x.size(); i--; ) {
00151         GECODE_ES_FAIL((Rel::Nq<IntView,IntView>::post(home,x[i],y)));
00152       }
00153       break;
00154     case IRT_GQ:
00155       for (int i=x.size(); i--; ) {
00156         GECODE_ES_FAIL((Rel::Lq<IntView,IntView>::post(home,y,x[i])));
00157       }
00158       break;
00159     case IRT_LQ:
00160       for (int i=x.size(); i--; ) {
00161         GECODE_ES_FAIL((Rel::Lq<IntView,IntView>::post(home,x[i],y)));
00162       }
00163       break;
00164     case IRT_GR:
00165       for (int i=x.size(); i--; ) {
00166         GECODE_ES_FAIL((Rel::Le<IntView,IntView>::post(home,y,x[i])));
00167       }
00168       break;
00169     case IRT_LE:
00170       for (int i=x.size(); i--; ) {
00171         GECODE_ES_FAIL((Rel::Le<IntView,IntView>::post(home,x[i],y)));
00172       }
00173       break;
00174     default:
00175       throw UnknownRelation("Int::rel");
00176     }
00177   }
00178 
00179 
00180   void
00181   rel(Home home, IntVar x0, IntRelType irt, IntVar x1, Reify r,
00182       IntPropLevel ipl) {
00183     using namespace Int;
00184     GECODE_POST;
00185     switch (irt) {
00186     case IRT_EQ:
00187       if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00188         switch (r.mode()) {
00189         case RM_EQV:
00190           GECODE_ES_FAIL((Rel::ReEqDom<IntView,BoolView,RM_EQV>
00191                           ::post(home,x0,x1,r.var())));
00192           break;
00193         case RM_IMP:
00194           GECODE_ES_FAIL((Rel::ReEqDom<IntView,BoolView,RM_IMP>
00195                           ::post(home,x0,x1,r.var())));
00196           break;
00197         case RM_PMI:
00198           GECODE_ES_FAIL((Rel::ReEqDom<IntView,BoolView,RM_PMI>
00199                           ::post(home,x0,x1,r.var())));
00200           break;
00201         default: throw UnknownReifyMode("Int::rel");
00202         }
00203       } else {
00204         switch (r.mode()) {
00205         case RM_EQV:
00206           GECODE_ES_FAIL((Rel::ReEqBnd<IntView,BoolView,RM_EQV>
00207                           ::post(home,x0,x1,r.var())));
00208           break;
00209         case RM_IMP:
00210           GECODE_ES_FAIL((Rel::ReEqBnd<IntView,BoolView,RM_IMP>
00211                           ::post(home,x0,x1,r.var())));
00212           break;
00213         case RM_PMI:
00214           GECODE_ES_FAIL((Rel::ReEqBnd<IntView,BoolView,RM_PMI>
00215                           ::post(home,x0,x1,r.var())));
00216           break;
00217         default: throw UnknownReifyMode("Int::rel");
00218         }
00219       }
00220       break;
00221     case IRT_NQ:
00222       {
00223         NegBoolView n(r.var());
00224         if (vbd(ipl) == IPL_BND) {
00225           switch (r.mode()) {
00226           case RM_EQV:
00227             GECODE_ES_FAIL((Rel::ReEqBnd<IntView,NegBoolView,RM_EQV>
00228                             ::post(home,x0,x1,n)));
00229             break;
00230           case RM_IMP:
00231             GECODE_ES_FAIL((Rel::ReEqBnd<IntView,NegBoolView,RM_PMI>
00232                             ::post(home,x0,x1,n)));
00233             break;
00234           case RM_PMI:
00235             GECODE_ES_FAIL((Rel::ReEqBnd<IntView,NegBoolView,RM_IMP>
00236                             ::post(home,x0,x1,n)));
00237             break;
00238           default: throw UnknownReifyMode("Int::rel");
00239           }
00240         } else {
00241           switch (r.mode()) {
00242           case RM_EQV:
00243             GECODE_ES_FAIL((Rel::ReEqDom<IntView,NegBoolView,RM_EQV>
00244                             ::post(home,x0,x1,n)));
00245             break;
00246           case RM_IMP:
00247             GECODE_ES_FAIL((Rel::ReEqDom<IntView,NegBoolView,RM_PMI>
00248                             ::post(home,x0,x1,n)));
00249             break;
00250           case RM_PMI:
00251             GECODE_ES_FAIL((Rel::ReEqDom<IntView,NegBoolView,RM_IMP>
00252                             ::post(home,x0,x1,n)));
00253             break;
00254           default: throw UnknownReifyMode("Int::rel");
00255           }
00256         }
00257       }
00258       break;
00259     case IRT_GQ:
00260       std::swap(x0,x1); // Fall through
00261     case IRT_LQ:
00262       switch (r.mode()) {
00263       case RM_EQV:
00264         GECODE_ES_FAIL((Rel::ReLq<IntView,BoolView,RM_EQV>
00265                         ::post(home,x0,x1,r.var())));
00266         break;
00267       case RM_IMP:
00268         GECODE_ES_FAIL((Rel::ReLq<IntView,BoolView,RM_IMP>
00269                         ::post(home,x0,x1,r.var())));
00270         break;
00271       case RM_PMI:
00272         GECODE_ES_FAIL((Rel::ReLq<IntView,BoolView,RM_PMI>
00273                         ::post(home,x0,x1,r.var())));
00274         break;
00275       default: throw UnknownReifyMode("Int::rel");
00276       }
00277       break;
00278     case IRT_LE:
00279       std::swap(x0,x1); // Fall through
00280     case IRT_GR:
00281       {
00282         NegBoolView n(r.var());
00283         switch (r.mode()) {
00284         case RM_EQV:
00285           GECODE_ES_FAIL((Rel::ReLq<IntView,NegBoolView,RM_EQV>
00286                           ::post(home,x0,x1,n)));
00287           break;
00288         case RM_IMP:
00289           GECODE_ES_FAIL((Rel::ReLq<IntView,NegBoolView,RM_PMI>
00290                           ::post(home,x0,x1,n)));
00291           break;
00292         case RM_PMI:
00293           GECODE_ES_FAIL((Rel::ReLq<IntView,NegBoolView,RM_IMP>
00294                           ::post(home,x0,x1,n)));
00295           break;
00296         default: throw UnknownReifyMode("Int::rel");
00297         }
00298       }
00299       break;
00300     default:
00301       throw UnknownRelation("Int::rel");
00302     }
00303   }
00304 
00305   void
00306   rel(Home home, IntVar x, IntRelType irt, int n, Reify r,
00307       IntPropLevel ipl) {
00308     using namespace Int;
00309     Limits::check(n,"Int::rel");
00310     GECODE_POST;
00311     switch (irt) {
00312     case IRT_EQ:
00313       if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00314         switch (r.mode()) {
00315         case RM_EQV:
00316           GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,BoolView,RM_EQV>
00317                           ::post(home,x,n,r.var())));
00318           break;
00319         case RM_IMP:
00320           GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,BoolView,RM_IMP>
00321                           ::post(home,x,n,r.var())));
00322           break;
00323         case RM_PMI:
00324           GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,BoolView,RM_PMI>
00325                           ::post(home,x,n,r.var())));
00326           break;
00327         default: throw UnknownReifyMode("Int::rel");
00328         }
00329       } else {
00330         switch (r.mode()) {
00331         case RM_EQV:
00332           GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,BoolView,RM_EQV>
00333                           ::post(home,x,n,r.var())));
00334           break;
00335         case RM_IMP:
00336           GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,BoolView,RM_IMP>
00337                           ::post(home,x,n,r.var())));
00338           break;
00339         case RM_PMI:
00340           GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,BoolView,RM_PMI>
00341                           ::post(home,x,n,r.var())));
00342           break;
00343         default: throw UnknownReifyMode("Int::rel");
00344         }
00345       }
00346       break;
00347     case IRT_NQ:
00348       {
00349         NegBoolView nb(r.var());
00350         if (vbd(ipl) == IPL_BND) {
00351           switch (r.mode()) {
00352           case RM_EQV:
00353             GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,NegBoolView,RM_EQV>
00354                             ::post(home,x,n,nb)));
00355             break;
00356           case RM_IMP:
00357             GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,NegBoolView,RM_PMI>
00358                             ::post(home,x,n,nb)));
00359             break;
00360           case RM_PMI:
00361             GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,NegBoolView,RM_IMP>
00362                             ::post(home,x,n,nb)));
00363             break;
00364           default: throw UnknownReifyMode("Int::rel");
00365           }
00366         } else {
00367           switch (r.mode()) {
00368           case RM_EQV:
00369             GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,NegBoolView,RM_EQV>
00370                             ::post(home,x,n,nb)));
00371             break;
00372           case RM_IMP:
00373             GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,NegBoolView,RM_PMI>
00374                             ::post(home,x,n,nb)));
00375             break;
00376           case RM_PMI:
00377             GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,NegBoolView,RM_IMP>
00378                             ::post(home,x,n,nb)));
00379             break;
00380           default: throw UnknownReifyMode("Int::rel");
00381           }
00382         }
00383       }
00384       break;
00385     case IRT_LE:
00386       n--; // Fall through
00387     case IRT_LQ:
00388       switch (r.mode()) {
00389       case RM_EQV:
00390         GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_EQV>
00391                         ::post(home,x,n,r.var())));
00392         break;
00393       case RM_IMP:
00394         GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_IMP>
00395                         ::post(home,x,n,r.var())));
00396         break;
00397       case RM_PMI:
00398         GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView,RM_PMI>
00399                         ::post(home,x,n,r.var())));
00400         break;
00401       default: throw UnknownReifyMode("Int::rel");
00402       }
00403       break;
00404     case IRT_GQ:
00405       n--; // Fall through
00406     case IRT_GR:
00407       {
00408         NegBoolView nb(r.var());
00409         switch (r.mode()) {
00410         case RM_EQV:
00411           GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_EQV>
00412                           ::post(home,x,n,nb)));
00413           break;
00414         case RM_IMP:
00415           GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_PMI>
00416                           ::post(home,x,n,nb)));
00417           break;
00418         case RM_PMI:
00419           GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView,RM_IMP>
00420                           ::post(home,x,n,nb)));
00421           break;
00422         default: throw UnknownReifyMode("Int::rel");
00423         }
00424       }
00425       break;
00426     default:
00427       throw UnknownRelation("Int::rel");
00428     }
00429   }
00430 
00431   void
00432   rel(Home home, const IntVarArgs& x, IntRelType irt,
00433       IntPropLevel ipl) {
00434     using namespace Int;
00435     GECODE_POST;
00436     if ((irt != IRT_NQ) && (x.size() < 2))
00437       return;
00438     switch (irt) {
00439     case IRT_EQ:
00440       {
00441         ViewArray<IntView> xv(home,x);
00442         if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF)) {
00443           GECODE_ES_FAIL(Rel::NaryEqDom<IntView>::post(home,xv));
00444         } else {
00445           GECODE_ES_FAIL(Rel::NaryEqBnd<IntView>::post(home,xv));
00446         }
00447       }
00448       break;
00449     case IRT_NQ:
00450       {
00451         ViewArray<IntView> y(home,x);
00452         GECODE_ES_FAIL((Rel::NaryNq<IntView>::post(home,y)));
00453       }
00454       break;
00455     case IRT_LE:
00456       {
00457         ViewArray<IntView> y(home,x);
00458         GECODE_ES_FAIL((Rel::NaryLqLe<IntView,1>::post(home,y)));
00459       }
00460       break;
00461     case IRT_LQ:
00462       {
00463         ViewArray<IntView> y(home,x);
00464         GECODE_ES_FAIL((Rel::NaryLqLe<IntView,0>::post(home,y)));
00465       }
00466       break;
00467     case IRT_GR:
00468       {
00469         ViewArray<IntView> y(home,x.size());
00470         for (int i=x.size(); i--; )
00471           y[i] = x[x.size()-1-i];
00472         GECODE_ES_FAIL((Rel::NaryLqLe<IntView,1>::post(home,y)));
00473       }
00474       for (int i=x.size()-1; i--; )
00475         GECODE_ES_FAIL((Rel::Le<IntView,IntView>::post(home,x[i+1],x[i])));
00476       break;
00477     case IRT_GQ:
00478       {
00479         ViewArray<IntView> y(home,x.size());
00480         for (int i=x.size(); i--; )
00481           y[i] = x[x.size()-1-i];
00482         GECODE_ES_FAIL((Rel::NaryLqLe<IntView,0>::post(home,y)));
00483       }
00484       break;
00485     default:
00486       throw UnknownRelation("Int::rel");
00487     }
00488   }
00489 
00490   void
00491   rel(Home home, const IntVarArgs& x, IntRelType irt, const IntVarArgs& y,
00492       IntPropLevel ipl) {
00493     using namespace Int;
00494     GECODE_POST;
00495 
00496     switch (irt) {
00497     case IRT_GR:
00498       {
00499         ViewArray<IntView> xv(home,x), yv(home,y);
00500         GECODE_ES_FAIL((Rel::LexLqLe<IntView,IntView>
00501                         ::post(home,yv,xv,true)));
00502       }
00503       break;
00504     case IRT_LE:
00505       {
00506         ViewArray<IntView> xv(home,x), yv(home,y);
00507         GECODE_ES_FAIL((Rel::LexLqLe<IntView,IntView>
00508                         ::post(home,xv,yv,true)));
00509       }
00510       break;
00511     case IRT_GQ:
00512       {
00513         ViewArray<IntView> xv(home,x), yv(home,y);
00514         GECODE_ES_FAIL((Rel::LexLqLe<IntView,IntView>
00515                         ::post(home,yv,xv,false)));
00516       }
00517       break;
00518     case IRT_LQ:
00519       {
00520         ViewArray<IntView> xv(home,x), yv(home,y);
00521         GECODE_ES_FAIL((Rel::LexLqLe<IntView,IntView>
00522                         ::post(home,xv,yv,false)));
00523       }
00524       break;
00525     case IRT_EQ:
00526       if (x.size() != y.size()) {
00527         home.fail();
00528       } else if ((vbd(ipl) == IPL_DOM) || (vbd(ipl) == IPL_DEF))
00529         for (int i=x.size(); i--; ) {
00530           GECODE_ES_FAIL((Rel::EqDom<IntView,IntView>
00531                           ::post(home,x[i],y[i])));
00532         }
00533       else
00534         for (int i=x.size(); i--; ) {
00535           GECODE_ES_FAIL((Rel::EqBnd<IntView,IntView>
00536                           ::post(home,x[i],y[i])));
00537         }
00538       break;
00539     case IRT_NQ:
00540       {
00541         ViewArray<IntView> xv(home,x), yv(home,y);
00542         GECODE_ES_FAIL((Rel::LexNq<IntView,IntView>
00543                         ::post(home,xv,yv)));
00544       }
00545       break;
00546     default:
00547       throw UnknownRelation("Int::rel");
00548     }
00549   }
00550 
00551   namespace {
00552 
00554     ViewArray<Int::ConstIntView>
00555     viewarray(Space& home, const IntArgs& x) {
00556       ViewArray<Int::ConstIntView> xv(home, x.size());
00557       for (int i = x.size(); i--; ) {
00558         Int::Limits::check(x[i],"Int::rel");
00559         xv[i] = Int::ConstIntView(x[i]);
00560       }
00561       return xv;
00562     }
00563 
00564   }
00565 
00566   void
00567   rel(Home home, const IntVarArgs& x, IntRelType irt, const IntArgs& y,
00568       IntPropLevel) {
00569     using namespace Int;
00570     GECODE_POST;
00571 
00572     switch (irt) {
00573     case IRT_GR:
00574       {
00575         ViewArray<IntView> xv(home,x);
00576         ViewArray<ConstIntView> yv(viewarray(home,y));
00577         GECODE_ES_FAIL((Rel::LexLqLe<ConstIntView,IntView>
00578                         ::post(home,yv,xv,true)));
00579       }
00580       break;
00581     case IRT_LE:
00582       {
00583         ViewArray<IntView> xv(home,x);
00584         ViewArray<ConstIntView> yv(viewarray(home,y));
00585         GECODE_ES_FAIL((Rel::LexLqLe<IntView,ConstIntView>
00586                         ::post(home,xv,yv,true)));
00587       }
00588       break;
00589     case IRT_GQ:
00590       {
00591         ViewArray<IntView> xv(home,x);
00592         ViewArray<ConstIntView> yv(viewarray(home,y));
00593         GECODE_ES_FAIL((Rel::LexLqLe<ConstIntView,IntView>
00594                         ::post(home,yv,xv,false)));
00595       }
00596       break;
00597     case IRT_LQ:
00598       {
00599         ViewArray<IntView> xv(home,x);
00600         ViewArray<ConstIntView> yv(viewarray(home,y));
00601         GECODE_ES_FAIL((Rel::LexLqLe<IntView,ConstIntView>
00602                         ::post(home,xv,yv,false)));
00603       }
00604       break;
00605     case IRT_EQ:
00606       if (x.size() != y.size()) {
00607         home.fail();
00608       } else {
00609         for (int i=x.size(); i--; )
00610           GECODE_ME_FAIL(IntView(x[i]).eq(home,y[i]));
00611       }
00612       break;
00613     case IRT_NQ:
00614       {
00615         ViewArray<IntView> xv(home,x); 
00616         ViewArray<ConstIntView> yv(viewarray(home,y));
00617         GECODE_ES_FAIL((Rel::LexNq<IntView,ConstIntView>
00618                         ::post(home,xv,yv)));
00619       }
00620       break;
00621     default:
00622       throw UnknownRelation("Int::rel");
00623     }
00624   }
00625 
00626   void
00627   rel(Home home, const IntArgs& x, IntRelType irt, const IntVarArgs& y,
00628       IntPropLevel ipl) {
00629     rel(home,y,irt,x,ipl);
00630   }
00631 
00632 }
00633 
00634 // STATISTICS: int-post