dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/count/int-eq.hpp

@@ -0,0 +1,143 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-08-29 22:59:24 +1000 (Mon, 29 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12359 $
+ *
+ *  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 Int { namespace Count {
+
+  template<class VX, class VY>
+  forceinline
+  EqInt<VX,VY>::EqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c)
+    : IntBase<VX,VY>(home,x,n_s,y,c) {}
+
+  template<class VX, class VY>
+  ExecStatus
+  EqInt<VX,VY>::post(Home home, ViewArray<VX>& x, VY y, int c) {
+    // Eliminate decided views
+    int n_x = x.size();
+    for (int i=n_x; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i] = x[--n_x]; break;
+      case RT_TRUE:
+        x[i] = x[--n_x]; c--; break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    // RHS too small or too large
+    if ((c < 0) || (c > n_x))
+      return ES_FAILED;
+    // All views must be different
+    if (c == 0)
+      return post_false(home,x,y);
+    // All views must be equal
+    if (c == n_x)
+      return post_true(home,x,y);
+    // Compute how many subscriptions must be created
+    int n_s = std::max(c,n_x-c)+1;
+    assert(n_s <= n_x);
+    (void) new (home) EqInt<VX,VY>(home,x,n_s,y,c);
+    return ES_OK;
+  }
+
+  template<class VX, class VY>
+  forceinline
+  EqInt<VX,VY>::EqInt(Space& home, bool share, EqInt<VX,VY>& p)
+    : IntBase<VX,VY>(home,share,p) {}
+
+  template<class VX, class VY>
+  Actor*
+  EqInt<VX,VY>::copy(Space& home, bool share) {
+    return new (home) EqInt<VX,VY>(home,share,*this);
+  }
+
+  template<class VX, class VY>
+  ExecStatus
+  EqInt<VX,VY>::propagate(Space& home, const ModEventDelta&) {
+    // Eliminate decided views from subscribed views
+    int n_x = x.size();
+    for (int i=n_s; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x];
+        break;
+      case RT_TRUE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x]; c--;
+        break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    if ((c < 0) || (c > n_x))
+      return ES_FAILED;
+    // Eliminate decided views from unsubscribed views
+    for (int i=n_x; i-- > n_s; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE: x[i]=x[--n_x]; break;
+      case RT_TRUE:  x[i]=x[--n_x]; c--; break;
+      case RT_MAYBE: break;
+      default:       GECODE_NEVER;
+      }
+    x.size(n_x);
+    if ((c < 0) || (c > n_x))
+      return ES_FAILED;
+    if (c == 0) {
+      // All views must be different
+      GECODE_ES_CHECK(post_false(home,x,y));
+      return home.ES_SUBSUMED(*this);
+    }
+    if (c == n_x) {
+      // All views must be equal
+      GECODE_ES_CHECK(post_true(home,x,y));
+      return home.ES_SUBSUMED(*this);
+    }
+    int m = std::max(c,n_x-c)+1;
+    assert(m <= n_x);
+    // Now, there must be new subscriptions from x[n_s] up to x[m-1]
+    while (n_s < m)
+      x[n_s++].subscribe(home,*this,PC_INT_DOM,false);
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/count/int-gq.hpp

@@ -0,0 +1,137 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-08-29 22:59:24 +1000 (Mon, 29 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12359 $
+ *
+ *  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 Int { namespace Count {
+
+  template<class VX, class VY>
+  forceinline
+  GqInt<VX,VY>::GqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c)
+    : IntBase<VX,VY>(home,x,n_s,y,c) {}
+
+  template<class VX, class VY>
+  ExecStatus
+  GqInt<VX,VY>::post(Home home, ViewArray<VX>& x, VY y, int c) {
+    // Eliminate decided views
+    int n_x = x.size();
+    for (int i=n_x; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i] = x[--n_x]; break;
+      case RT_TRUE:
+        x[i] = x[--n_x]; c--; break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    // RHS too large
+    if (n_x < c)
+      return ES_FAILED;
+    // Whatever the x[i] take for values, the inequality is subsumed
+    if (c <= 0)
+      return ES_OK;
+    // All views must be equal
+    if (c == n_x)
+      return post_true(home,x,y);
+    (void) new (home) GqInt<VX,VY>(home,x,c+1,y,c);
+    return ES_OK;
+  }
+
+  template<class VX, class VY>
+  forceinline
+  GqInt<VX,VY>::GqInt(Space& home, bool share, GqInt<VX,VY>& p)
+    : IntBase<VX,VY>(home,share,p) {}
+
+  template<class VX, class VY>
+  Actor*
+  GqInt<VX,VY>::copy(Space& home, bool share) {
+    return new (home) GqInt<VX,VY>(home,share,*this);
+  }
+
+  template<class VX, class VY>
+  ExecStatus
+  GqInt<VX,VY>::propagate(Space& home, const ModEventDelta&) {
+    // Eliminate decided views from subscribed views
+    int n_x = x.size();
+    for (int i=n_s; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x];
+        break;
+      case RT_TRUE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x]; c--;
+        break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    if (n_x < c)
+      return ES_FAILED;
+    if (c <= 0)
+      return home.ES_SUBSUMED(*this);
+    // Eliminate decided views from unsubscribed views
+    for (int i=n_x; i-- > n_s; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE: x[i]=x[--n_x]; break;
+      case RT_TRUE:  x[i]=x[--n_x]; c--; break;
+      case RT_MAYBE: break;
+      default:       GECODE_NEVER;
+      }
+    x.size(n_x);
+    if (n_x < c)
+      return ES_FAILED;
+    if (c <= 0)
+      return home.ES_SUBSUMED(*this);
+    if (c == n_x) {
+      // All views must be equal
+      GECODE_ES_CHECK(post_true(home,x,y)); 
+      return home.ES_SUBSUMED(*this);
+    }
+    // Now, there must be new subscriptions from x[n_s] up to x[c+1]
+    while (n_s <= c)
+      x[n_s++].subscribe(home,*this,PC_INT_DOM,false);
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/count/int-lq.hpp

@@ -0,0 +1,136 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-08-29 22:59:24 +1000 (Mon, 29 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12359 $
+ *
+ *  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 Int { namespace Count {
+
+  template<class VX, class VY>
+  forceinline
+  LqInt<VX,VY>::LqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c)
+    : IntBase<VX,VY>(home,x,n_s,y,c) {}
+
+  template<class VX, class VY>
+  ExecStatus
+  LqInt<VX,VY>::post(Home home, ViewArray<VX>& x, VY y, int c) {
+    // Eliminate decided views
+    int n_x = x.size();
+    for (int i=n_x; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i] = x[--n_x]; break;
+      case RT_TRUE:
+        x[i] = x[--n_x]; c--; break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    if (c < 0)
+      return ES_FAILED;
+    if (c >= n_x)
+      return ES_OK;
+    // All views must be different
+    if (c == 0)
+      return post_false(home,x,y);
+    (void) new (home) LqInt<VX,VY>(home,x,n_x-c+1,y,c);
+    return ES_OK;
+  }
+
+  template<class VX, class VY>
+  forceinline
+  LqInt<VX,VY>::LqInt(Space& home, bool share, LqInt<VX,VY>& p)
+    : IntBase<VX,VY>(home,share,p) {}
+
+  template<class VX, class VY>
+  Actor*
+  LqInt<VX,VY>::copy(Space& home, bool share) {
+    return new (home) LqInt<VX,VY>(home,share,*this);
+  }
+
+  template<class VX, class VY>
+  ExecStatus
+  LqInt<VX,VY>::propagate(Space& home, const ModEventDelta&) {
+    // Eliminate decided views from subscribed views
+    int n_x = x.size();
+    for (int i=n_s; i--; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x];
+        break;
+      case RT_TRUE:
+        x[i].cancel(home,*this,PC_INT_DOM);
+        x[i]=x[--n_s]; x[n_s]=x[--n_x]; c--;
+        break;
+      case RT_MAYBE:
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    x.size(n_x);
+    if (c < 0)
+      return ES_FAILED;
+    if (c >= n_x)
+      return home.ES_SUBSUMED(*this);
+    // Eliminate decided views from unsubscribed views
+    for (int i=n_x; i-- > n_s; )
+      switch (holds(x[i],y)) {
+      case RT_FALSE: x[i]=x[--n_x]; break;
+      case RT_TRUE:  x[i]=x[--n_x]; c--; break;
+      case RT_MAYBE: break;
+      default:       GECODE_NEVER;
+      }
+    x.size(n_x);
+    if (c < 0)
+      return ES_FAILED;
+    if (c >= n_x)
+      return home.ES_SUBSUMED(*this);
+    if (c == 0) {
+      // All views must be different
+      GECODE_ES_CHECK(post_false(home,x,y));
+      return home.ES_SUBSUMED(*this);
+    }
+    // Now, there must be new subscriptions from x[n_s] up to x[n_x-c+1]
+    int m = n_x-c;
+    while (n_s <= m)
+      x[n_s++].subscribe(home,*this,PC_INT_DOM,false);
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/count/rel.hpp

@@ -0,0 +1,281 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 18:41:47 +1000 (Thu, 25 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12351 $
+ *
+ *  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/int/rel.hh>
+
+namespace Gecode { namespace Int { namespace Count {
+
+  /*
+   * Counting domain consistent equality
+   *
+   */
+
+  template<class VY>
+  forceinline ViewTypeDesc
+  vtd(VY y) {
+    (void) y;
+    return VTD_VARVIEW;
+  }
+  template<>
+  forceinline ViewTypeDesc
+  vtd(const IntSet& y) {
+    (void) y;
+    return VTD_INTSET;
+  }
+  template<>
+  forceinline ViewTypeDesc
+  vtd(ConstIntView y) {
+    (void) y;
+    return VTD_CONSTVIEW;
+  }
+  template<>
+  forceinline ViewTypeDesc
+  vtd(ZeroIntView y) {
+    (void) y;
+    return VTD_CONSTVIEW;
+  }
+
+
+  forceinline void
+  subscribe(Space& home, Propagator& p, IntSet& y) {
+    (void) home; (void) p; (void) y;
+  }
+  template<class VY>
+  forceinline void
+  subscribe(Space& home, Propagator& p, VY y) {
+    y.subscribe(home, p, PC_INT_DOM);
+  }
+
+  forceinline void
+  cancel(Space& home, Propagator& p, IntSet& y) {
+    (void) home; (void) p;
+    y.~IntSet();
+  }
+  template<class VY>
+  forceinline void
+  cancel(Space& home, Propagator& p, VY y) {
+    y.cancel(home, p, PC_INT_DOM);
+  }
+
+  template<class VX>
+  forceinline RelTest
+  holds(VX x, ConstIntView y) {
+    return rtest_eq_dom(x,y.val());
+  }
+  template<class VX>
+  forceinline RelTest
+  holds(VX x, ZeroIntView) {
+    return rtest_eq_dom(x,0);
+  }
+  template<class VX>
+  forceinline RelTest
+  holds(VX x, const IntSet& y) {
+    if ((x.max() < y.min()) || (y.max() < x.min()))
+      return RT_FALSE;
+    ViewRanges<VX> rx(x);
+    IntSetRanges ry(y);
+    switch (Iter::Ranges::compare(rx,ry)) {
+    case Iter::Ranges::CS_SUBSET:
+      return RT_TRUE;
+    case Iter::Ranges::CS_DISJOINT:
+      return RT_FALSE;
+    case Iter::Ranges::CS_NONE:
+      return RT_MAYBE;
+    default:
+      GECODE_NEVER;
+    }
+    GECODE_NEVER;
+    return RT_MAYBE;
+  }
+  template<class VX>
+  forceinline RelTest
+  holds(VX x, VX y) {
+    return rtest_eq_dom(x,y);
+  }
+
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, VX x, ConstIntView y) {
+    GECODE_ME_CHECK(x.eq(home,y.val()));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, VX x, ZeroIntView) {
+    GECODE_ME_CHECK(x.eq(home,0));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, VX x, const IntSet& y) {
+    IntSetRanges ry(y);
+    GECODE_ME_CHECK(x.inter_r(home,ry,false));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, ViewArray<VX>& x, ConstIntView y) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].eq(home,y.val()));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, ViewArray<VX>& x, ZeroIntView) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].eq(home,0));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, ViewArray<VX>& x, const IntSet& y) {
+    for (int i = x.size(); i--; ) {
+      IntSetRanges ry(y);
+      GECODE_ME_CHECK(x[i].inter_r(home,ry,false));
+    }
+    return ES_OK;
+  }
+
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, VX x, ConstIntView y) {
+    GECODE_ME_CHECK(x.nq(home,y.val()));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, VX x, ZeroIntView) {
+    GECODE_ME_CHECK(x.nq(home,0));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, VX x, const IntSet& y) {
+    IntSetRanges ry(y);
+    GECODE_ME_CHECK(x.minus_r(home,ry,false));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, ViewArray<VX>& x, ConstIntView y) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].nq(home,y.val()));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, ViewArray<VX>& x, ZeroIntView) {
+    for (int i = x.size(); i--; )
+      GECODE_ME_CHECK(x[i].nq(home,0));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, ViewArray<VX>& x, const IntSet& y) {
+    for (int i = x.size(); i--; ) {
+      IntSetRanges ry(y);
+      GECODE_ME_CHECK(x[i].minus_r(home,ry,false));
+    }
+    return ES_OK;
+  }
+
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, ViewArray<VX>& x, VX y) {
+    ViewArray<VX> z(home,x.size()+1);
+    z[x.size()] = y;
+    for (int i = x.size(); i--; )
+      z[i] = x[i];
+    return Rel::NaryEqDom<VX>::post(home,z);
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_true(Home home, VX x, VX y) {
+    return Rel::EqDom<VX,VX>::post(home,x,y);
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, ViewArray<VX>& x, VX y) {
+    for (int i = x.size(); i--; )
+      GECODE_ES_CHECK(Rel::Nq<VX>::post(home,x[i],y));
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  post_false(Home home, VX x, VX y) {
+    return Rel::Nq<VX>::post(home,x,y);
+  }
+
+  template<class VX>
+  forceinline ExecStatus
+  prune(Space& home, ViewArray<VX>& x, ConstIntView) {
+    (void) home;
+    (void) x;
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  prune(Space& home, ViewArray<VX>& x, ZeroIntView) {
+    (void) home;
+    (void) x;
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  prune(Space& home, ViewArray<VX>& x, const IntSet& y) {
+    (void) home;
+    (void) x;
+    (void) y;
+    return ES_OK;
+  }
+  template<class VX>
+  forceinline ExecStatus
+  prune(Space& home, ViewArray<VX>& x, VX y) {
+    if (x.size() == 0)
+      return ES_OK;
+    Region r(home);
+    ViewRanges<VX>* rx = r.alloc<ViewRanges<VX> >(x.size());
+    for (int i=x.size(); i--; )
+      rx[i] = ViewRanges<VX>(x[i]);
+    Iter::Ranges::NaryUnion u(r, rx, x.size());
+    GECODE_ME_CHECK(y.inter_r(home, u, false));
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop