Generated on Mon Nov 30 23:53:29 2009 for Gecode by doxygen 1.6.1

rel.cpp

Go to the documentation of this file.
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: 2009-10-12 17:36:53 +0200 (Mon, 12 Oct 2009) $ by $Author: schulte $
00011  *     $Revision: 9878 $
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   using namespace Int;
00046 
00047   void
00048   rel(Home home, IntVar x0, IntRelType r, int n, IntConLevel) {
00049     Limits::check(n,"Int::rel");
00050     if (home.failed()) return;
00051     IntView x(x0);
00052     switch (r) {
00053     case IRT_EQ: GECODE_ME_FAIL(home,x.eq(home,n)); break;
00054     case IRT_NQ: GECODE_ME_FAIL(home,x.nq(home,n)); break;
00055     case IRT_LQ: GECODE_ME_FAIL(home,x.lq(home,n)); break;
00056     case IRT_LE: GECODE_ME_FAIL(home,x.le(home,n)); break;
00057     case IRT_GQ: GECODE_ME_FAIL(home,x.gq(home,n)); break;
00058     case IRT_GR: GECODE_ME_FAIL(home,x.gr(home,n)); break;
00059     default: throw UnknownRelation("Int::rel");
00060     }
00061   }
00062 
00063   void
00064   rel(Home home, const IntVarArgs& x, IntRelType r, int n, IntConLevel) {
00065     Limits::check(n,"Int::rel");
00066     if (home.failed()) return;
00067     switch (r) {
00068     case IRT_EQ:
00069       for (int i=x.size(); i--; ) {
00070         IntView xi(x[i]); GECODE_ME_FAIL(home,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(home,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(home,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(home,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(home,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(home,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 r, IntVar x1, IntConLevel icl) {
00105     if (home.failed()) return;
00106     switch (r) {
00107     case IRT_EQ:
00108       if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
00109         GECODE_ES_FAIL(home,(Rel::EqDom<IntView,IntView>::post(home,x0,x1)));
00110       } else {
00111         GECODE_ES_FAIL(home,(Rel::EqBnd<IntView,IntView>::post(home,x0,x1)));
00112       }
00113       break;
00114     case IRT_NQ:
00115       GECODE_ES_FAIL(home,Rel::Nq<IntView>::post(home,x0,x1)); break;
00116     case IRT_GQ:
00117       std::swap(x0,x1); // Fall through
00118     case IRT_LQ:
00119       GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,x0,x1)); break;
00120     case IRT_GR:
00121       std::swap(x0,x1); // Fall through
00122     case IRT_LE:
00123       GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,x0,x1)); break;
00124     default:
00125       throw UnknownRelation("Int::rel");
00126     }
00127   }
00128 
00129   void
00130   rel(Home home, const IntVarArgs& x, IntRelType r, IntVar y,
00131       IntConLevel icl) {
00132     if (home.failed()) return;
00133     switch (r) {
00134     case IRT_EQ:
00135       {
00136         ViewArray<IntView> xv(home,x.size()+1);
00137         xv[x.size()]=y;
00138         for (int i=x.size(); i--; )
00139           xv[i]=x[i];
00140         if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
00141           GECODE_ES_FAIL(home,Rel::NaryEqDom<IntView>::post(home,xv));
00142         } else {
00143           GECODE_ES_FAIL(home,Rel::NaryEqBnd<IntView>::post(home,xv));
00144         }
00145       }
00146       break;
00147     case IRT_NQ:
00148       for (int i=x.size(); i--; ) {
00149         GECODE_ES_FAIL(home,Rel::Nq<IntView>::post(home,x[i],y));
00150       }
00151       break;
00152     case IRT_GQ:
00153       for (int i=x.size(); i--; ) {
00154         GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,y,x[i]));
00155       }
00156       break;
00157     case IRT_LQ:
00158       for (int i=x.size(); i--; ) {
00159         GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,x[i],y));
00160       }
00161       break;
00162     case IRT_GR:
00163       for (int i=x.size(); i--; ) {
00164         GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,y,x[i]));
00165       }
00166       break;
00167     case IRT_LE:
00168       for (int i=x.size(); i--; ) {
00169         GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,x[i],y));
00170       }
00171       break;
00172     default:
00173       throw UnknownRelation("Int::rel");
00174     }
00175   }
00176 
00177 
00178   void
00179   rel(Home home, IntVar x0, IntRelType r, IntVar x1, BoolVar b,
00180       IntConLevel icl) {
00181     if (home.failed()) return;
00182     switch (r) {
00183     case IRT_EQ:
00184       if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
00185         GECODE_ES_FAIL(home,(Rel::ReEqDom<IntView,BoolView>
00186                              ::post(home,x0,x1,b)));
00187       } else {
00188         GECODE_ES_FAIL(home,(Rel::ReEqBnd<IntView,BoolView>
00189                              ::post(home,x0,x1,b)));
00190       }
00191       break;
00192     case IRT_NQ:
00193       {
00194         NegBoolView n(b);
00195         if (icl == ICL_BND) {
00196           GECODE_ES_FAIL(home,(Rel::ReEqBnd<IntView,NegBoolView>
00197                                ::post(home,x0,x1,n)));
00198         } else {
00199           GECODE_ES_FAIL(home,(Rel::ReEqDom<IntView,NegBoolView>
00200                                ::post(home,x0,x1,n)));
00201         }
00202       }
00203       break;
00204     case IRT_GQ:
00205       std::swap(x0,x1); // Fall through
00206     case IRT_LQ:
00207       GECODE_ES_FAIL(home,(Rel::ReLq<IntView,BoolView>::post(home,x0,x1,b)));
00208       break;
00209     case IRT_LE:
00210       std::swap(x0,x1); // Fall through
00211     case IRT_GR:
00212       {
00213         NegBoolView n(b);
00214         GECODE_ES_FAIL(home,(Rel::ReLq<IntView,NegBoolView>::post(home,x0,x1,n)));
00215       }
00216       break;
00217     default:
00218       throw UnknownRelation("Int::rel");
00219     }
00220   }
00221 
00222   void
00223   rel(Home home, IntVar x, IntRelType r, int n, BoolVar b,
00224       IntConLevel icl) {
00225     Limits::check(n,"Int::rel");
00226     if (home.failed()) return;
00227     switch (r) {
00228     case IRT_EQ:
00229       if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
00230         GECODE_ES_FAIL(home,(Rel::ReEqDomInt<IntView,BoolView>
00231                              ::post(home,x,n,b)));
00232       } else {
00233         GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,BoolView>
00234                              ::post(home,x,n,b)));
00235       }
00236       break;
00237     case IRT_NQ:
00238       {
00239         NegBoolView nb(b);
00240         if (icl == ICL_BND) {
00241           GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,NegBoolView>
00242                                ::post(home,x,n,nb)));
00243         } else {
00244           GECODE_ES_FAIL(home,(Rel::ReEqDomInt<IntView,NegBoolView>
00245                                ::post(home,x,n,nb)));
00246         }
00247       }
00248       break;
00249     case IRT_LE:
00250       n--; // Fall through
00251     case IRT_LQ:
00252       GECODE_ES_FAIL(home,(Rel::ReLqInt<IntView,BoolView>
00253                            ::post(home,x,n,b)));
00254       break;
00255     case IRT_GQ:
00256       n--; // Fall through
00257     case IRT_GR:
00258       {
00259         NegBoolView nb(b);
00260         GECODE_ES_FAIL(home,(Rel::ReLqInt<IntView,NegBoolView>
00261                              ::post(home,x,n,nb)));
00262       }
00263       break;
00264     default:
00265       throw UnknownRelation("Int::rel");
00266     }
00267   }
00268 
00269   void
00270   rel(Home home, const IntVarArgs& x, IntRelType r,
00271       IntConLevel icl) {
00272     if (home.failed() || (x.size() < 2)) return;
00273     switch (r) {
00274     case IRT_EQ:
00275       {
00276         ViewArray<IntView> xv(home,x);
00277         if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
00278           GECODE_ES_FAIL(home,Rel::NaryEqDom<IntView>::post(home,xv));
00279         } else {
00280           GECODE_ES_FAIL(home,Rel::NaryEqBnd<IntView>::post(home,xv));
00281         }
00282       }
00283       break;
00284     case IRT_NQ:
00285       distinct(home,x,icl);
00286       break;
00287     case IRT_LE:
00288       for (int i=x.size()-1; i--; )
00289         GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,x[i],x[i+1]));
00290       break;
00291     case IRT_LQ:
00292       for (int i=x.size()-1; i--; )
00293         GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,x[i],x[i+1]));
00294       break;
00295     case IRT_GR:
00296       for (int i=x.size()-1; i--; )
00297         GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,x[i+1],x[i]));
00298       break;
00299     case IRT_GQ:
00300       for (int i=x.size()-1; i--; )
00301         GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,x[i+1],x[i]));
00302       break;
00303     default:
00304       throw UnknownRelation("Int::rel");
00305     }
00306   }
00307 
00308   void
00309   rel(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
00310       IntConLevel icl) {
00311     if (x.size() != y.size())
00312       throw ArgumentSizeMismatch("Int::rel");
00313     if (home.failed()) return;
00314 
00315     switch (r) {
00316     case IRT_GR:
00317       {
00318         ViewArray<IntView> xv(home,x), yv(home,y);
00319         GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,yv,xv,true));
00320       }
00321       break;
00322     case IRT_LE:
00323       {
00324         ViewArray<IntView> xv(home,x), yv(home,y);
00325         GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xv,yv,true));
00326       }
00327       break;
00328     case IRT_GQ:
00329       {
00330         ViewArray<IntView> xv(home,x), yv(home,y);
00331         GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,yv,xv,false));
00332       }
00333       break;
00334     case IRT_LQ:
00335       {
00336         ViewArray<IntView> xv(home,x), yv(home,y);
00337         GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xv,yv,false));
00338       }
00339       break;
00340     case IRT_EQ:
00341       if ((icl == ICL_DOM) || (icl == ICL_DEF))
00342         for (int i=x.size(); i--; ) {
00343           GECODE_ES_FAIL(home,(Rel::EqDom<IntView,IntView>
00344                                ::post(home,x[i],y[i])));
00345         }
00346       else
00347         for (int i=x.size(); i--; ) {
00348           GECODE_ES_FAIL(home,(Rel::EqBnd<IntView,IntView>
00349                                ::post(home,x[i],y[i])));
00350         }
00351       break;
00352     case IRT_NQ:
00353       {
00354         ViewArray<BoolView> b(home,x.size());
00355         for (int i=x.size(); i--; ) {
00356           BoolVar bi(home,0,1); b[i]=bi;
00357           NegBoolView n(b[i]);
00358           GECODE_ES_FAIL(home,(Rel::ReEqDom<IntView,NegBoolView>
00359                                ::post(home,x[i],y[i],n)));
00360         }
00361         GECODE_ES_FAIL(home,Bool::NaryOrTrue<BoolView>::post(home,b));
00362       }
00363       break;
00364     default:
00365       throw UnknownRelation("Int::rel");
00366     }
00367   }
00368 
00369 }
00370 
00371 // STATISTICS: int-post