Generated on Tue Apr 18 10:21:38 2017 for Gecode by doxygen 1.6.3
gecode » set

dom.cpp

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