dom.cpp

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