gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/distinct.cc

@@ -0,0 +1,77 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Gabor Szokoli, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/int/distinct.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  distinct(Space* home, const IntVarArgs& x, IntConLevel icl) {
+    if (x.same())
+      throw ArgumentSame("Int::distinct");
+    if (home->failed()) return;
+    ViewArray<IntView> xv(home,x);
+    switch (icl) {
+    case ICL_BND:
+      GECODE_ES_FAIL(home,Distinct::Bnd<IntView>::post(home,xv));
+      break;
+    case ICL_DOM:
+      GECODE_ES_FAIL(home,Distinct::Dom<IntView>::post(home,xv));
+      break;
+    default:
+      GECODE_ES_FAIL(home,Distinct::Val<IntView>::post(home,xv));
+    }
+  }
+
+  void
+  distinct(Space* home, const IntArgs& c, const IntVarArgs& x,
+	   IntConLevel icl) {
+    if (x.same())
+      throw ArgumentSame("Int::distinct");
+    if (c.size() != x.size())
+      throw ArgumentSizeMismatch("Int::distinct");
+    if (home->failed()) return;
+    ViewArray<OffsetView> cx(home,x.size());
+    for (int i = c.size(); i--; )
+      if ((c[i] < Limits::Int::int_min) || (c[i] > Limits::Int::int_max))
+	throw NumericalOverflow("Int::distinct");
+      else
+	cx[i].init(x[i],c[i]);
+    switch (icl) {
+    case ICL_BND:
+      GECODE_ES_FAIL(home,Distinct::Bnd<OffsetView>::post(home,cx));
+      break;
+    case ICL_DOM:
+      GECODE_ES_FAIL(home,Distinct::Dom<OffsetView>::post(home,cx));
+      break;
+    default:
+      GECODE_ES_FAIL(home,Distinct::Val<OffsetView>::post(home,cx));
+    }
+  }
+
+}
+
+// STATISTICS: int-post
+

data/ext/gecode-1.3.1/gecode/int/distinct.hh

@@ -0,0 +1,272 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *     Gabor Szokoli, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-10-23 16:16:09 +0200 (Mon, 23 Oct 2006) $ by $Author: schulte $
+ *     $Revision: 3768 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_INT_DISTINCT_HH__
+#define __GECODE_INT_DISTINCT_HH__
+
+#include "gecode/int.hh"
+
+#include "gecode/int/rel.hh"
+
+/**
+ * \namespace Gecode::Int::Distinct
+ * \brief %Distinct propagators
+ */
+
+namespace Gecode { namespace Int { namespace Distinct {
+
+  /**
+   * \brief Naive value distinct propagator
+   *
+   * Eliminates values of assigned views of type \a View.
+   *
+   * Requires \code #include "gecode/int/distinct.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Val : public NaryPropagator<View,PC_INT_VAL> {
+  protected:
+    using NaryPropagator<View,PC_INT_VAL>::x;
+
+    /// Constructor for posting
+    Val(Space* home, ViewArray<View>& x);
+    /// Constructor for cloning \a p
+    Val(Space* home, bool share, Val<View>& p);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*     copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for view array \a x
+    static ExecStatus post(Space* home, ViewArray<View>& x);
+  };
+
+  /**
+   * \brief Eliminate singletons by naive value propagation
+   *
+   * This is actually the propagation algorithm for Distinct::Val.
+   * It is available as separate function as it is reused for
+   * both bounds-consistent and domain-consistent distinct
+   * propagators.
+   *
+   * If \a complete is true, computes fixpoint, otherwise might not
+   * compute fixpoint. This can be helpful when used together with
+   * bounds or domain propagation to protect from pathological cases
+   * which can be handled more efficiently with bounds propagation.
+   */
+  template <class View, bool complete>
+  ExecStatus prop_val(Space* home, ViewArray<View>&);
+
+
+
+  /**
+   * \brief Bounds-consistent distinct propagator
+   *
+   * The propagator uses staging: first it uses naive value-based
+   * propagation and only then uses bounds-consistent propagation.
+   * Due to using naive value-based propagation, the propagator
+   * might actually achieve stronger consistency than just
+   * bounds-consistency.
+   *
+   * The algorithm is taken from:
+   *	A. Lopez-Ortiz, C.-G. Quimper, J. Tromp, and P. van Beek.
+   *	A fast and simple algorithm for bounds consistency of the
+   *	alldifferent constraint. IJCAI-2003.
+   *
+   * This implementation uses the code that is provided by
+   * Peter Van Beek:
+   *   http://ai.uwaterloo.ca/~vanbeek/software/software.html
+   * The code (originally by John Tromp) here has only been slightly modified
+   * to fit %Gecode (taking idempotent/non-idempotent propagation into account)
+   * and uses a more efficient layout of datastructures (keeping the number
+   * of different arrays small).
+   *
+   * Requires \code #include "gecode/int/distinct.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Bnd : public Propagator {
+  protected:
+    /// Views on which to perform bounds-propagation
+    ViewArray<View> x;
+    /// Views on which to perform value-propagation (subset of \c x)
+    ViewArray<View> y;
+    /// Constructor for posting
+    Bnd(Space* home, ViewArray<View>& x);
+    /// Constructor for cloning \a p
+    Bnd(Space* home, bool share, Bnd<View>& p);
+  public:
+    /// Post propagator for view array \a x
+    static ExecStatus post(Space* home, ViewArray<View>& x);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /**
+     * \brief Cost function
+     *
+     * If in stage for naive value propagation, the cost is dynamic
+     * PC_LINEAR_LO. Otherwise it is dynamic PC_LINEAR_HI.
+     */
+    virtual PropCost cost(void) const;
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Destructor
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Perform bounds-consistent distinct propagation
+   *
+   * This is actually the propagation algorithm for Distinct::Bnd.
+   * It is available as separate function as it is reused for
+   * both bounds-consistent and domain-consistent distinct
+   * propagators.
+   */
+  template <class View>
+  ExecStatus prop_bnd(Space* home, ViewArray<View>& x, int m);
+
+
+  /**
+   * \brief Propagation controller for domain-consistent distinct
+   *
+   * The propagation controller provides convenient access to
+   * performing incremental domain-consistent distinct propagation
+   * so that the routines can be reused easily.
+   *
+   * Requires \code #include "gecode/int/distinct.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class DomCtrl {
+  protected:
+    /// View-value graph for propagation
+    class ViewValGraph;
+    /// Propagation is performed on a view-value graph (used as cache)
+    ViewValGraph* vvg;
+  public:
+    /// Initialize with non-existing view-value graph
+    DomCtrl(void);
+    /// Check whether a view-value graph is available
+    bool available(void);
+    /// Initialize view-value graph for views \a x
+    ExecStatus init(int n, View* x);
+    /// Synchronize available view-value graph
+    ExecStatus sync(void);
+    /// Perform propagation
+    void propagate(Space* home);
+    /// Returns size of view-value graph
+    size_t size(void) const;
+    /// Flush view-value graph
+    void flush(void);
+    /// Deallocate view-value graph
+    void dispose(void);
+  };
+
+  /**
+   * \brief Domain-consistent distinct propagator
+   *
+   * The propagator uses staging: first it uses naive value-based
+   * propagation and only then uses domain-consistent propagation.
+   *
+   * The algorithm is taken from:
+   *    Jean-Charles R�gin, A filtering algorithm for constraints
+   *    of difference in CSPs, Proceedings of the Twelfth National
+   *    Conference on Artificial Intelligence, pages 362--367.
+   *    Seattle, WA, USA, 1994.
+   *
+   * Requires \code #include "gecode/int/distinct.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Dom : public NaryPropagator<View,PC_INT_DOM> {
+  protected:
+    using NaryPropagator<View,PC_INT_DOM>::x;
+
+    /// Propagation controller
+    DomCtrl<View> dc;
+    /// Constructor for cloning \a p
+    Dom(Space* home, bool share, Dom<View>& p);
+    /// Constructor for posting
+    Dom(Space* home, ViewArray<View>& x);
+  public:
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /**
+     * \brief Cost function
+     *
+     * If in stage for naive value propagation, the cost is dynamic
+     * PC_LINEAR_LO. Otherwise it is dynamic PC_CUBIC_LO.
+     */
+    virtual PropCost cost(void) const;
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Flush view-value graph
+    virtual void flush(void);
+    /// Returns size of view-value graph
+    virtual size_t size(void) const;
+    /// Post propagator for views \a x
+    static  ExecStatus post(Space* home, ViewArray<View>& x);
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Ternary domain-consistent distinct propagator
+   *
+   * Requires \code #include "gecode/int/distinct.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class TerDom : public TernaryPropagator<View,PC_INT_DOM> {
+  protected:
+    using TernaryPropagator<View,PC_INT_DOM>::x0;
+    using TernaryPropagator<View,PC_INT_DOM>::x1;
+    using TernaryPropagator<View,PC_INT_DOM>::x2;
+
+    /// Constructor for cloning \a p
+    TerDom(Space* home, bool share, TerDom<View>& p);
+    /// Constructor for posting
+    TerDom(Space* home, View x0, View x1, View x2);
+  public:
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Post propagator for views \a x
+    static  ExecStatus post(Space* home, View x0, View x1, View x2);
+  };
+
+}}}
+
+#include "gecode/int/distinct/val.icc"
+#include "gecode/int/distinct/bnd.icc"
+#include "gecode/int/distinct/ter-dom.icc"
+#include "gecode/int/distinct/dom.icc"
+
+#endif
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/distinct/bilink.icc

@@ -0,0 +1,73 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Distinct {
+
+  forceinline
+  BiLink::BiLink(void) {
+    _prev = this; _next = this;
+  }
+
+  forceinline BiLink*
+  BiLink::prev(void) const {
+    return _prev;
+  }
+  forceinline BiLink*
+  BiLink::next(void) const {
+    return _next;
+  }
+  forceinline void
+  BiLink::prev(BiLink* l) {
+    _prev = l;
+  }
+  forceinline void
+  BiLink::next(BiLink* l) {
+    _next = l;
+  }
+
+  forceinline void
+  BiLink::add(BiLink* l) {
+    l->_prev = this; l->_next = _next;
+    _next->_prev = l; _next = l;
+  }
+  forceinline void
+  BiLink::unlink(void) {
+    BiLink* p = _prev; BiLink* n = _next;
+    p->_next = n; n->_prev = p;
+  }
+
+  forceinline void
+  BiLink::mark(void) {
+    _next = NULL;
+  }
+  forceinline bool
+  BiLink::marked(void) const {
+    return _next == NULL;
+  }
+  forceinline bool
+  BiLink::empty(void) const {
+    return _prev == this;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/distinct/bnd.icc

@@ -0,0 +1,335 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-10-23 16:16:09 +0200 (Mon, 23 Oct 2006) $ by $Author: schulte $
+ *     $Revision: 3768 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/support/sort.hh"
+
+namespace Gecode { namespace Int { namespace Distinct {
+
+  template <class View>
+  inline
+  Bnd<View>::Bnd(Space* home, ViewArray<View>& x0)
+    : Propagator(home), x(x0), y(home,x0) {
+    // Both x and y initially contain the same variables
+    //  - x is used for bounds propagation
+    //  - y is used for performing singleton propagation
+    // They can not be shared as singleton propagation removes
+    // determined variables still required for bounds propagation.
+    y.subscribe(home,this,PC_INT_BND);
+  }
+
+  template <class View>
+  size_t
+  Bnd<View>::dispose(Space* home) {
+    assert(!home->failed());
+    y.cancel(home,this,PC_INT_BND);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View>
+  forceinline
+  Bnd<View>::Bnd(Space* home, bool share, Bnd<View>& p)
+    : Propagator(home,share,p) {
+      x.update(home,share,p.x);
+      y.update(home,share,p.y);
+  }
+
+  template <class View>
+  Actor*
+  Bnd<View>::copy(Space* home, bool share) {
+    return new (home) Bnd<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  Bnd<View>::cost(void) const {
+    return (View::pme(this) == ME_INT_VAL)
+      ? cost_lo(y.size(),PC_LINEAR_LO)
+      : cost_hi(x.size(),PC_LINEAR_HI);
+  }
+
+
+  /// Rank information
+  class Rank {
+  public:
+    int min, max;
+  };
+
+  /// Sort-order by increasing maximum
+  template <class View>
+  class MaxInc {
+  protected:
+    ViewArray<View> x;
+  public:
+    MaxInc(const ViewArray<View>& x0) : x(x0) {}
+    forceinline bool
+    operator()(const int i, const int j) {
+      return x[i].max() < x[j].max();
+    }
+  };
+
+  /// Sort-order by increasing minimum
+  template <class View>
+  class MinInc {
+  public:
+    forceinline bool
+    operator()(const View& x, const View& y) {
+      return x.min() < y.min();
+    }
+  };
+
+  /// Information on Hall intervals
+  class HallInfo {
+  public:
+    int bounds, t, d, h;
+  };
+
+  inline void
+  pathset_t(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].t=to) {
+      l = hall[k].t;
+    }
+  }
+
+  inline void
+  pathset_h(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].h=to) {
+      l = hall[k].h;
+    }
+  }
+
+  forceinline int
+  pathmin_h(const HallInfo hall[], int i) {
+    while (hall[i].h < i)
+      i = hall[i].h;
+    return i;
+  }
+
+  forceinline int
+  pathmin_t(const HallInfo hall[], int i) {
+    while (hall[i].t < i)
+      i = hall[i].t;
+    return i;
+  }
+
+  forceinline int
+  pathmax_h(const HallInfo hall[], int i) {
+    while (hall[i].h > i)
+      i = hall[i].h;
+    return i;
+  }
+
+  forceinline int
+  pathmax_t(const HallInfo hall[], int i) {
+    while (hall[i].t > i)
+      i = hall[i].t;
+    return i;
+  }
+
+#define GECODE_INT_MINSORTED(i) (i)
+#define GECODE_INT_MAXSORTED(i) (_maxsorted[i])
+
+  template <class View>
+  ExecStatus
+  prop_bnd(Space* home, ViewArray<View>& x, int m) {
+    const int n = x.size();
+    // Sort variable array for minimum directly
+    {
+      MinInc<View> min_inc;
+      Support::insertion<View,MinInc<View> >(&x[0], n, min_inc);
+    }
+
+    GECODE_AUTOARRAY(int, _maxsorted, n);
+    for (int i = n; i--; )
+      _maxsorted[i]=i;
+
+    {
+      MaxInc<View> max_inc(x);
+      Support::insertion<int,MaxInc<View> >(_maxsorted, n, max_inc);
+    }
+
+    // Setup rank and bounds info
+    GECODE_AUTOARRAY(HallInfo, hall, 2*n+2);
+    GECODE_AUTOARRAY(Rank,     rank, n);
+
+    int nb = 0;
+    {
+      int min  = x[GECODE_INT_MINSORTED(0)].min();
+      int max  = x[GECODE_INT_MAXSORTED(0)].max() + 1;
+      int last = min - 2;
+
+      hall[0].bounds = last;
+
+      int i = 0;
+      int j = 0;
+      while (true) {
+	if (i < n && min < max) {
+	  if (min != last)
+	    hall[++nb].bounds = last = min;
+	  rank[GECODE_INT_MINSORTED(i)].min = nb;
+	  if (++i < n)
+	    min = x[GECODE_INT_MINSORTED(i)].min();
+	} else {
+	  if (max != last)
+	    hall[++nb].bounds = last = max;
+	  rank[GECODE_INT_MAXSORTED(j)].max = nb;
+	  if (++j == n)
+	    break;
+	  max = x[GECODE_INT_MAXSORTED(j)].max() + 1;
+	}
+      }
+      hall[nb+1].bounds = hall[nb].bounds + 2;
+    }
+
+    // If tells cross holes, we do not compute a fixpoint
+    ExecStatus es = ES_FIX;
+
+    // Propagate lower bounds
+    for (int i=nb+2; --i;) {
+      hall[i].t = hall[i].h = i-1;
+      hall[i].d = hall[i].bounds - hall[i-1].bounds;
+    }
+    for (int i=0; i<n; i++) { // visit intervals in increasing max order
+      int x0 = rank[GECODE_INT_MAXSORTED(i)].min;
+      int z = pathmax_t(hall, x0+1);
+      int j = hall[z].t;
+      if (--hall[z].d == 0)
+	hall[z = pathmax_t(hall, hall[z].t=z+1)].t = j;
+      pathset_t(hall, x0+1, z, z); // path compression
+      int y = rank[GECODE_INT_MAXSORTED(i)].max;
+      if (hall[z].d < hall[z].bounds-hall[y].bounds)
+	return ES_FAILED;
+      if (hall[x0].h > x0) {
+	int w = pathmax_h(hall, hall[x0].h);
+	int m = hall[w].bounds;
+	ModEvent me = x[GECODE_INT_MAXSORTED(i)].gq(home,m);
+	if (me_failed(me))
+	  return ES_FAILED;
+	if ((me == ME_INT_VAL) || 
+	    ((me == ME_INT_BND) && (m != x[GECODE_INT_MAXSORTED(i)].min())))
+	  es = ES_NOFIX;
+	pathset_h(hall, x0, w, w); // path compression
+      }
+      if (hall[z].d == hall[z].bounds-hall[y].bounds) {
+	pathset_h(hall, hall[y].h, j-1, y); // mark hall interval
+	hall[y].h = j-1;
+      }
+    }
+
+    // Propagate upper bounds
+    for (int i=nb+1; i--;) {
+      hall[i].t = hall[i].h = i+1;
+      hall[i].d = hall[i+1].bounds - hall[i].bounds;
+    }
+    for (int i=n; --i>=0; ) { // visit intervals in decreasing min order
+      int x0 = rank[GECODE_INT_MINSORTED(i)].max;
+      int z = pathmin_t(hall, x0-1);
+      int j = hall[z].t;
+      if (--hall[z].d == 0)
+	hall[z = pathmin_t(hall, hall[z].t=z-1)].t = j;
+      pathset_t(hall, x0-1, z, z);
+      int y = rank[GECODE_INT_MINSORTED(i)].min;
+      if (hall[z].d < hall[y].bounds-hall[z].bounds)
+	return ES_FAILED;
+      if (hall[x0].h < x0) {
+	int w = pathmin_h(hall, hall[x0].h);
+	int m = hall[w].bounds - 1;
+	ModEvent me = x[GECODE_INT_MINSORTED(i)].lq(home,m);
+	if (me_failed(me))
+	  return ES_FAILED;
+	if ((me == ME_INT_VAL) || 
+	    ((me == ME_INT_BND) && (m != x[GECODE_INT_MAXSORTED(i)].min())))
+	  es = ES_NOFIX;
+	pathset_h(hall, x0, w, w);
+      }
+      if (hall[z].d == hall[y].bounds-hall[z].bounds) {
+	pathset_h(hall, hall[y].h, j+1, y);
+	hall[y].h = j+1;
+      }
+    }
+
+    if ((n > 2*m) && (n > 6)) {
+      // If there are many assigned views, try to eliminate them
+      MinInc<View> min_inc;
+      Support::insertion<View,MinInc<View> >(&x[0], n, min_inc);
+      int i   = 0;
+      int j   = 0;
+      int max = x[0].max()-1;
+      while (i < n-1) {
+	if (!x[i].assigned() ||
+	    (x[i].val() <= max) || (x[i].val() > x[i+1].min())) {
+	  // Keep view x[i]
+	  max = std::max(max,x[i].max());
+	  x[j++]=x[i];
+	}
+	i++;
+      }
+      if (!x[i].assigned() || (x[i].val() <= max))
+	x[j++]=x[i];
+      x.size(j);
+      if (j < 2)
+	return ES_SUBSUMED;
+    }
+
+    return es;
+  }
+
+#undef GECODE_INT_MINSORTED
+#undef GECODE_INT_MAXSORTED
+
+  template <class View>
+  ExecStatus
+  Bnd<View>::propagate(Space* home) {
+    assert(x.size() > 1);
+
+    if (View::pme(this) == ME_INT_VAL) {
+      ExecStatus es = prop_val<View,false>(home,y);
+      if ((es == ES_FAILED) || (es == ES_SUBSUMED))
+	return es;
+      if (es == ES_FIX)
+	return ES_FIX_PARTIAL(View::pme(ME_INT_BND));
+    }
+
+    if (y.size() == 2) {
+      GECODE_ES_CHECK(Rel::Nq<View>::post(home,y[0],y[1]));
+      return ES_SUBSUMED;
+    }
+
+    return prop_bnd<View>(home,x,y.size());
+  }
+
+  template <class View>
+  ExecStatus
+  Bnd<View>::post(Space* home, ViewArray<View>& x){
+    if (x.size() == 2)
+      return Rel::Nq<View>::post(home,x[0],x[1]);
+    if (x.size() > 2)
+      (void) new (home) Bnd<View>(home,x);
+    return ES_OK;
+  }
+
+
+}}}
+
+// STATISTICS: int-prop
+