dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/convex/hull.hpp

@@ -0,0 +1,68 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2009-10-13 02:36:53 +1100 (Tue, 13 Oct 2009) $ by $Author: schulte $
+ *     $Revision: 9878 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Convex {
+
+  /*
+   * "Convex hull" propagator
+   *
+   */
+
+  forceinline
+  ConvexHull::ConvexHull(Home home, SetView x, SetView y)
+    : BinaryPropagator<SetView, PC_SET_ANY>(home, x, y) {}
+
+  forceinline
+  ConvexHull::ConvexHull(Space& home, bool share, ConvexHull& p)
+    : BinaryPropagator<SetView, PC_SET_ANY>(home, share, p) {}
+
+  forceinline ExecStatus
+  ConvexHull::post(Home home, SetView x, SetView y) {
+    (void) new (home) ConvexHull(home,x,y);
+    return ES_OK;
+  }
+
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/distinct.cpp

@@ -0,0 +1,56 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2010-03-04 03:40:32 +1100 (Thu, 04 Mar 2010) $ by $Author: schulte $
+ *     $Revision: 10365 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/set/distinct.hh>
+
+using namespace Gecode::Set;
+
+namespace Gecode {
+
+  void
+  atmostOne(Home home, const SetVarArgs& xa, unsigned int c) {
+    Set::Limits::check(c, "Set::atmostOne");
+    if (home.failed()) return;
+    if (xa.size() < 2)
+      return;
+    ViewArray<SetView> x(home,xa);
+    GECODE_ES_FAIL(Distinct::AtmostOne::post(home, x, c));
+  }
+
+}
+
+// STATISTICS: set-post

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/distinct.hh

@@ -0,0 +1,79 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2009-10-13 02:36:53 +1100 (Tue, 13 Oct 2009) $ by $Author: schulte $
+ *     $Revision: 9878 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef __GECODE_SET_ATMOSTONE_HH__
+#define __GECODE_SET_ATMOSTONE_HH__
+
+#include <gecode/set.hh>
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /**
+   * \namespace Gecode::Set::Distinct
+   * \brief Propagators for global distinctness constraints
+   */
+
+  /**
+   * \brief %Propagator for the AtMostOneIntersection constraint
+   *
+   * Requires \code #include <gecode/set/distinct.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  class AtmostOne : public NaryPropagator<SetView, PC_SET_ANY> {
+  protected:
+    /// Cardinality of the sets
+    unsigned int c;
+    /// Constructor for cloning \a p
+    AtmostOne(Space& home, bool share,AtmostOne& p);
+    /// Constructor for posting
+    AtmostOne(Home home,ViewArray<SetView>&,unsigned int);
+  public:
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor*      copy(Space& home, bool);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator for \f$\forall 0\leq i\leq |x| : |x_i|=c\f$ and \f$\forall 0\leq i<j\leq |x| : |x_i\cap x_j|\leq 1\f$
+    static ExecStatus post(Home home,ViewArray<SetView> x,unsigned int c);
+  };
+
+}}}
+
+#include <gecode/set/distinct/atmostOne.hpp>
+
+#endif
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/distinct/atmostOne.cpp

@@ -0,0 +1,162 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-08-09 02:04:53 +1000 (Tue, 09 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12253 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/set/distinct.hh>
+
+/*
+ * These propagators implement the scheme discussed in
+ *
+ * Andrew Sadler and Carment Gervet: Global Reasoning on Sets.
+ * FORMUL'01 workshop in conjunction with CP 2001.
+ *
+ * Todo: make the propagators incremental.
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * "AtMostOneIntersection" propagator
+   *
+   */
+
+  Actor*
+  AtmostOne::copy(Space& home, bool share) {
+    return new (home) AtmostOne(home,share,*this);
+  }
+
+  ExecStatus
+  AtmostOne::propagate(Space& home, const ModEventDelta&) {
+    Region r(home);
+    LubRanges<SetView>* lubs = r.alloc<LubRanges<SetView> >(x.size());
+    for (int i = x.size(); i--; ) {
+      lubs[i].init(x[i]);
+    }
+    Iter::Ranges::NaryUnion bigT(r, lubs, x.size());
+
+    Iter::Ranges::ToValues<Iter::Ranges::NaryUnion>
+      as(bigT);
+
+    while (as()) {
+      int a = as.val(); ++as;
+
+      // cardSa is the number of sets that contain a in the glb
+      int cardSa = 0;
+      for (int i=x.size(); i--;)
+        if (x[i].contains(a))
+          cardSa++;
+
+      // bigTa is the union of all lubs that contain a
+      GLBndSet bigTa(home);
+      for (int i=x.size(); i--;) {
+        if (!x[i].notContains(a)) {
+          LubRanges<SetView> xilub(x[i]);
+          bigTa.includeI(home, xilub);
+        }
+      }
+
+      // maxa is the maximum number of sets that can contain a
+      int maxa = static_cast<int>((bigTa.size() - 1) / (c - 1));
+      bigTa.dispose(home);
+
+      // Conditional Rule A:
+      // If more sets already contain a than allowed, fail.
+      if (maxa < cardSa)
+        return ES_FAILED;
+
+      if (maxa == cardSa) {
+        // Conditional Rule B:
+        // All a used up. All other sets (those that don't have a in their
+        // glb already) cannot contain a.
+        for (int i=x.size(); i--;) {
+          if (!x[i].contains(a)) {
+            GECODE_ME_CHECK(x[i].exclude(home, a));
+          }
+        }
+      } else {
+        LubRanges<SetView>* lubs2 = r.alloc<LubRanges<SetView> >(x.size());
+        for (int i = x.size(); i--; ) {
+          lubs2[i].init(x[i]);
+        }
+        Iter::Ranges::NaryUnion bigT2(r, lubs2, x.size());
+
+        GlbRanges<SetView>* glbs = r.alloc<GlbRanges<SetView> >(cardSa);
+        int count = 0;
+        for (int i=x.size(); i--; ) {
+          if (x[i].contains(a)) {
+            glbs[count].init(x[i]);
+            count++;
+          }
+        }
+        Iter::Ranges::NaryUnion glbsa(r, glbs, cardSa);
+        Iter::Ranges::Diff<Iter::Ranges::NaryUnion,
+          Iter::Ranges::NaryUnion> deltaA(bigT2, glbsa);
+        Iter::Ranges::Cache deltaAC(r,deltaA);
+        // deltaAC contains all elements that are not yet known to be
+        // in a set together with a.
+        // Formally: \cup_i lub(x_i) - \cup_i {glb(s_i) | a\in glb(s_i)}
+
+
+        if (Iter::Ranges::size(deltaAC) == c - 1) {
+          // Conditional Rule C:
+          // If deltaA has exactly c-1 elements, all sets that are not yet
+          // known to contain a cannot contain a if it is impossible that
+          // they contain all of deltaA. Or the other way around:
+          // If a is added to the glb of a set s, deltaA must be a subset of
+          // s, because otherwise s would share at least one more element
+          // with another set that has a in its lower bound.
+          // Weird, eh?
+          for (int i=x.size(); i--; ) {
+            if (!x[i].contains(a) && !x[i].notContains(a)) {
+              deltaAC.reset();
+              LubRanges<SetView> xilub(x[i]);
+              if (!Iter::Ranges::subset(deltaAC, xilub)) {
+                GECODE_ME_CHECK(x[i].exclude(home, a));
+              }
+            }
+          }
+        }
+
+      }
+
+    }
+
+    return ES_NOFIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/distinct/atmostOne.hpp

@@ -0,0 +1,66 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2009-10-13 02:36:53 +1100 (Tue, 13 Oct 2009) $ by $Author: schulte $
+ *     $Revision: 9878 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * "AtMostOneIntersection" propagator
+   *
+   */
+
+  forceinline
+  AtmostOne::AtmostOne(Home home, ViewArray<SetView>& x, unsigned int _c)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,x), c(_c) {}
+
+  forceinline
+  AtmostOne::AtmostOne(Space& home, bool share, AtmostOne& p)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,share,p), c(p.c) {}
+
+  forceinline ExecStatus
+  AtmostOne::post(Home home, ViewArray<SetView> x, unsigned int c) {
+    for (int i=x.size(); i--;) {
+      GECODE_ME_CHECK(x[i].cardMin(home, c));
+      GECODE_ME_CHECK(x[i].cardMax(home, c));
+    }
+
+    (void) new (home) AtmostOne(home,x,c);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/dom.cpp

@@ -0,0 +1,300 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 00:34:16 +1000 (Thu, 25 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12346 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/set.hh>
+#include <gecode/set/rel.hh>
+
+namespace Gecode {
+
+  void
+  dom(Home home, SetVar s, SetRelType r, int i) {
+    Set::Limits::check(i, "Set::dom");
+    IntSet d(i,i);
+    dom(home, s, r, d);
+  }
+
+  void
+  dom(Home home, SetVar s, SetRelType r, int i, int j) {
+    Set::Limits::check(i, "Set::dom");
+    Set::Limits::check(j, "Set::dom");
+    IntSet d(i,j);
+    dom(home, s, r, d);
+  }
+
+  void
+  dom(Home home, SetVar s, SetRelType r, const IntSet& is) {
+    Set::Limits::check(is, "Set::dom");
+    if (home.failed()) return;
+
+    Set::SetView _s(s);
+
+    switch (r) {
+    case SRT_EQ:
+      {
+        if (is.ranges() == 1) {
+          GECODE_ME_FAIL(_s.include(home, is.min(), is.max()));
+          GECODE_ME_FAIL(_s.intersect(home, is.min(), is.max()));
+        } else {
+          IntSetRanges rd1(is);
+          GECODE_ME_FAIL(_s.includeI(home, rd1));
+          IntSetRanges rd2(is);
+          GECODE_ME_FAIL(_s.intersectI(home, rd2));
+        }
+      }
+      break;
+    case SRT_LQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::Lq<Set::SetView,Set::ConstSetView,false>
+            ::post(home,s,cv)));
+      }
+      break;
+    case SRT_LE:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::Lq<Set::SetView,Set::ConstSetView,true>
+            ::post(home,s,cv)));
+      }
+      break;
+    case SRT_GQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::Lq<Set::ConstSetView,Set::SetView,false>
+            ::post(home,cv,s)));
+      }
+      break;
+    case SRT_GR:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::Lq<Set::ConstSetView,Set::SetView,true>
+            ::post(home,cv,s)));
+      }
+      break;
+    case SRT_DISJ:
+      {
+        if (is.ranges() == 1) {
+          GECODE_ME_FAIL(_s.exclude(home, is.min(), is.max()));
+        } else {
+          IntSetRanges rd(is);
+          GECODE_ME_FAIL(_s.excludeI(home, rd));
+        }
+      }
+      break;
+    case SRT_NQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+                       (Set::Rel::DistinctDoit<Set::SetView>::post(home, s,
+                                                                   cv)));
+      }
+      break;
+    case SRT_SUB:
+      {
+         if (is.ranges() == 1) {
+           GECODE_ME_FAIL(_s.intersect(home, is.min(), is.max()));
+         } else {
+          IntSetRanges rd(is);
+          GECODE_ME_FAIL(_s.intersectI(home, rd));
+         }
+      }
+      break;
+    case SRT_SUP:
+      {
+        if (is.ranges() == 1) {
+          GECODE_ME_FAIL(_s.include(home, is.min(), is.max()));
+        } else {
+          IntSetRanges rd(is);
+          GECODE_ME_FAIL(_s.includeI(home, rd));
+        }
+      }
+      break;
+    case SRT_CMPL:
+      {
+        if (is.ranges() == 1) {
+          GECODE_ME_FAIL(_s.exclude(home, is.min(), is.max()));
+          GECODE_ME_FAIL(
+                         _s.include(home,
+                                    Set::Limits::min,
+                                    is.min()-1) );
+          GECODE_ME_FAIL(
+                         _s.include(home, is.max()+1,
+                                    Set::Limits::max) );
+        } else {
+          IntSetRanges rd1(is);
+          Set::RangesCompl<IntSetRanges > rdC1(rd1);
+          GECODE_ME_FAIL(_s.includeI(home, rdC1));
+          IntSetRanges rd2(is);
+          Set::RangesCompl<IntSetRanges > rdC2(rd2);
+          GECODE_ME_FAIL(_s.intersectI(home, rdC2));
+        }
+      }
+      break;
+    default:
+      throw Set::UnknownRelation("Set::dom");
+    }
+  }
+
+  void
+  dom(Home home, SetVar s, SetRelType r, int i, BoolVar b) {
+    Set::Limits::check(i, "Set::dom");
+    IntSet d(i,i);
+    dom(home, s, r, d, b);
+  }
+
+  void
+  dom(Home home, SetVar s, SetRelType r, int i, int j, BoolVar b) {
+    Set::Limits::check(i, "Set::dom");
+    Set::Limits::check(j, "Set::dom");
+    IntSet d(i,j);
+    dom(home, s, r, d, b);
+  }
+
+  void
+  dom(Home home, SetVar s, SetRelType r, const IntSet& is, BoolVar b) {
+    Set::Limits::check(is, "Set::dom");
+    if (home.failed()) return;
+    switch (r) {
+    case SRT_EQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReEq<Set::SetView,
+                        Set::ConstSetView>::post(home, s, cv, b)));
+      }
+      break;
+    case SRT_LQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::ReLq<Set::SetView,Set::ConstSetView,false>
+            ::post(home,s,cv,b)));
+      }
+      break;
+    case SRT_LE:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::ReLq<Set::SetView,Set::ConstSetView,true>
+            ::post(home,s,cv,b)));
+      }
+      break;
+    case SRT_GQ:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::ReLq<Set::ConstSetView,Set::SetView,false>
+            ::post(home,cv,s,b)));
+      }
+      break;
+    case SRT_GR:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+          (Set::Rel::ReLq<Set::ConstSetView,Set::SetView,true>
+            ::post(home,cv,s,b)));
+      }
+      break;
+    case SRT_NQ:
+      {
+        BoolVar notb(home,0,1);
+        rel(home, b, IRT_NQ, notb);
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReEq<Set::SetView,
+                        Set::ConstSetView>::post(home, s, cv, notb)));
+      }
+      break;
+    case SRT_SUB:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReSubset<Set::SetView,Set::ConstSetView>
+                        ::post(home, s, cv, b)));
+      }
+      break;
+    case SRT_SUP:
+      {
+        Set::ConstSetView cv(home, is);
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReSubset<Set::ConstSetView,Set::SetView>
+                        ::post(home, cv, s, b)));
+      }
+      break;
+    case SRT_DISJ:
+      {
+        // x||y <=> b is equivalent to
+        // ( y <= complement(x) and x<=complement(y) ) <=> b
+
+        // compute complement of is
+        IntSetRanges dr1(is);
+        Set::RangesCompl<IntSetRanges > dc1(dr1);
+        IntSet dcompl(dc1);
+        Set::ConstSetView cvcompl(home, dcompl);
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReSubset<Set::SetView,Set::ConstSetView>
+                        ::post(home, s, cvcompl, b)));
+      }
+      break;
+    case SRT_CMPL:
+      {
+        Set::SetView sv(s);
+
+        IntSetRanges dr1(is);
+        Set::RangesCompl<IntSetRanges> dc1(dr1);
+        IntSet dcompl(dc1);
+        Set::ConstSetView cvcompl(home, dcompl);
+
+        GECODE_ES_FAIL(
+                       (Set::Rel::ReEq<Set::SetView,Set::ConstSetView>
+                        ::post(home, sv, cvcompl, b)));
+      }
+      break;
+    default:
+      throw Set::UnknownRelation("Set::dom");
+    }
+  }
+
+}
+
+// STATISTICS: set-post