gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,293 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Gabor Szokoli, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3579 $
+ *
+ *  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/rel.hh"
+
+#include <algorithm>
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  rel(Space* home, IntVar x0, IntRelType r, int n, IntConLevel) {
+    if (home->failed()) return;
+    IntView x(x0);
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ME_FAIL(home,x.eq(home,n)); break;
+    case IRT_NQ:
+      GECODE_ME_FAIL(home,x.nq(home,n)); break;
+    case IRT_LQ:
+      GECODE_ME_FAIL(home,x.lq(home,n)); break;
+    case IRT_LE:
+      GECODE_ME_FAIL(home,x.le(home,n)); break;
+    case IRT_GQ:
+      GECODE_ME_FAIL(home,x.gq(home,n)); break;
+    case IRT_GR:
+      GECODE_ME_FAIL(home,x.gr(home,n)); break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Space* home, IntVar x0, IntRelType r, IntVar x1, IntConLevel icl) {
+    if (home->failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if (icl == ICL_BND) {
+	GECODE_ES_FAIL(home,(Rel::EqBnd<IntView,IntView>::post(home,x0,x1)));
+      } else {
+	GECODE_ES_FAIL(home,(Rel::EqDom<IntView,IntView>::post(home,x0,x1)));
+      }
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(home,Rel::Nq<IntView>::post(home,x0,x1)); break;
+    case IRT_GQ:
+      std::swap(x0,x1); // Fall through
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,Rel::Lq<IntView>::post(home,x0,x1)); break;
+    case IRT_GR:
+      std::swap(x0,x1); // Fall through
+    case IRT_LE:
+      GECODE_ES_FAIL(home,Rel::Le<IntView>::post(home,x0,x1)); break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+
+  void
+  rel(Space* home, IntVar x0, IntRelType r, IntVar x1, BoolVar b,
+      IntConLevel icl) {
+    if (home->failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if (icl == ICL_BND) {
+	GECODE_ES_FAIL(home,(Rel::ReEqBnd<IntView,BoolView>
+			     ::post(home,x0,x1,b)));
+      } else {
+	GECODE_ES_FAIL(home,(Rel::ReEqDom<IntView,BoolView>
+			     ::post(home,x0,x1,b)));
+      }
+      break;
+    case IRT_NQ:
+      {
+	NegBoolView n(b);
+	if (icl == ICL_BND) {
+	  GECODE_ES_FAIL(home,(Rel::ReEqBnd<IntView,NegBoolView>
+			       ::post(home,x0,x1,n)));
+	} else {
+	  GECODE_ES_FAIL(home,(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(home,(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(home,(Rel::ReLq<IntView,NegBoolView>::post(home,x0,x1,n)));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  rel(Space* home, IntVar x, IntRelType r, int n, BoolVar b,
+      IntConLevel icl) {
+    if (home->failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      if (icl == ICL_BND) {
+	GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,BoolView>
+			     ::post(home,x,n,b)));
+      } else {
+	GECODE_ES_FAIL(home,(Rel::ReEqDomInt<IntView,BoolView>
+			     ::post(home,x,n,b)));
+      }
+      break;
+    case IRT_NQ:
+      {
+	NegBoolView nb(b);
+	if (icl == ICL_BND) {
+	  GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,NegBoolView>
+			       ::post(home,x,n,nb)));
+	} else {
+	  GECODE_ES_FAIL(home,(Rel::ReEqDomInt<IntView,NegBoolView>
+			       ::post(home,x,n,nb)));
+	}
+      }
+      break;
+    case IRT_LE:
+      n--; // Fall through
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,(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(home,(Rel::ReLqInt<IntView,NegBoolView>
+			     ::post(home,x,n,nb)));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+  void
+  eq(Space* home, IntVar x0, IntVar x1, IntConLevel icl) {
+    if (home->failed()) return;
+    if (icl == ICL_BND) {
+      GECODE_ES_FAIL(home,(Rel::EqBnd<IntView,IntView>::post(home,x0,x1)));
+    } else {
+      GECODE_ES_FAIL(home,(Rel::EqDom<IntView,IntView>::post(home,x0,x1)));
+    }
+  }
+
+  void
+  eq(Space* home, IntVar x0, int n, IntConLevel) {
+    if (home->failed()) return;
+    IntView x(x0);
+    GECODE_ME_FAIL(home,x.eq(home,n));
+  }
+
+  void
+  eq(Space* home, IntVar x0, IntVar x1, BoolVar b, IntConLevel icl) {
+    if (home->failed()) return;
+    if (icl == ICL_BND) {
+      GECODE_ES_FAIL(home,(Rel::ReEqBnd<IntView,BoolView>::post(home,x0,x1,b)));
+    } else {
+      GECODE_ES_FAIL(home,(Rel::ReEqDom<IntView,BoolView>::post(home,x0,x1,b)));
+    }
+  }
+
+  void
+  eq(Space* home, IntVar x, int n, BoolVar b, IntConLevel icl) {
+    if (home->failed()) return;
+    if (icl == ICL_BND) {
+      GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,BoolView>::post(home,x,n,b)));
+    } else {
+      GECODE_ES_FAIL(home,(Rel::ReEqDomInt<IntView,BoolView>::post(home,x,n,b)));
+    }
+  }
+
+  void
+  eq(Space* home, const IntVarArgs& x, IntConLevel icl) {
+    if (home->failed()) return;
+    ViewArray<IntView> xv(home,x);
+    if (icl == ICL_BND) {
+      GECODE_ES_FAIL(home,Rel::NaryEqBnd<IntView>::post(home,xv));
+    } else {
+      GECODE_ES_FAIL(home,Rel::NaryEqDom<IntView>::post(home,xv));
+    }
+  }
+
+
+  void
+  rel(Space* home, const IntVarArgs& x, IntRelType r, const IntVarArgs& y,
+      IntConLevel icl) {
+    if (x.size() != y.size())
+      throw ArgumentSizeMismatch("Int::rel");
+    if (home->failed()) return;
+
+    switch (r) {
+    case IRT_GR: 
+      {
+	ViewArray<ViewTuple<IntView,2> > xy(home,x.size());
+	for (int i = x.size(); i--; ) {
+	  xy[i][0]=y[i]; xy[i][1]=x[i];
+	}
+	GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xy,true));
+      }
+      break;
+    case IRT_LE: 
+      {
+	ViewArray<ViewTuple<IntView,2> > xy(home,x.size());
+	for (int i = x.size(); i--; ) {
+	  xy[i][0]=x[i]; xy[i][1]=y[i];
+	}
+	GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xy,true));
+      }
+      break;
+    case IRT_GQ: 
+      {
+	ViewArray<ViewTuple<IntView,2> > xy(home,x.size());
+	for (int i = x.size(); i--; ) {
+	  xy[i][0]=y[i]; xy[i][1]=x[i];
+	}
+	GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xy,false));
+      }
+      break;
+    case IRT_LQ: 
+      {
+	ViewArray<ViewTuple<IntView,2> > xy(home,x.size());
+	for (int i = x.size(); i--; ) {
+	  xy[i][0]=x[i]; xy[i][1]=y[i];
+	}
+	GECODE_ES_FAIL(home,Rel::Lex<IntView>::post(home,xy,false));
+      }
+      break;
+    case IRT_EQ:
+      if (icl == ICL_BND)
+	for (int i=x.size(); i--; ) {
+	  GECODE_ES_FAIL(home,(Rel::EqBnd<IntView,IntView>
+			       ::post(home,x[i],y[i])));
+	}
+      else
+	for (int i=x.size(); i--; ) {
+	  GECODE_ES_FAIL(home,(Rel::EqDom<IntView,IntView>
+			       ::post(home,x[i],y[i])));
+	}
+      break;
+    case IRT_NQ: 
+      {
+	ViewArray<ViewTuple<IntView,2> > xy(home,x.size());
+	for (int i = x.size(); i--; ) {
+	  xy[i][0]=x[i]; xy[i][1]=y[i];
+	}
+	GECODE_ES_FAIL(home,Rel::NaryNq<IntView>::post(home,xy));
+      }
+      break;
+    default:
+      throw UnknownRelation("Int::rel");
+    }
+  }
+
+}
+
+// STATISTICS: int-post
+

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

@@ -0,0 +1,526 @@
+/*
+ *  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-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3579 $
+ *
+ *  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_REL_HH__
+#define __GECODE_INT_REL_HH__
+
+#include "gecode/int.hh"
+
+#include "gecode/iter.hh"
+
+/**
+ * \namespace Gecode::Int::Rel
+ * \brief Simple relation propagators
+ */
+
+namespace Gecode { namespace Int { namespace Rel {
+
+  /*
+   * Equality propagators
+   *
+   */
+
+  /**
+   * \brief Binary domain-consistent equality propagator
+   *
+   * Uses staging by first performing bounds propagation and only
+   * then domain propagation.
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View0,class View1>
+  class EqDom :
+    public InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM> {
+  protected:
+    using InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>::x0;
+    using InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>::x1;
+
+    /// Constructor for cloning \a p
+    EqDom(Space* home, bool share, EqDom<View0,View1>& p);
+    /// Constructor for posting
+    EqDom(Space* home, View0 x0, View1 x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If a view has been assigned, the cost is PC_UNARY_LO.
+     * If in stage for bounds propagation, the cost is
+     * PC_BINARY_LO. Otherwise it is PC_BINARY_HI.
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post domain-consistent propagator \f$ x_0 = x_1\f$
+    static  ExecStatus post(Space* home, View0 x0, View1 x1);
+  };
+
+  /**
+   * \brief Binary bounds-consistent equality propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View0, class View1>
+  class EqBnd :
+    public InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND> {
+  protected:
+    using InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>::x0;
+    using InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>::x1;
+
+    /// Constructor for cloning \a p
+    EqBnd(Space* home, bool share, EqBnd<View0,View1>& p);
+    /// Constructor for posting
+    EqBnd(Space* home, View0 x0, View1 x1);
+  public:
+    /// Constructor for rewriting \a p during cloning
+    EqBnd(Space* home, bool share, Propagator& p, View0 x0, View1 x1);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post bounds-consistent propagator \f$ x_0 = x_1\f$
+    static  ExecStatus post(Space* home, View0 x0, View1 x1);
+  };
+
+  /**
+   * \brief n-ary domain-consistent equality propagator
+   *
+   * Uses staging by first performing bounds propagation and only
+   * then domain propagation.
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class NaryEqDom : public NaryPropagator<View,PC_INT_DOM> {
+  protected:
+    using NaryPropagator<View,PC_INT_DOM>::x;
+
+    /// Constructor for cloning \a p
+    NaryEqDom(Space* home, bool share, NaryEqDom<View>& p);
+    /// Constructor for posting
+    NaryEqDom(Space* home, ViewArray<View>&);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If a view has been assigned, the cost is PC_UNARY_LO.
+     * If in stage for bounds propagation, the cost is dynamic
+     * PC_LINEAR_LO. Otherwise it is dynamic PC_LINEAR_HI.
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post domain-consistent propagator \f$ x_0 = x_1=\ldots =x_{|x|-1}\f$
+    static  ExecStatus post(Space* home, ViewArray<View>& x);
+  };
+
+  /**
+   * \brief n-ary bounds-consistent equality propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class NaryEqBnd : public NaryPropagator<View,PC_INT_BND> {
+  protected:
+    using NaryPropagator<View,PC_INT_BND>::x;
+
+    /// Constructor for cloning \a p
+    NaryEqBnd(Space* home, bool share, NaryEqBnd<View>& p);
+    /// Constructor for posting
+    NaryEqBnd(Space* home, ViewArray<View>&);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If a view has been assigned, the cost is PC_UNARY_LO.
+     * Otherwise it is dynamic PC_LINEAR_HI.
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post bounds-consistent propagator \f$ x_0 = x_1=\ldots =x_{|x|-1}\f$
+    static  ExecStatus post(Space* home, ViewArray<View>& x);
+  };
+
+  /**
+   * \brief Reified binary domain-consistent equality propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class CtrlView>
+  class ReEqDom : public ReBinaryPropagator<View,PC_INT_DOM,CtrlView> {
+  protected:
+    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::x0;
+    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::x1;
+    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::b;
+
+    /// Constructor for cloning \a p
+    ReEqDom(Space* home, bool share, ReEqDom& p);
+    /// Constructor for posting
+    ReEqDom(Space* home, View x0, View x1, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post domain-consistent propagator \f$ (x_0 = x_1)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
+  };
+
+  /**
+   * \brief Reified binary bounds-consistent equality propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class CtrlView>
+  class ReEqBnd : public ReBinaryPropagator<View,PC_INT_BND,CtrlView> {
+  protected:
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x0;
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x1;
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::b;
+
+    /// Constructor for cloning \a p
+    ReEqBnd(Space* home, bool share, ReEqBnd& p);
+    /// Constructor for posting
+    ReEqBnd(Space* home, View x0, View x1, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*     copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post bounds-consistent propagator \f$ (x_0 = x_1)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
+  };
+
+  /**
+   * \brief Reified domain-consistent equality with integer propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class CtrlView>
+  class ReEqDomInt : public ReUnaryPropagator<View,PC_INT_DOM,CtrlView> {
+  protected:
+    using ReUnaryPropagator<View,PC_INT_DOM,CtrlView>::x0;
+    using ReUnaryPropagator<View,PC_INT_DOM,CtrlView>::b;
+
+    /// Integer constant to check
+    int c;
+    /// Constructor for cloning \a p
+    ReEqDomInt(Space* home, bool share, ReEqDomInt& p);
+    /// Constructor for posting
+    ReEqDomInt(Space* home, View x, int c, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post domain-consistent propagator \f$ (x = c)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
+  };
+
+  /**
+   * \brief Reified bounds-consistent equality with integer propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, class CtrlView>
+  class ReEqBndInt : public ReUnaryPropagator<View,PC_INT_BND,CtrlView> {
+  protected:
+    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::x0;
+    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::b;
+
+    /// Integer constant to check
+    int c;
+    /// Constructor for cloning \a p
+    ReEqBndInt(Space* home, bool share, ReEqBndInt& p);
+    /// Constructor for posting
+    ReEqBndInt(Space* home, View x, int c, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post bounds-consistent propagator \f$ (x = c)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
+  };
+
+
+
+
+  /*
+   * Disequality propagators
+   *
+   */
+
+  /**
+   * \brief Binary disequality propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+
+  template <class View>
+  class Nq : public BinaryPropagator<View,PC_INT_VAL> {
+  protected:
+    using BinaryPropagator<View,PC_INT_VAL>::x0;
+    using BinaryPropagator<View,PC_INT_VAL>::x1;
+
+    /// Constructor for cloning \a p
+    Nq(Space* home, bool share, Nq<View>& p);
+    /// Constructor for posting
+    Nq(Space* home, View x0, View x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost function (defined as PC_UNARY_LO)
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator \f$x_0\neq x_1\f$
+    static  ExecStatus post(Space* home, View x0, View x1);
+  };
+
+  /*
+   * Order propagators
+   *
+   */
+
+  /**
+   * \brief Less or equal propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+
+  template <class View>
+  class Lq : public BinaryPropagator<View,PC_INT_BND> {
+  protected:
+    using BinaryPropagator<View,PC_INT_BND>::x0;
+    using BinaryPropagator<View,PC_INT_BND>::x1;
+
+    /// Constructor for cloning \a p
+    Lq(Space* home, bool share, Lq& p);
+    /// Constructor for posting
+    Lq(Space* home, View x0, View x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*     copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator \f$x_0 \leq x_1\f$
+    static  ExecStatus post(Space* home, View x0, View x1);
+  };
+
+  /**
+   * \brief Less propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+
+  template <class View>
+  class Le : public BinaryPropagator<View,PC_INT_BND> {
+  protected:
+    using BinaryPropagator<View,PC_INT_BND>::x0;
+    using BinaryPropagator<View,PC_INT_BND>::x1;
+
+    /// Constructor for cloning \a p
+    Le(Space* home, bool share, Le& p);
+    /// Constructor for posting
+    Le(Space* home, View x0, View x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator \f$x_0 \le x_1\f$
+    static  ExecStatus post(Space* home, View x0, View x1);
+  };
+
+
+
+  /*
+   * Reified order propagators
+   *
+   */
+
+  /**
+   * \brief Reified less or equal propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+
+  template <class View, class CtrlView>
+  class ReLq : public ReBinaryPropagator<View,PC_INT_BND,CtrlView> {
+  protected:
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x0;
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x1;
+    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::b;
+
+    /// Constructor for cloning \a p
+    ReLq(Space* home, bool share, ReLq& p);
+    /// Constructor for posting
+    ReLq(Space* home, View x0, View x1, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$ (x_0 \leq x_1)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
+  };
+
+  /**
+   * \brief Reified less or equal with integer propagator
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+
+  template <class View, class CtrlView>
+  class ReLqInt : public ReUnaryPropagator<View,PC_INT_BND,CtrlView> {
+  protected:
+    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::x0;
+    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::b;
+
+    /// Integer constant to check
+    int c;
+    /// Constructor for cloning \a p
+    ReLqInt(Space* home, bool share, ReLqInt& p);
+    /// Constructor for posting
+    ReLqInt(Space* home, View x, int c, CtrlView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$ (x \leq c)\Leftrightarrow b\f$
+    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
+   };
+
+
+
+
+
+  /**
+   * \brief Lexical ordering propagator
+   *
+   * The propagator uses the algorithm (and also the automaton)
+   * from:
+   *   Mats Carlsson, Nicolas Beldiceanu, Revisiting the
+   *   Lexicographic Ordering Constraint. SICS Technical
+   *   Report T2002:17, SICS, Sweden, 2002.
+   *
+   * It deviates in the following two main aspects:
+   *  - Assigned variables are eagerly eliminated
+   *    This yields the same incremental behaviour with
+   *    respect to states 1 and 2 of the automaton.
+   *    With respect to the values of \a q and \a r in the report:
+   *     - \a q is always 0 after elimination
+   *     - \a r is always 1 after elimination
+   *
+   *  - It is not incremental with respect to states 3 and 4
+   *    as no propagation event information is available
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Lex : public NaryPropagator<ViewTuple<View,2>,PC_INT_BND> {
+  protected:
+    using NaryPropagator<ViewTuple<View,2>,PC_INT_BND>::x;
+
+    /// Determines whether propagator is strict or not
+    bool strict;
+    /// Constructor for cloning \a p
+    Lex(Space* home, bool share, Lex& p);
+    /// Constructor for posting
+    Lex(Space* home, ViewArray<ViewTuple<View,2> >& xy, bool strict);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for lexical order on \a xy
+    static  ExecStatus post(Space* home,
+			    ViewArray<ViewTuple<View,2> >& xy, bool strict);
+  };
+
+
+  /**
+   * \brief %Propagator for n-ary disequlaity
+   *
+   * Requires \code #include "gecode/int/rel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class View>
+  class NaryNq : public BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM> {
+  protected:
+    using BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>::x0;
+    using BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>::x1;
+    /// Views not yet subscribed to
+    ViewArray<ViewTuple<View,2> > x;
+    /// Constructor for posting
+    NaryNq(Space* home,  ViewArray<ViewTuple<View,2> >& x);
+    /// Constructor for cloning \a p
+    NaryNq(Space* home, bool share, NaryNq& p);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$\exists i\in\{0,\ldots,|x|-1\}:\;x_i\neq y_i\f$
+    static  ExecStatus post(Space* home, ViewArray<ViewTuple<View,2> >& x);
+  };
+
+
+}}}
+
+#include "gecode/int/rel/eq.icc"
+#include "gecode/int/rel/nq.icc"
+#include "gecode/int/rel/lq-le.icc"
+#include "gecode/int/rel/lex.icc"
+
+#endif
+
+
+// STATISTICS: int-prop
+