count.cc

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: 2008-02-06 20:23:59 +0100 (Wed, 06 Feb 2008) $ by $Author: schulte $
00011  *     $Revision: 6103 $
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/count.hh"
00039 
00040 namespace Gecode {
00041 
00042   void
00043   count(Space* home, const IntVarArgs& x, int n,
00044         IntRelType r, int m, IntConLevel, PropKind) {
00045     using namespace Int;
00046     Limits::check(n,"Int::count");
00047     Limits::check(m,"Int::count");
00048     if (home->failed()) return;
00049     ViewArray<IntView> xv(home,x);
00050     ConstIntView y(n);
00051     switch (r) {
00052     case IRT_EQ:
00053       GECODE_ES_FAIL(home,(Count::EqInt<IntView,ConstIntView>
00054                            ::post(home,xv,y,m)));
00055       break;
00056     case IRT_NQ:
00057       GECODE_ES_FAIL(home,(Count::NqInt<IntView,ConstIntView>
00058                            ::post(home,xv,y,m)));
00059       break;
00060     case IRT_LE:
00061       GECODE_ES_FAIL(home,(Count::LqInt<IntView,ConstIntView>
00062                            ::post(home,xv,y,m-1)));
00063       break;
00064     case IRT_LQ:
00065       GECODE_ES_FAIL(home,(Count::LqInt<IntView,ConstIntView>
00066                            ::post(home,xv,y,m)));
00067       break;
00068     case IRT_GR:
00069       GECODE_ES_FAIL(home,(Count::GqInt<IntView,ConstIntView>
00070                            ::post(home,xv,y,m+1)));
00071       break;
00072     case IRT_GQ:
00073       GECODE_ES_FAIL(home,(Count::GqInt<IntView,ConstIntView>
00074                            ::post(home,xv,y,m)));
00075       break;
00076     default:
00077       throw UnknownRelation("Int::count");
00078     }
00079   }
00080 
00081   void
00082   count(Space* home, const IntVarArgs& x, IntVar y,
00083         IntRelType r, int m, IntConLevel, PropKind) {
00084     using namespace Int;
00085     Limits::check(m,"Int::count");
00086     if (home->failed()) return;
00087     ViewArray<IntView> xv(home,x);
00088     switch (r) {
00089     case IRT_EQ:
00090       GECODE_ES_FAIL(home,(Count::EqInt<IntView,IntView>
00091                            ::post(home,xv,y,m)));
00092       break;
00093     case IRT_NQ:
00094       GECODE_ES_FAIL(home,(Count::NqInt<IntView,IntView>
00095                            ::post(home,xv,y,m)));
00096       break;
00097     case IRT_LE:
00098       GECODE_ES_FAIL(home,(Count::LqInt<IntView,IntView>
00099                            ::post(home,xv,y,m-1)));
00100       break;
00101     case IRT_LQ:
00102       GECODE_ES_FAIL(home,(Count::LqInt<IntView,IntView>
00103                            ::post(home,xv,y,m)));
00104       break;
00105     case IRT_GR:
00106       GECODE_ES_FAIL(home,(Count::GqInt<IntView,IntView>
00107                            ::post(home,xv,y,m+1)));
00108       break;
00109     case IRT_GQ:
00110       GECODE_ES_FAIL(home,(Count::GqInt<IntView,IntView>
00111                            ::post(home,xv,y,m)));
00112       break;
00113     default:
00114       throw UnknownRelation("Int::count");
00115     }
00116   }
00117 
00118   void
00119   count(Space* home, const IntVarArgs& x, const IntArgs& y,
00120         IntRelType r, int m, IntConLevel, PropKind) {
00121     using namespace Int;
00122     if (x.size() != y.size())
00123       throw ArgumentSizeMismatch("Int::count");
00124     Limits::check(m,"Int::count");
00125     if (home->failed()) return;
00126 
00127     ViewArray<OffsetView> xy(home,x.size());
00128     for (int i=x.size(); i--; )
00129       xy[i].init(x[i],-y[i]);
00130 
00131     ZeroIntView z;
00132     switch (r) {
00133     case IRT_EQ:
00134       GECODE_ES_FAIL(home,(Count::EqInt<OffsetView,ZeroIntView>
00135                            ::post(home,xy,z,m)));
00136       break;
00137     case IRT_NQ:
00138       GECODE_ES_FAIL(home,(Count::NqInt<OffsetView,ZeroIntView>
00139                            ::post(home,xy,z,m)));
00140       break;
00141     case IRT_LE:
00142       GECODE_ES_FAIL(home,(Count::LqInt<OffsetView,ZeroIntView>
00143                            ::post(home,xy,z,m-1)));
00144       break;
00145     case IRT_LQ:
00146       GECODE_ES_FAIL(home,(Count::LqInt<OffsetView,ZeroIntView>
00147                            ::post(home,xy,z,m)));
00148       break;
00149     case IRT_GR:
00150       GECODE_ES_FAIL(home,(Count::GqInt<OffsetView,ZeroIntView>
00151                            ::post(home,xy,z,m+1)));
00152       break;
00153     case IRT_GQ:
00154       GECODE_ES_FAIL(home,(Count::GqInt<OffsetView,ZeroIntView>
00155                            ::post(home,xy,z,m)));
00156       break;
00157     default:
00158       throw UnknownRelation("Int::count");
00159     }
00160   }
00161 
00162   void
00163   count(Space* home, const IntVarArgs& x, int n,
00164         IntRelType r, IntVar z, IntConLevel, PropKind) {
00165     using namespace Int;
00166     Limits::check(n,"Int::count");
00167     if (home->failed()) return;
00168     ViewArray<IntView> xv(home,x);
00169     ConstIntView yv(n);
00170     switch (r) {
00171     case IRT_EQ:
00172       GECODE_ES_FAIL(home,(Count::EqView<IntView,ConstIntView,IntView,true>
00173                            ::post(home,xv,yv,z,0)));
00174       break;
00175     case IRT_NQ:
00176       GECODE_ES_FAIL(home,(Count::NqView<IntView,ConstIntView,IntView,true>
00177                            ::post(home,xv,yv,z,0)));
00178       break;
00179     case IRT_LE:
00180       GECODE_ES_FAIL(home,(Count::LqView<IntView,ConstIntView,IntView,true>
00181                            ::post(home,xv,yv,z,-1)));
00182       break;
00183     case IRT_LQ:
00184       GECODE_ES_FAIL(home,(Count::LqView<IntView,ConstIntView,IntView,true>
00185                            ::post(home,xv,yv,z,0)));
00186       break;
00187     case IRT_GR:
00188       GECODE_ES_FAIL(home,(Count::GqView<IntView,ConstIntView,IntView,true>
00189                            ::post(home,xv,yv,z,1)));
00190       break;
00191     case IRT_GQ:
00192       GECODE_ES_FAIL(home,(Count::GqView<IntView,ConstIntView,IntView,true>
00193                            ::post(home,xv,yv,z,0)));
00194       break;
00195     default:
00196       throw UnknownRelation("Int::count");
00197     }
00198   }
00199 
00200   void
00201   count(Space* home, const IntVarArgs& x, IntVar y,
00202         IntRelType r, IntVar z, IntConLevel, PropKind) {
00203     using namespace Int;
00204     if (home->failed()) return;
00205     ViewArray<IntView> xv(home,x);
00206     switch (r) {
00207     case IRT_EQ:
00208       GECODE_ES_FAIL(home,(Count::EqView<IntView,IntView,IntView,true>
00209                            ::post(home,xv,y,z,0)));
00210       break;
00211     case IRT_NQ:
00212       GECODE_ES_FAIL(home,(Count::NqView<IntView,IntView,IntView,true>
00213                            ::post(home,xv,y,z,0)));
00214       break;
00215     case IRT_LE:
00216       GECODE_ES_FAIL(home,(Count::LqView<IntView,IntView,IntView,true>
00217                            ::post(home,xv,y,z,-1)));
00218       break;
00219     case IRT_LQ:
00220       GECODE_ES_FAIL(home,(Count::LqView<IntView,IntView,IntView,true>
00221                            ::post(home,xv,y,z,0)));
00222       break;
00223     case IRT_GR:
00224       GECODE_ES_FAIL(home,(Count::GqView<IntView,IntView,IntView,true>
00225                            ::post(home,xv,y,z,1)));
00226       break;
00227     case IRT_GQ:
00228       GECODE_ES_FAIL(home,(Count::GqView<IntView,IntView,IntView,true>
00229                            ::post(home,xv,y,z,0)));
00230       break;
00231     default:
00232       throw UnknownRelation("Int::count");
00233     }
00234   }
00235 
00236   void
00237   count(Space* home, const IntVarArgs& x, const IntArgs& y,
00238         IntRelType r, IntVar z, IntConLevel, PropKind) {
00239     using namespace Int;
00240     if (x.size() != y.size())
00241       throw ArgumentSizeMismatch("Int::count");
00242     if (home->failed()) return;
00243 
00244     ViewArray<OffsetView> xy(home,x.size());
00245     for (int i=x.size(); i--; )
00246       xy[i].init(x[i],-y[i]);
00247 
00248     ZeroIntView u;
00249     switch (r) {
00250     case IRT_EQ:
00251       GECODE_ES_FAIL(home,(Count::EqView<OffsetView,ZeroIntView,IntView,true>
00252                            ::post(home,xy,u,z,0)));
00253       break;
00254     case IRT_NQ:
00255       GECODE_ES_FAIL(home,(Count::NqView<OffsetView,ZeroIntView,IntView,true>
00256                            ::post(home,xy,u,z,0)));
00257       break;
00258     case IRT_LE:
00259       GECODE_ES_FAIL(home,(Count::LqView<OffsetView,ZeroIntView,IntView,true>
00260                            ::post(home,xy,u,z,-1)));
00261       break;
00262     case IRT_LQ:
00263       GECODE_ES_FAIL(home,(Count::LqView<OffsetView,ZeroIntView,IntView,true>
00264                            ::post(home,xy,u,z,0)));
00265       break;
00266     case IRT_GR:
00267       GECODE_ES_FAIL(home,(Count::GqView<OffsetView,ZeroIntView,IntView,true>
00268                            ::post(home,xy,u,z,1)));
00269       break;
00270     case IRT_GQ:
00271       GECODE_ES_FAIL(home,(Count::GqView<OffsetView,ZeroIntView,IntView,true>
00272                            ::post(home,xy,u,z,0)));
00273       break;
00274     default:
00275       throw UnknownRelation("Int::count");
00276     }
00277   }
00278 
00279   namespace {
00280     using namespace Int;
00281     template <template<class,class> class P>
00282     class I {
00283       GECODE_REGISTER2(P<IntView,ConstIntView>);      
00284       GECODE_REGISTER2(P<IntView,IntView>);      
00285       GECODE_REGISTER2(P<OffsetView,ZeroIntView>);
00286     };
00287     I<Count::EqInt> ieq;
00288     I<Count::LqInt> ilq;
00289     I<Count::GqInt> igq;
00290     I<Count::NqInt> inq;
00291     
00292     template <template <class,class,class,bool> class P,bool b>
00293     class VB {
00294       GECODE_REGISTER4(P<OffsetView,ZeroIntView,IntView,b>);
00295       GECODE_REGISTER4(P<IntView,ConstIntView,IntView,b>);
00296       GECODE_REGISTER4(P<IntView,IntView,IntView,b>);
00297     };
00298     template <template <class,class,class,bool> class P>
00299     class V {
00300       VB<P,false> vf;
00301       VB<P,true> vt;
00302     };
00303     V<Count::EqView> v1;
00304     V<Count::LqView> v2;
00305     V<Count::GqView> v3;
00306     VB<Count::NqView,true> v4;
00307   }
00308 }
00309 
00310 // STATISTICS: int-post