dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/propagator.hpp

@@ -0,0 +1,311 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2010-03-15 08:08:40 +1100 (Mon, 15 Mar 2010) $ by $Author: schulte $
+ *     $Revision: 10426 $
+ *
+ *  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 {
+
+  /**
+   * \defgroup TaskPropRePat Reified propagator patterns
+   *
+   * \ingroup TaskActor
+   */
+
+  //@{
+  /**
+   * \brief Reified unary propagator
+   *
+   * Stores single view of type \a View with propagation condition \a pc
+   * and a Boolean control view of type \a CtrlView.
+   *
+   * If the propagation condition \a pc has the value PC_GEN_NONE, no
+   * subscriptions are created for \a View.
+   *
+   */
+  template<class View, PropCond pc, class CtrlView>
+  class ReUnaryPropagator : public Propagator {
+  protected:
+    /// Single view
+    View x0;
+    /// Boolean control view
+    CtrlView b;
+    /// Constructor for cloning \a p
+    ReUnaryPropagator(Space& home, bool share, ReUnaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    ReUnaryPropagator(Space& home, bool share, Propagator& p,
+                      View x0, CtrlView b);
+    /// Constructor for creation
+    ReUnaryPropagator(Space& home, View x0, CtrlView b);
+  public:
+    /// Cost function (defined as low unary)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+  };
+
+  /**
+   * \brief Reified binary propagator
+   *
+   * Stores two views of type \a View with propagation condition \a pc
+   * and a Boolean control view of type \a CtrlView.
+   *
+   * If the propagation condition \a pc has the value PC_GEN_NONE, no
+   * subscriptions are created for \a View.
+   *
+   */
+  template<class View, PropCond pc, class CtrlView>
+  class ReBinaryPropagator : public Propagator {
+  protected:
+    /// Two views
+    View x0, x1;
+    /// Boolean control view
+    CtrlView b;
+    /// Constructor for cloning \a p
+    ReBinaryPropagator(Space& home, bool share, ReBinaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    ReBinaryPropagator(Space& home, bool share, Propagator& p,
+                       View x0, View x1, CtrlView b);
+    /// Constructor for creation
+    ReBinaryPropagator(Space& home, View x0, View x1, CtrlView b);
+  public:
+    /// Cost function (defined as low binary)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+  };
+  //@}
+
+
+  /**
+   * \brief Reified mixed binary propagator
+   *
+   * Stores two views of type \a View0 and \a View1 with propagation
+   * conditions \a pc0 and \a pc1 and a Boolean control view of type 
+   * \a CtrlView.
+   *
+   * If the propagation conditions \a pc0 or \a pc1 have the values
+   * PC_GEN_NONE, no subscriptions are created.
+   *
+   */
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  class ReMixBinaryPropagator : public Propagator {
+  protected:
+    /// View of type \a View0
+    View0 x0;
+    /// View of type \a View1
+    View1 x1;
+    /// Boolean control view
+    CtrlView b;
+    /// Constructor for cloning \a p
+    ReMixBinaryPropagator(Space& home, bool share, ReMixBinaryPropagator& p);
+    /// Constructor for creation
+    ReMixBinaryPropagator(Space& home, View0 x0, View1 x1, CtrlView b);
+    /// Constructor for rewriting \a p during cloning
+    ReMixBinaryPropagator(Space& home, bool share, Propagator& p,
+                          View0 x0, View1 x1, CtrlView b);
+  public:
+    /// Cost function (defined as low binary)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+  };
+
+
+  /*
+   * Reified unary propagators
+   *
+   */
+  template<class View, PropCond pc, class CtrlView>
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space& home, View y0, CtrlView b0)
+    : Propagator(home), x0(y0), b(b0) {
+    if (pc != PC_GEN_NONE)
+      x0.subscribe(home,*this,pc);
+    b.subscribe(home,*this,Int::PC_INT_VAL);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space& home, bool share, ReUnaryPropagator<View,pc,CtrlView>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    b.update(home,share,p.b);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline
+  ReUnaryPropagator<View,pc,CtrlView>::ReUnaryPropagator
+  (Space& home, bool share, Propagator& p, View y0, CtrlView b0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    b.update(home,share,b0);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  PropCost
+  ReUnaryPropagator<View,pc,CtrlView>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::unary(PropCost::LO);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline size_t
+  ReUnaryPropagator<View,pc,CtrlView>::dispose(Space& home) {
+    if (pc != PC_GEN_NONE)
+      x0.cancel(home,*this,pc);
+    b.cancel(home,*this,Int::PC_INT_VAL);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  /*
+   * Reified binary propagators
+   *
+   */
+  template<class View, PropCond pc, class CtrlView>
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space& home, View y0, View y1, CtrlView b1)
+    : Propagator(home), x0(y0), x1(y1), b(b1) {
+    if (pc != PC_GEN_NONE) {
+      x0.subscribe(home,*this,pc);
+      x1.subscribe(home,*this,pc);
+    }
+    b.subscribe(home,*this,Int::PC_INT_VAL);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space& home, bool share, ReBinaryPropagator<View,pc,CtrlView>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline
+  ReBinaryPropagator<View,pc,CtrlView>::ReBinaryPropagator
+  (Space& home, bool share, Propagator& p, View y0, View y1, CtrlView b0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    b.update(home,share,b0);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  PropCost
+  ReBinaryPropagator<View,pc,CtrlView>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::binary(PropCost::LO);
+  }
+
+  template<class View, PropCond pc, class CtrlView>
+  forceinline size_t
+  ReBinaryPropagator<View,pc,CtrlView>::dispose(Space& home) {
+    if (pc != PC_GEN_NONE) {
+      x0.cancel(home,*this,pc);
+      x1.cancel(home,*this,pc);
+    }
+    b.cancel(home,*this,Int::PC_INT_VAL);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  /*
+   * Reified mixed binary propagator
+   *
+   */
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>
+  ::ReMixBinaryPropagator(Space& home, View0 y0, View1 y1, CtrlView b1)
+    : Propagator(home), x0(y0), x1(y1), b(b1) {
+    if (pc0 != PC_GEN_NONE)
+      x0.subscribe(home,*this,pc0);
+    if (pc1 != PC_GEN_NONE)
+      x1.subscribe(home,*this,pc1);
+    b.subscribe(home,*this,Int::PC_INT_VAL);
+  }
+
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  forceinline
+  ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>::ReMixBinaryPropagator
+  (Space& home, bool share, 
+   ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  forceinline
+  ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>
+  ::ReMixBinaryPropagator
+  (Space& home, bool share, Propagator& p, View0 y0, View1 y1, CtrlView b0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    b.update(home,share,b0);
+  }
+
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  PropCost
+  ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>
+  ::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::binary(PropCost::LO);
+  }
+
+  template<class View0, PropCond pc0, class View1, PropCond pc1,
+            class CtrlView>
+  forceinline size_t
+  ReMixBinaryPropagator<View0,pc0,View1,pc1,CtrlView>::dispose(Space& home) {
+    if (pc0 != PC_GEN_NONE)
+      x0.cancel(home,*this,pc0);
+    if (pc1 != PC_GEN_NONE)
+      x1.cancel(home,*this,pc1);
+    b.cancel(home,*this,Int::PC_INT_VAL);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+}}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/rel.cpp

@@ -0,0 +1,381 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2011-07-07 05:56:28 +1000 (Thu, 07 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12151 $
+ *
+ *  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>
+#include <gecode/int/bool.hh>
+
+#include <algorithm>
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  rel(Home home, IntVar x0, IntRelType r, int n, IntConLevel) {
+    Limits::check(n,"Int::rel");
+    if (home.failed()) return;
+    IntView x(x0);
+    switch (r) {
+    case IRT_EQ: GECODE_ME_FAIL(x.eq(home,n)); break;
+    case IRT_NQ: GECODE_ME_FAIL(x.nq(home,n)); break;
+    case IRT_LQ: GECODE_ME_FAIL(x.lq(home,n)); break;
+    case IRT_LE: GECODE_ME_FAIL(x.le(home,n)); break;
+    case IRT_GQ: GECODE_ME_FAIL(x.gq(home,n)); break;
+    case IRT_GR: GECODE_ME_FAIL(x.gr(home,n)); break;
+    default: throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, const IntVarArgs& x, IntRelType r, int n, IntConLevel) {
+    Limits::check(n,"Int::rel");
+    if (home.failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.eq(home,n));
+      }
+      break;
+    case IRT_NQ:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.nq(home,n));
+      }
+      break;
+    case IRT_LQ:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,n));
+      }
+      break;
+    case IRT_LE:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.le(home,n));
+      }
+      break;
+    case IRT_GQ:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,n));
+      }
+      break;
+    case IRT_GR:
+      for (int i=x.size(); i--; ) {
+        IntView xi(x[i]); GECODE_ME_FAIL(xi.gr(home,n));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, IntVar x0, IntRelType r, IntVar x1, IntConLevel icl) {
+    if (home.failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
+        GECODE_ES_FAIL((Rel::EqDom<IntView,IntView>::post(home,x0,x1)));
+      } else {
+        GECODE_ES_FAIL((Rel::EqBnd<IntView,IntView>::post(home,x0,x1)));
+      }
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(Rel::Nq<IntView>::post(home,x0,x1)); break;
+    case IRT_GQ:
+      std::swap(x0,x1); // Fall through
+    case IRT_LQ:
+      GECODE_ES_FAIL(Rel::Lq<IntView>::post(home,x0,x1)); break;
+    case IRT_GR:
+      std::swap(x0,x1); // Fall through
+    case IRT_LE:
+      GECODE_ES_FAIL(Rel::Le<IntView>::post(home,x0,x1)); break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, const IntVarArgs& x, IntRelType r, IntVar y,
+      IntConLevel icl) {
+    if (home.failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<IntView> xv(home,x.size()+1);
+        xv[x.size()]=y;
+        for (int i=x.size(); i--; )
+          xv[i]=x[i];
+        if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
+          GECODE_ES_FAIL(Rel::NaryEqDom<IntView>::post(home,xv));
+        } else {
+          GECODE_ES_FAIL(Rel::NaryEqBnd<IntView>::post(home,xv));
+        }
+      }
+      break;
+    case IRT_NQ:
+      for (int i=x.size(); i--; ) {
+        GECODE_ES_FAIL(Rel::Nq<IntView>::post(home,x[i],y));
+      }
+      break;
+    case IRT_GQ:
+      for (int i=x.size(); i--; ) {
+        GECODE_ES_FAIL(Rel::Lq<IntView>::post(home,y,x[i]));
+      }
+      break;
+    case IRT_LQ:
+      for (int i=x.size(); i--; ) {
+        GECODE_ES_FAIL(Rel::Lq<IntView>::post(home,x[i],y));
+      }
+      break;
+    case IRT_GR:
+      for (int i=x.size(); i--; ) {
+        GECODE_ES_FAIL(Rel::Le<IntView>::post(home,y,x[i]));
+      }
+      break;
+    case IRT_LE:
+      for (int i=x.size(); i--; ) {
+        GECODE_ES_FAIL(Rel::Le<IntView>::post(home,x[i],y));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+
+  void
+  rel(Home home, IntVar x0, IntRelType r, IntVar x1, BoolVar b,
+      IntConLevel icl) {
+    if (home.failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
+        GECODE_ES_FAIL((Rel::ReEqDom<IntView,BoolView>::post(home,x0,x1,b)));
+      } else {
+        GECODE_ES_FAIL((Rel::ReEqBnd<IntView,BoolView>::post(home,x0,x1,b)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        NegBoolView n(b);
+        if (icl == ICL_BND) {
+          GECODE_ES_FAIL((Rel::ReEqBnd<IntView,NegBoolView>
+                          ::post(home,x0,x1,n)));
+        } else {
+          GECODE_ES_FAIL((Rel::ReEqDom<IntView,NegBoolView>
+                          ::post(home,x0,x1,n)));
+        }
+      }
+      break;
+    case IRT_GQ:
+      std::swap(x0,x1); // Fall through
+    case IRT_LQ:
+      GECODE_ES_FAIL((Rel::ReLq<IntView,BoolView>::post(home,x0,x1,b)));
+      break;
+    case IRT_LE:
+      std::swap(x0,x1); // Fall through
+    case IRT_GR:
+      {
+        NegBoolView n(b);
+        GECODE_ES_FAIL((Rel::ReLq<IntView,NegBoolView>::post(home,x0,x1,n)));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, IntVar x, IntRelType r, int n, BoolVar b,
+      IntConLevel icl) {
+    Limits::check(n,"Int::rel");
+    if (home.failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
+        GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,BoolView>
+                        ::post(home,x,n,b)));
+      } else {
+        GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,BoolView>
+                        ::post(home,x,n,b)));
+      }
+      break;
+    case IRT_NQ:
+      {
+        NegBoolView nb(b);
+        if (icl == ICL_BND) {
+          GECODE_ES_FAIL((Rel::ReEqBndInt<IntView,NegBoolView>
+                          ::post(home,x,n,nb)));
+        } else {
+          GECODE_ES_FAIL((Rel::ReEqDomInt<IntView,NegBoolView>
+                          ::post(home,x,n,nb)));
+        }
+      }
+      break;
+    case IRT_LE:
+      n--; // Fall through
+    case IRT_LQ:
+      GECODE_ES_FAIL((Rel::ReLqInt<IntView,BoolView>
+                      ::post(home,x,n,b)));
+      break;
+    case IRT_GQ:
+      n--; // Fall through
+    case IRT_GR:
+      {
+        NegBoolView nb(b);
+        GECODE_ES_FAIL((Rel::ReLqInt<IntView,NegBoolView>
+                        ::post(home,x,n,nb)));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, const IntVarArgs& x, IntRelType r,
+      IntConLevel icl) {
+    if (home.failed() || ((r != IRT_NQ) && (x.size() < 2))) 
+      return;
+    switch (r) {
+    case IRT_EQ:
+      {
+        ViewArray<IntView> xv(home,x);
+        if ((icl == ICL_DOM) || (icl == ICL_DEF)) {
+          GECODE_ES_FAIL(Rel::NaryEqDom<IntView>::post(home,xv));
+        } else {
+          GECODE_ES_FAIL(Rel::NaryEqBnd<IntView>::post(home,xv));
+        }
+      }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<IntView> y(home,x);
+        GECODE_ES_FAIL((Rel::NaryNq<IntView>::post(home,y)));
+      }
+      break;
+    case IRT_LE:
+      {
+        ViewArray<IntView> y(home,x);
+        GECODE_ES_FAIL((Rel::NaryLqLe<IntView,1>::post(home,y)));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<IntView> y(home,x);
+        GECODE_ES_FAIL((Rel::NaryLqLe<IntView,0>::post(home,y)));
+      }
+      break;
+    case IRT_GR:
+      {
+        ViewArray<IntView> y(home,x.size());
+        for (int i=x.size(); i--; )
+          y[i] = x[x.size()-1-i];
+        GECODE_ES_FAIL((Rel::NaryLqLe<IntView,1>::post(home,y)));
+      }
+      for (int i=x.size()-1; i--; )
+        GECODE_ES_FAIL(Rel::Le<IntView>::post(home,x[i+1],x[i]));
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<IntView> y(home,x.size());
+        for (int i=x.size(); i--; )
+          y[i] = x[x.size()-1-i];
+        GECODE_ES_FAIL((Rel::NaryLqLe<IntView,0>::post(home,y)));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Home home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
+      IntConLevel icl) {
+    if (home.failed()) return;
+
+    switch (r) {
+    case IRT_GR:
+      {
+        ViewArray<IntView> xv(home,x), yv(home,y);
+        GECODE_ES_FAIL(Rel::LexLqLe<IntView>::post(home,yv,xv,true));
+      }
+      break;
+    case IRT_LE:
+      {
+        ViewArray<IntView> xv(home,x), yv(home,y);
+        GECODE_ES_FAIL(Rel::LexLqLe<IntView>::post(home,xv,yv,true));
+      }
+      break;
+    case IRT_GQ:
+      {
+        ViewArray<IntView> xv(home,x), yv(home,y);
+        GECODE_ES_FAIL(Rel::LexLqLe<IntView>::post(home,yv,xv,false));
+      }
+      break;
+    case IRT_LQ:
+      {
+        ViewArray<IntView> xv(home,x), yv(home,y);
+        GECODE_ES_FAIL(Rel::LexLqLe<IntView>::post(home,xv,yv,false));
+      }
+      break;
+    case IRT_EQ:
+      if (x.size() != y.size()) {
+        home.fail();
+      } else if ((icl == ICL_DOM) || (icl == ICL_DEF))
+        for (int i=x.size(); i--; ) {
+          GECODE_ES_FAIL((Rel::EqDom<IntView,IntView>
+                          ::post(home,x[i],y[i])));
+        }
+      else
+        for (int i=x.size(); i--; ) {
+          GECODE_ES_FAIL((Rel::EqBnd<IntView,IntView>
+                          ::post(home,x[i],y[i])));
+        }
+      break;
+    case IRT_NQ:
+      {
+        ViewArray<IntView> xv(home,x), yv(home,y);
+        GECODE_ES_FAIL(Rel::LexNq<IntView>::post(home,xv,yv));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+}
+
+// STATISTICS: int-post