gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/int/linear/int-noview.icc

@@ -0,0 +1,385 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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 Linear {
+
+    /**
+     * \brief No view serves as filler for empty view arrays
+     *
+     */
+    class NoView : public ConstViewBase {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      NoView(void) {}
+      /// Initialize
+      void init(void) {}
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const { return 0; }
+      /// Return maximum of domain
+      int max(void) const { return 0; }
+      /// Return median of domain
+      int med(void) const { return 0; }
+      /// Return assigned value (only if assigned)
+      int val(void) const { return 0; }
+
+      /// Return size (cardinality) of domain
+      unsigned int size(void) const { return 1; }
+      /// Return width of domain (distance between maximum and minimum)
+      unsigned int width(void) const { return 1; }
+      /// Return regret of domain minimum (distance to next larger value)
+      unsigned int regret_min(void) const { return 0; }
+      /// Return regret of domain maximum (distance to next smaller value)
+      unsigned int regret_max(void) const { return 0; }
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const { return true; }
+      /// Test whether view is assigned
+      bool assigned(void) const { return true; }
+
+      /// Test whether \a n is contained in domain
+      bool in(int n) const { n=n; return false; }
+      /// Test whether \a n is contained in domain
+      bool in(double n) const { n=n; return false; }
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, int n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, double n) {
+        (void) home; (void) n;
+        return ME_INT_NONE;
+      }
+      //@}
+
+      /// \name View-dependent propagator support
+      //@{
+      /// Schedule propagator \a p with modification event \a me
+      static void schedule(Space* home, Propagator* p, ModEvent me) {
+        (void) home; (void) p; (void) me;
+      }
+      /// Return modification event of propagator \a p for view
+      static ModEvent med(const Propagator* p) {
+        (void) p;
+        return ME_INT_NONE;
+      }
+      /// Translate modification event \a me to modification event delta for view
+      static ModEventDelta med(ModEvent me) {
+        (void) me;
+        return ME_INT_NONE;
+      }
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /// Subscribe propagator \a p with propagation condition \a pc to view
+      void subscribe(Space* home, Propagator* p, PropCond pc,
+                     bool process=true) {
+        (void) home; (void) p; (void)  pc; (void) process;
+      }
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc) {
+        (void) home; (void) p; (void)  pc;
+      }
+      /// Subscribe advisor to view
+      void subscribe(Space*, Advisor*) {};
+      /// Cancel subscription of advisor
+      void cancel(Space*, Advisor*) {};
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, NoView& x) {
+        (void) home; (void) share; (void) x;
+      }
+      //@}
+
+      /// \name Reflection
+      //@{
+      /// Return specification for this view, using variable map \a m
+      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const {
+        (void) home; (void) m;
+        return NULL;
+      }
+      /// Type of this view
+      static Support::Symbol type(void) {
+        return Support::Symbol("Gecode::Int::Linear::NoView");
+      }
+      //@}
+
+      /// \name View comparison
+      //@{
+      /// Test whether this view is the same as \a x
+      bool operator ==(const NoView& x) const { (void) x; return true; }
+      /// Test whether this view is not the same as \a x
+      bool operator !=(const NoView& x) const { (void) x; return false; }
+      /// Test whether this view is smaller than \a x (arbitrary order)
+      bool operator < (const NoView& x) const { (void) x; return false; }
+      /// Test whether this view is larger than \a x (arbitrary order)
+      bool operator > (const NoView& x) const { (void) x; return false; }
+      //@}
+    };
+
+  }}
+
+
+  /**
+   * \brief View array for no view (empty)
+   *
+   */
+  template <>
+  class ViewArray<Int::Linear::NoView> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor (array of size 0)
+    ViewArray(void) {}
+    /// Allocate array with \a m variables
+    ViewArray(Space* home, int m) { (void) home; (void) m; }
+    /// Initialize
+    ViewArray(const ViewArray<Int::Linear::NoView>&) {}
+    /// Initialize
+    ViewArray(Space*, const ViewArray<Int::Linear::NoView>&) {}
+    /// Initialize
+    ViewArray(Space*, const Reflection::VarMap&, Reflection::Arg*) {}
+    /// Initialize
+    const ViewArray<Int::Linear::NoView>& operator=(const ViewArray<Int::Linear::NoView>&) { return *this; }
+    //@}
+
+    /// \name Array size
+    //@{
+    /// Return size of array (number of elements)
+    int size(void) const { return 0; }
+    /// Decrease size of array (number of elements)
+    void size(int n) { (void) n; }
+    //@}
+
+    /// \name Array elements
+    //@{
+    /// Return view at position \a i
+    Int::Linear::NoView operator[](int i) {
+      (void)  i;
+      Int::Linear::NoView n;
+      return n;
+    }
+    //@}
+
+    /// \name Dependencies
+    //@{
+    /// Subscribe propagator \a p with propagation condition \a pc to all views
+    void subscribe(Space*, Propagator* p, PropCond pc, bool process=true) {
+      (void) p; (void) pc; (void) process;
+    }
+    /// Cancel subscription of propagator \a p with propagation condition \a pc to all views
+    void cancel(Space* home, Propagator* p, PropCond pc) {
+      (void) home; (void) p; (void) pc;
+    }
+    //@}
+
+    /// \name Cloning
+    //@{
+    /**
+     * \brief Update array to be a clone of array \a a
+     *
+     * If \a share is true, sharing is retained for all shared
+     * data structures. Otherwise, for each of them an independent
+     * copy is created.
+     */
+    void update(Space*, bool share, ViewArray<Int::Linear::NoView>& a) {
+      (void) share; (void) a;
+    }
+    //@}
+
+    /// \name Reflection
+    //@{
+    /// Return specification for this array, using variable map \a m
+    Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const {
+      (void) home; (void) m;
+      return Reflection::Arg::newArray(0);
+    }
+    //@}
+
+
+    /// \name Moving elements
+    //@{
+    /// Move assigned view from position 0 to position \a i (shift elements to the left)
+    void move_fst(int i) { (void) i; }
+    /// Move assigned view from position \c size()-1 to position \a i (truncate array by one)
+    void move_lst(int i) { (void) i; }
+    /** \brief Move view from position 0 to position \a i (shift elements to the left)
+     *
+     * Before moving, cancel subscription of propagator \a p with
+     * propagation condition \a pc to view at position \a i.
+     */
+    void move_fst(int i, Propagator* p, PropCond pc) {
+      (void) i; (void) p; (void) pc;
+    }
+    /** \brief Move view from position \c size()-1 to position \a i (truncate array by one)
+     *
+     * Before moving, cancel subscription of propagator \a p with
+     * propagation condition \a pc to view at position \a i.
+     */
+    void move_lst(int i, Propagator* p, PropCond pc) {
+      (void) i; (void) p; (void) pc;
+    }
+    //@}
+
+    /// \name Dropping elements
+    //@{
+    /// Drop assigned views from positions 0 to \a i-1 from array
+    void drop_fst(int i);
+    /// Drop assigned views from positions \a i+1 to \c size()-1 from array
+    void drop_lst(int i);
+    /** \brief Drop views from positions 0 to \a i-1 from array
+     *
+     * Before moving, cancel subscription of propagator \a p with
+     * propagation condition \a pc to views at positions 0 to \a i-1.
+     */
+    void drop_fst(int i, Propagator* p, PropCond pc) {
+      (void) i; (void) p; (void) pc;
+    }
+    /** \brief Drop assigned views from positions \a i+1 to \c size()-1 from array
+     *
+     * Before moving, cancel subscription of propagator \a p with
+     * propagation condition \a pc to views at positions \a i+1 to
+     * \c size()-1.
+     */
+    void drop_lst(int i, Propagator* p, PropCond pc) {
+      (void) i; (void) p; (void) pc;
+    }
+    //@}
+
+    /// \name View equality
+    //@{
+    /// Test whether array has equal views
+    bool equal(void) const { return false; }
+    /// Test whether array contains view equal to \a y
+    bool equal(const Int::Linear::NoView& y) const {
+      (void) y;
+      return false;
+    }
+    /// Remove all duplicate views from array (changes element order)
+    void unique(void) {}
+    //@}
+
+    /// \name View sharing
+    //@{
+    /// Test whether array has shared views
+    bool shared(void) const { return false; }
+    /// Test whether array contains view shared with \a y
+    bool shared(const Int::Linear::NoView& y) const {
+      (void) y;
+      return false;
+    }
+    //@}
+
+  private:
+    static void* operator new(size_t);
+    static void  operator delete(void*,size_t);
+  };
+
+}
+
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/linear/int-post.cc

@@ -0,0 +1,493 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2008-02-25 08:33:35 +0100 (Mon, 25 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6292 $
+ *
+ *  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 <cfloat>
+#include <algorithm>
+
+#include "gecode/int/rel.hh"
+#include "gecode/int/linear.hh"
+
+namespace Gecode { namespace Int { namespace Linear {
+
+  /// Largest double that can exactly be represented
+  const double double_max = 9007199254740991.0;
+  /// Smallest double that can exactly be represented
+  const double double_min = -9007199254740991.0;
+
+  /// Eliminate assigned views
+  inline void
+  eliminate(Term<IntView>* t, int &n, double& d) {
+    for (int i=n; i--; )
+      if (t[i].x.assigned()) {
+        d -= t[i].a * static_cast<double>(t[i].x.val());
+        t[i]=t[--n];
+      }
+    if ((d < double_min) || (d > double_max))
+      throw OutOfLimits("Int::linear");
+  }
+
+  /// Rewrite all inequations in terms of IRT_LQ
+  inline void
+  rewrite(IntRelType &r, double &d,
+          Term<IntView>* &t_p, int &n_p,
+          Term<IntView>* &t_n, int &n_n) {
+    switch (r) {
+    case IRT_EQ: case IRT_NQ: case IRT_LQ:
+      break;
+    case IRT_LE:
+      d--; r = IRT_LQ; break;
+    case IRT_GR:
+      d++; /* fall through */
+    case IRT_GQ:
+      r = IRT_LQ;
+      std::swap(n_p,n_n); std::swap(t_p,t_n); d = -d;
+      break;
+    default:
+      throw UnknownRelation("Int::linear");
+    }
+  }
+
+  /// Decide the required precision and check for overflow
+  inline bool
+  precision(Term<IntView>* t_p, int n_p, 
+            Term<IntView>* t_n, int n_n,
+            double d) {
+    double sl = 0.0;
+    double su = 0.0;
+
+    for (int i = n_p; i--; ) {
+      sl += t_p[i].a * static_cast<double>(t_p[i].x.min());
+      su += t_p[i].a * static_cast<double>(t_p[i].x.max());
+    }
+    for (int i = n_n; i--; ) {
+      sl -= t_n[i].a * static_cast<double>(t_n[i].x.max());
+      su -= t_n[i].a * static_cast<double>(t_n[i].x.min());
+    }
+    sl -= d;
+    su -= d;
+
+    if ((sl < double_min) || (su > double_max))
+      throw OutOfLimits("Int::linear");
+
+    bool is_ip = (sl >= Limits::min) && (su <= Limits::max);
+
+    for (int i = n_p; i--; ) {
+      if (sl - t_p[i].a * static_cast<double>(t_p[i].x.min()) < double_min)
+        throw OutOfLimits("Int::linear");
+      if (sl - t_p[i].a * static_cast<double>(t_p[i].x.min()) < Limits::min)
+        is_ip = false;
+      if (su - t_p[i].a * static_cast<double>(t_p[i].x.max()) > double_max)
+        throw OutOfLimits("Int::linear");
+      if (su - t_p[i].a * static_cast<double>(t_p[i].x.max()) > Limits::max)
+        is_ip = false;
+    }
+    for (int i = n_n; i--; ) {
+      if (sl + t_n[i].a * static_cast<double>(t_n[i].x.min()) < double_min)
+        throw OutOfLimits("Int::linear");
+      if (sl + t_n[i].a * static_cast<double>(t_n[i].x.min()) < Limits::min)
+        is_ip = false;
+      if (su + t_n[i].a * static_cast<double>(t_n[i].x.max()) > double_max)
+        throw OutOfLimits("Int::linear");
+      if (su + t_n[i].a * static_cast<double>(t_n[i].x.max()) > Limits::max)
+        is_ip = false;
+    }
+    return is_ip;
+  }
+
+  /**
+   * \brief Posting n-ary propagators
+   *
+   */
+  template <class Val, class View>
+  forceinline void
+  post_nary(Space* home,
+            ViewArray<View>& x, ViewArray<View>& y, IntRelType r, Val c) {
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ES_FAIL(home,(Eq<Val,View,View >::post(home,x,y,c)));
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(home,(Nq<Val,View,View >::post(home,x,y,c)));
+      break;
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,(Lq<Val,View,View >::post(home,x,y,c)));
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+
+
+/// Macro for posting binary special cases for linear constraints
+#define GECODE_INT_PL_BIN(CLASS)                                \
+  switch (n_p) {                                                \
+  case 2:                                                       \
+    GECODE_ES_FAIL(home,(CLASS<int,IntView,IntView>::post       \
+                         (home,t_p[0].x,t_p[1].x,c)));          \
+    break;                                                      \
+  case 1:                                                       \
+    GECODE_ES_FAIL(home,(CLASS<int,IntView,MinusView>::post     \
+                         (home,t_p[0].x,t_n[0].x,c)));          \
+    break;                                                      \
+  case 0:                                                       \
+    GECODE_ES_FAIL(home,(CLASS<int,MinusView,MinusView>::post   \
+                         (home,t_n[0].x,t_n[1].x,c)));          \
+    break;                                                      \
+  default: GECODE_NEVER;                                        \
+  }
+
+/// Macro for posting ternary special cases for linear constraints
+#define GECODE_INT_PL_TER(CLASS)                                        \
+  switch (n_p) {                                                        \
+  case 3:                                                               \
+    GECODE_ES_FAIL(home,(CLASS<int,IntView,IntView,IntView>::post       \
+                         (home,t_p[0].x,t_p[1].x,t_p[2].x,c)));         \
+    break;                                                              \
+  case 2:                                                               \
+    GECODE_ES_FAIL(home,(CLASS<int,IntView,IntView,MinusView>::post     \
+                         (home,t_p[0].x,t_p[1].x,t_n[0].x,c)));         \
+    break;                                                              \
+  case 1:                                                               \
+    GECODE_ES_FAIL(home,(CLASS<int,IntView,MinusView,MinusView>::post   \
+                         (home,t_p[0].x,t_n[0].x,t_n[1].x,c)));         \
+    break;                                                              \
+  case 0:                                                               \
+    GECODE_ES_FAIL(home,(CLASS<int,MinusView,MinusView,MinusView>::post \
+                         (home,t_n[0].x,t_n[1].x,t_n[2].x,c)));         \
+    break;                                                              \
+  default: GECODE_NEVER;                                                \
+  }
+
+  void
+  post(Space* home, Term<IntView>* t, int n, IntRelType r, int c,
+       IntConLevel icl, PropKind) {
+
+    Limits::check(c,"Int::linear");
+
+    double d = c;
+    
+    eliminate(t,n,d);
+
+    Term<IntView> *t_p, *t_n;
+    int n_p, n_n;
+    bool is_unit = normalize<IntView>(t,n,t_p,n_p,t_n,n_n);
+
+    rewrite(r,d,t_p,n_p,t_n,n_n);
+
+    if (n == 0) {
+      switch (r) {
+      case IRT_EQ: if (d != 0.0) home->fail(); break;
+      case IRT_NQ: if (d == 0.0) home->fail(); break;
+      case IRT_LQ: if (d < 0.0)  home->fail(); break;
+      default: GECODE_NEVER;
+      }
+      return;
+    }
+
+    if (n == 1) {
+      if (n_p == 1) {
+        DoubleScaleView y(t_p[0].a,t_p[0].x);
+        switch (r) {
+        case IRT_EQ: GECODE_ME_FAIL(home,y.eq(home,d)); break;
+        case IRT_NQ: GECODE_ME_FAIL(home,y.nq(home,d)); break;
+        case IRT_LQ: GECODE_ME_FAIL(home,y.lq(home,d)); break;
+        default: GECODE_NEVER;
+        }
+      } else {
+        DoubleScaleView y(t_n[0].a,t_n[0].x);
+        switch (r) {
+        case IRT_EQ: GECODE_ME_FAIL(home,y.eq(home,-d)); break;
+        case IRT_NQ: GECODE_ME_FAIL(home,y.nq(home,-d)); break;
+        case IRT_LQ: GECODE_ME_FAIL(home,y.gq(home,-d)); break;
+        default: GECODE_NEVER;
+        }
+      }
+      return;
+    }
+
+    bool is_ip = precision(t_p,n_p,t_n,n_n,d);
+
+    if (is_unit && is_ip && (icl != ICL_DOM)) {
+      // Unit coefficients with integer precision
+      c = static_cast<int>(d);
+      if (n == 2) {
+        switch (r) {
+        case IRT_EQ: GECODE_INT_PL_BIN(EqBin); break;
+        case IRT_NQ: GECODE_INT_PL_BIN(NqBin); break;
+        case IRT_LQ: GECODE_INT_PL_BIN(LqBin); break;
+        default: GECODE_NEVER;
+        }
+      } else if (n == 3) {
+        switch (r) {                                                
+        case IRT_EQ: GECODE_INT_PL_TER(EqTer); break;
+        case IRT_NQ: GECODE_INT_PL_TER(NqTer); break;
+        case IRT_LQ: GECODE_INT_PL_TER(LqTer); break;
+        default: GECODE_NEVER;
+        }
+      } else {
+        ViewArray<IntView> x(home,n_p);
+        for (int i = n_p; i--; ) 
+          x[i] = t_p[i].x;
+        ViewArray<IntView> y(home,n_n);
+        for (int i = n_n; i--; ) 
+          y[i] = t_n[i].x;
+        post_nary<int,IntView>(home,x,y,r,c);
+      }
+    } else if (is_ip) {
+      // Arbitrary coefficients with integer precision
+      c = static_cast<int>(d);
+      ViewArray<IntScaleView> x(home,n_p);
+      for (int i = n_p; i--; )
+        x[i].init(t_p[i].a,t_p[i].x);
+      ViewArray<IntScaleView> y(home,n_n);
+      for (int i = n_n; i--; )
+        y[i].init(t_n[i].a,t_n[i].x);
+      if ((icl == ICL_DOM) && (r == IRT_EQ)) {
+        GECODE_ES_FAIL(home,(DomEq<int,IntScaleView>::post(home,x,y,c)));
+      } else {
+        post_nary<int,IntScaleView>(home,x,y,r,c);
+      }
+    } else {
+      // Arbitrary coefficients with double precision
+      ViewArray<DoubleScaleView> x(home,n_p);
+      for (int i = n_p; i--; )
+        x[i].init(t_p[i].a,t_p[i].x);
+      ViewArray<DoubleScaleView> y(home,n_n);
+      for (int i = n_n; i--; )
+        y[i].init(t_n[i].a,t_n[i].x);
+      if ((icl == ICL_DOM) && (r == IRT_EQ)) {
+        GECODE_ES_FAIL(home,(DomEq<double,DoubleScaleView>::post(home,x,y,d)));
+      } else {
+        post_nary<double,DoubleScaleView>(home,x,y,r,d);
+      }
+    }
+  }
+
+#undef GECODE_INT_PL_BIN
+#undef GECODE_INT_PL_TER
+
+
+  /**
+   * \brief Posting reified n-ary propagators
+   *
+   */
+  template <class Val, class View>
+  forceinline void
+  post_nary(Space* home,
+            ViewArray<View>& x, ViewArray<View>& y, 
+            IntRelType r, Val c, BoolView b) {
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ES_FAIL(home,(ReEq<Val,View,View,BoolView>::post(home,x,y,c,b)));
+      break;
+    case IRT_NQ:
+      {
+        NegBoolView n(b);
+        GECODE_ES_FAIL(home,(ReEq<Val,View,View,NegBoolView>::post
+                             (home,x,y,c,n)));
+      }
+      break;
+    case IRT_LQ:
+      GECODE_ES_FAIL(home,(ReLq<Val,View,View>::post(home,x,y,c,b)));
+      break;
+    default: GECODE_NEVER;
+    }
+  }
+
+  void
+  post(Space* home,
+       Term<IntView>* t, int n, IntRelType r, int c, BoolView b,
+       IntConLevel,PropKind) {
+
+    Limits::check(c,"Int::linear");
+
+    double d = c;
+    
+    eliminate(t,n,d);
+
+    Term<IntView> *t_p, *t_n;
+    int n_p, n_n;
+    bool is_unit = normalize<IntView>(t,n,t_p,n_p,t_n,n_n);
+
+    rewrite(r,d,t_p,n_p,t_n,n_n);
+
+    if (n == 0) {
+      bool fail = false;
+      switch (r) {
+      case IRT_EQ: fail = (d != 0.0); break;
+      case IRT_NQ: fail = (d == 0.0); break;
+      case IRT_LQ: fail = (0.0 > d); break;
+      default: GECODE_NEVER;
+      }
+      if ((fail ? b.zero(home) : b.one(home)) == ME_INT_FAILED)
+        home->fail();
+      return;
+    }
+
+    bool is_ip = precision(t_p,n_p,t_n,n_n,d);
+
+    if (is_unit && is_ip) {
+      c = static_cast<int>(d);
+      if (n == 1) {
+        switch (r) {
+        case IRT_EQ:
+          if (n_p == 1) {
+            GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,BoolView>::post
+                                 (home,t_p[0].x,c,b)));
+          } else {
+            GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,BoolView>::post
+                                 (home,t_n[0].x,-c,b)));
+          }
+          break;
+        case IRT_NQ:
+          {
+            NegBoolView n(b);
+            if (n_p == 1) {
+              GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,NegBoolView>::post
+                                   (home,t_p[0].x,c,n)));
+            } else {
+              GECODE_ES_FAIL(home,(Rel::ReEqBndInt<IntView,NegBoolView>::post
+                                   (home,t_n[0].x,-c,n)));
+            }
+          }
+          break;
+        case IRT_LQ:
+          if (n_p == 1) {
+            GECODE_ES_FAIL(home,(Rel::ReLqInt<IntView,BoolView>::post
+                                 (home,t_p[0].x,c,b)));
+          } else {
+            NegBoolView n(b);
+            GECODE_ES_FAIL(home,(Rel::ReLqInt<IntView,NegBoolView>::post
+                                 (home,t_n[0].x,-c-1,n)));
+          }
+          break;
+        default: GECODE_NEVER;
+        }
+      } else if (n == 2) {
+        switch (r) {
+        case IRT_EQ:
+          switch (n_p) {
+          case 2:
+            GECODE_ES_FAIL(home,(ReEqBin<int,IntView,IntView,BoolView>::post
+                                 (home,t_p[0].x,t_p[1].x,c,b)));
+            break;
+          case 1:
+            GECODE_ES_FAIL(home,(ReEqBin<int,IntView,MinusView,BoolView>::post
+                                 (home,t_p[0].x,t_n[0].x,c,b)));
+            break;
+          case 0:
+            GECODE_ES_FAIL(home,(ReEqBin<int,IntView,IntView,BoolView>::post
+                                 (home,t_n[0].x,t_n[1].x,-c,b)));
+            break;
+          default: GECODE_NEVER;
+          }
+          break;
+        case IRT_NQ:
+          {
+            NegBoolView n(b);
+            switch (n_p) {
+            case 2:
+              GECODE_ES_FAIL(home,
+                             (ReEqBin<int,IntView,IntView,NegBoolView>::post
+                              (home,t_p[0].x,t_p[1].x,c,n)));
+              break;
+            case 1:
+              GECODE_ES_FAIL(home,
+                             (ReEqBin<int,IntView,MinusView,NegBoolView>::post
+                              (home,t_p[0].x,t_n[0].x,c,b)));
+              break;
+            case 0:
+              GECODE_ES_FAIL(home,
+                             (ReEqBin<int,IntView,IntView,NegBoolView>::post
+                              (home,t_p[0].x,t_p[1].x,-c,b)));
+              break;
+            default: GECODE_NEVER;
+            }
+          }
+          break;
+        case IRT_LQ:
+          switch (n_p) {
+          case 2:
+            GECODE_ES_FAIL(home,(ReLqBin<int,IntView,IntView>::post
+                                 (home,t_p[0].x,t_p[1].x,c,b)));
+            break;
+          case 1:
+            GECODE_ES_FAIL(home,(ReLqBin<int,IntView,MinusView>::post
+                                 (home,t_p[0].x,t_n[0].x,c,b)));
+            break;
+          case 0:
+            GECODE_ES_FAIL(home,(ReLqBin<int,MinusView,MinusView>::post
+                                 (home,t_n[0].x,t_n[1].x,c,b)));
+            break;
+          default: GECODE_NEVER;
+          }
+          break;
+        default: GECODE_NEVER;
+        }
+      } else {
+        ViewArray<IntView> x(home,n_p);
+        for (int i = n_p; i--; ) 
+          x[i] = t_p[i].x;
+        ViewArray<IntView> y(home,n_n);
+        for (int i = n_n; i--; )
+          y[i] = t_n[i].x;
+        post_nary<int,IntView>(home,x,y,r,c,b);
+      }
+    } else if (is_ip) {
+      // Arbitrary coefficients with integer precision
+      c = static_cast<int>(d); 
+      ViewArray<IntScaleView> x(home,n_p);
+      for (int i = n_p; i--; )
+        x[i].init(t_p[i].a,t_p[i].x);
+      ViewArray<IntScaleView> y(home,n_n);
+      for (int i = n_n; i--; )
+        y[i].init(t_n[i].a,t_n[i].x);
+      post_nary<int,IntScaleView>(home,x,y,r,c,b);
+    } else {
+      // Arbitrary coefficients with double precision
+      ViewArray<DoubleScaleView> x(home,n_p);
+      for (int i = n_p; i--; )
+        x[i].init(t_p[i].a,t_p[i].x);
+      ViewArray<DoubleScaleView> y(home,n_n);
+      for (int i = n_n; i--; )
+        y[i].init(t_n[i].a,t_n[i].x);
+      post_nary<double,DoubleScaleView>(home,x,y,r,d,b);
+    }
+  }
+
+}}}
+
+// STATISTICS: int-post