gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/kernel/memory.icc

@@ -0,0 +1,205 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:05 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3510 $
+ *
+ *  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 {
+
+  /// Heap and automatic memory management
+  namespace Memory {
+
+    /**
+     * \defgroup FuncMemHeap Heap-memory management
+     *
+     * All routines throw an exception of MemoryExhausted, if request
+     * cannot be fulfilled.
+     * \ingroup FuncMem
+     */
+
+    //@{
+    /// Allocate \a s bytes from heap.
+    void* malloc(size_t s);
+    /// Try to change memory-block starting at \a p to size \a s
+    void* realloc(void* p, size_t s);
+    /// Free memory block starting at \a p
+    void  free(void* p);
+
+    /// Allocate block of \a n objects of type \a T from heap
+    template <class T>
+    T* bmalloc(size_t n);
+    /// Reallocate block of \a n object starting at \a b to \a m objects of type \a T from heap
+    template <class T>
+    T* brealloc(T* b, size_t n);
+    /// Copy \a n objects starting at \a s to \a d
+    template <class T>
+    T* bcopy(T* d, const T* s, size_t n);
+
+    //@}
+
+
+    /*
+     * Implementations
+     *
+     */
+
+    forceinline void*
+    malloc(size_t s) {
+      void* p = ::malloc(s);
+      if (p != NULL)
+	return p;
+      throw MemoryExhausted();
+    }
+
+    forceinline void*
+    realloc(void *p, size_t s) {
+      p = ::realloc(p,s);
+      if (p != NULL)
+	return p;
+      throw MemoryExhausted();
+    }
+
+    forceinline void
+    free(void* p) {
+      ::free(p);
+    }
+
+
+    template <class T>
+    forceinline T*
+    bmalloc(size_t n) {
+      return reinterpret_cast<T*>(Memory::malloc(sizeof(T)*n));
+    }
+
+    template <class T>
+    forceinline T*
+    brealloc(T* b, size_t, size_t m) {
+      return reinterpret_cast<T*>(Memory::realloc(b,m*sizeof(T)));
+    }
+
+    template <class T>
+    forceinline T*
+    bcopy(T* d, const T* s, size_t n) {
+      return reinterpret_cast<T*>(memcpy(d,s,n*sizeof(T)));
+    }
+
+  }
+
+}
+
+/**
+ * \defgroup FuncMemAuto Automatic memory management
+ * \ingroup FuncMem
+ */
+
+//@{
+
+/**
+ * \def GECODE_AUTOARRAY(T,X,N)
+ * \brief Automatic (stack allocation) of memory
+ *
+ * Allocates automatic memory for \a N objects of type \a T and
+ * declares and initializes the pointer \a X to \a T to that
+ * block.
+ *
+ * As soon as the current scope is left, the memory is freed.
+ *
+ * Tries to allocate small blocks on the stack, bigger ones are
+ * allocated from the heap (however, management is still automatic).
+ */
+
+//@}
+
+/*
+ * Automatic stack memory management
+ *
+ */
+
+#if defined(__GNUC__) && (! defined(_WIN32) )
+
+#define GECODE_AUTOARRAY(T,X,N)					\
+char __GECODE__ ## X ## __LINE__ [(N)*sizeof(T)];		\
+T* X = reinterpret_cast<T*>(__GECODE__ ## X ## __LINE__);
+
+#elif defined(_MSC_VER) || (defined(__GNUC__) && defined(_WIN32))
+
+#include <cstdlib>
+#include <malloc.h>
+
+namespace Gecode { namespace Memory {
+
+  /**
+   *  \brief Helper class for large memory chunks obtained from heap
+   */
+  class ManageMemory {
+  private:
+    void* _x;
+  public:
+    ManageMemory(void) {}
+    void init(void* p) { _x = p; }
+    ~ManageMemory(void) {
+      if (_x != NULL)
+	::free(_x);
+    }
+  };
+
+}}
+
+
+#define GECODE_AUTOARRAY(T,X,N)					\
+T* X;								\
+::Gecode::Memory::ManageMemory __GECODE__ ## X ## __LINE__;	\
+if ((sizeof(T)*(N)) <= 2048) {					\
+   X = reinterpret_cast<T*>(_alloca(sizeof(T)*(N)));		\
+   __GECODE__ ## X ## __LINE__ .init(NULL);			\
+} else {							\
+   X = reinterpret_cast<T*>(::malloc(sizeof(T)*(N)));		\
+   __GECODE__ ## X ## __LINE__ .init(X);			\
+}
+
+#else
+
+#include <cstdlib>
+
+namespace Gecode { namespace Memory {
+
+  /**
+   *  \brief Helper class for large automatic memory chunks
+   */
+  template <class T>
+  class AutoArray {
+  private:
+    T* _x;
+  public:
+    AutoArray(const int n) {
+      _x = reinterpret_cast<T*>(::malloc(sizeof(T)*n));
+    }
+    ~AutoArray(void) {
+      ::free(_x);
+    }
+    T &operator [](const int i){ return _x[i]; }
+    operator T*(void) { return _x; }
+  };
+
+}}
+
+#define GECODE_AUTOARRAY(T,X,N) ::Gecode::Memory::AutoArray< T > X(N)
+
+#endif
+
+// STATISTICS: kernel-core

data/ext/gecode-1.3.1/gecode/kernel/modevent.icc

@@ -0,0 +1,53 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:05 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3510 $
+ *
+ *  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 {
+
+  /**
+   * \brief Check whether modification event \a me is failed.
+   * \ingroup TaskActor
+   */
+  bool me_failed(ModEvent me);
+  /**
+   * \brief Check whether modification event \a me describes variable modification.
+   * \ingroup TaskActor
+   */
+  bool me_modified(ModEvent me);
+
+
+  /*
+   * Modification events
+   *
+   */
+
+  forceinline bool
+  me_failed(ModEvent me) {
+    return me < ME_GEN_NONE;
+  }
+
+  forceinline bool
+  me_modified(ModEvent me) {
+    return me > ME_GEN_NONE;
+  }
+
+}
+
+// STATISTICS: kernel-other

data/ext/gecode-1.3.1/gecode/kernel/propagator.icc

@@ -0,0 +1,680 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:05 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3510 $
+ *
+ *  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 {
+
+  /**
+   * \brief Dynamic low-propagation cost computation
+   *
+   * If \a n is less than 4, use constant low-costs, otherwise use \a pc.
+   * \ingroup TaskActor
+   */
+  PropCost cost_lo(int n, PropCost pc);
+  /**
+   * \brief Dynamic high-propagation cost computation
+   *
+   * If \a n is less than 4, use constant hight-costs, otherwise use \a pc.
+   * \ingroup TaskActor
+   */
+  PropCost cost_hi(int n, PropCost pc);
+
+
+  /**
+   * \defgroup TaskPropPat Propagator patterns
+   *
+   * The optional last Boolean argument (\a fd) to the constructor for creation
+   * defines whether disposal must be forced. That is, if \a fd is true
+   * the dispose member function of a propagator is called when the
+   * space containing the propagator is deleted.
+   * \ingroup TaskActor
+   */
+
+  //@{
+  /**
+   * \brief Unary propagator
+   *
+   * Stores single view of type \a View with propagation condition \a pc.
+   */
+  template <class View, PropCond pc>
+  class UnaryPropagator : public Propagator {
+  protected:
+    /// Single view
+    View x0;
+    /// Constructor for cloning \a p
+    UnaryPropagator(Space* home, bool share, UnaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    UnaryPropagator(Space* home, bool share, Propagator& p,
+		    View x0);
+    /// Constructor for creation
+    UnaryPropagator(Space* home, View x0, bool fd=false);
+  public:
+    /// Cost function (defined as PC_UNARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Binary propagator
+   *
+   * Stores two views of type \a View with propagation condition \a pc.
+   */
+  template <class View, PropCond pc>
+  class BinaryPropagator : public Propagator {
+  protected:
+    /// Two views
+    View x0, x1;
+    /// Constructor for cloning \a p
+    BinaryPropagator(Space* home, bool share, BinaryPropagator& p);
+    /// Constructor for creation
+    BinaryPropagator(Space* home, View x0, View x1, bool fd=false);
+    /// Constructor for rewriting \a p during cloning
+    BinaryPropagator(Space* home, bool share, Propagator& p,
+		     View x0, View x1);
+  public:
+    /// Cost function (defined as PC_BINARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Ternary propagator
+   *
+   * Stores three views of type \a View with propagation condition \a pc.
+   */
+  template <class View, PropCond pc>
+  class TernaryPropagator : public Propagator {
+  protected:
+    /// Three views
+    View x0, x1, x2;
+    /// Constructor for cloning \a p
+    TernaryPropagator(Space* home, bool share, TernaryPropagator& p);
+    /// Constructor for creation
+    TernaryPropagator(Space* home, View x0, View x1, View x2, bool fd=false);
+    /// Constructor for rewriting \a p during cloning
+    TernaryPropagator(Space* home, bool share, Propagator& p,
+		      View x0, View x1, View x2);
+  public:
+    /// Cost function (defined as PC_TERNARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief n-ary propagator
+   *
+   * Stores array of views of type \a View with propagation condition \a pc.
+   */
+  template <class View, PropCond pc>
+  class NaryPropagator : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<View> x;
+    /// Constructor for cloning \a p
+    NaryPropagator(Space* home, bool share, NaryPropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    NaryPropagator(Space* home, bool share, Propagator& p,
+		   ViewArray<View>& x);
+    /// Constructor for creation
+    NaryPropagator(Space* home, ViewArray<View>& x, bool fd=false);
+  public:
+    /// Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief (n+1)-ary propagator
+   *
+   * Stores array of views and single view of type \a View with propagation
+   * condition \a pc.
+   */
+  template <class View, PropCond pc>
+  class NaryOnePropagator : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<View> x;
+    /// Single view
+    View y;
+    /// Constructor for cloning \a p
+    NaryOnePropagator(Space* home, bool share, NaryOnePropagator& p);
+    /// Constructor for rewriting \a p during cloning
+    NaryOnePropagator(Space* home, bool share, Propagator& p,
+		      ViewArray<View>& x, View y);
+    /// Constructor for creation
+    NaryOnePropagator(Space* home, ViewArray<View>& x, View y, bool fd=false);
+  public:
+    /// Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Inhomogeneous binary propagator
+   *
+   * Stores two views of type \a View0 and \a View1 with propagation
+   * conditions \a pc0 and \a pc1.
+   */
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  class InhomBinaryPropagator : public Propagator {
+  protected:
+    View0 x0;
+    View1 x1;
+    /// Constructor for cloning
+    InhomBinaryPropagator(Space* home,bool,InhomBinaryPropagator&);
+    /// Constructor for creation
+    InhomBinaryPropagator(Space* home,View0,View1,bool=false);
+    /// Constructor for rewriting \a p during cloning
+    InhomBinaryPropagator(Space* home, bool share, Propagator& p,
+			  View0 x0, View1 x1);
+  public:
+    /// Cost function (defined as PC_BINARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Inhomogeneous ternary propagator
+   *
+   * Stores three views of type \a View0, \a View1, and \a View2
+   * with propagation conditions \a pc0, \a pc1, and \a pc2.
+   */
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  class InhomTernaryPropagator : public Propagator {
+  protected:
+    View0 x0;
+    View1 x1;
+    View2 x2;
+    /// Constructor for cloning
+    InhomTernaryPropagator(Space* home,bool,InhomTernaryPropagator&);
+    /// Constructor for creation
+    InhomTernaryPropagator(Space* home,View0,View1,View2,bool=false);
+    /// Constructor for rewriting \a p during cloning
+    InhomTernaryPropagator(Space* home, bool share, Propagator& p,
+			   View0 x0, View1 x1, View2 x2);
+  public:
+    /// Cost function (defined as PC_TERNARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Inhomogeneous (n+1)-ary propagator
+   *
+   * Stores array of views of type \a View0 with propagation condition \a pc0
+   * and a single view of type \a View1 with propagation condition \a pc1.
+   */
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  class InhomNaryOnePropagator : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<View0> x;
+    /// Single view
+    View1 y;
+    /// Constructor for cloning \a p
+    InhomNaryOnePropagator(Space* home, bool share, InhomNaryOnePropagator& p);
+    /// Constructor for creation
+    InhomNaryOnePropagator(Space* home, ViewArray<View0>& x, View1 y,
+			   bool fd=false);
+    /// Constructor for rewriting \a p during cloning
+    InhomNaryOnePropagator(Space* home, bool share, Propagator& p,
+			   ViewArray<View0>& x, View1 y);
+  public:
+    /// Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+  //@}
+
+
+
+
+
+
+  /*
+   * Dynamic cost computation
+   *
+   */
+
+  forceinline PropCost
+  cost_lo(int n, PropCost c) {
+    if (n > 3) return c;
+    if (n < 2) return PC_UNARY_LO;
+    return (n > 2) ? PC_TERNARY_LO : PC_BINARY_LO;
+  }
+
+  forceinline PropCost
+  cost_hi(int n, PropCost c) {
+    if (n > 3) return c;
+    if (n < 2) return PC_UNARY_HI;
+    return (n > 2) ? PC_TERNARY_HI : PC_BINARY_HI;
+  }
+
+  /*
+   * Unary propagators
+   *
+   */
+
+  template <class View, PropCond pc>
+  UnaryPropagator<View,pc>::UnaryPropagator
+  (Space* home, View y0, bool fd)
+    : Propagator(home,fd), x0(y0) {
+    x0.subscribe(home,this,pc);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  UnaryPropagator<View,pc>::UnaryPropagator
+  (Space* home, bool share, UnaryPropagator<View,pc>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  UnaryPropagator<View,pc>::UnaryPropagator
+  (Space* home, bool share, Propagator& p, View y0)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+  }
+
+  template <class View, PropCond pc>
+  PropCost
+  UnaryPropagator<View,pc>::cost(void) const {
+    return PC_UNARY_LO;
+  }
+
+  template <class View, PropCond pc>
+  size_t
+  UnaryPropagator<View,pc>::dispose(Space* home) {
+    if (!home->failed())
+      x0.cancel(home,this,pc);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Binary propagators
+   *
+   */
+
+  template <class View, PropCond pc>
+  BinaryPropagator<View,pc>::BinaryPropagator
+  (Space* home, View y0, View y1, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  BinaryPropagator<View,pc>::BinaryPropagator
+  (Space* home, bool share, BinaryPropagator<View,pc>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  BinaryPropagator<View,pc>::BinaryPropagator
+  (Space* home, bool share, Propagator& p, View y0, View y1)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+  }
+
+  template <class View, PropCond pc>
+  PropCost
+  BinaryPropagator<View,pc>::cost(void) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View, PropCond pc>
+  size_t
+  BinaryPropagator<View,pc>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc);
+      x1.cancel(home,this,pc);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Ternary propagators
+   *
+   */
+
+  template <class View, PropCond pc>
+  TernaryPropagator<View,pc>::TernaryPropagator
+  (Space* home, View y0, View y1, View y2, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1), x2(y2) {
+    x0.subscribe(home,this,pc);
+    x1.subscribe(home,this,pc);
+    x2.subscribe(home,this,pc);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  TernaryPropagator<View,pc>::TernaryPropagator
+  (Space* home, bool share, TernaryPropagator<View,pc>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    x2.update(home,share,p.x2);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  TernaryPropagator<View,pc>::TernaryPropagator
+  (Space* home, bool share, Propagator& p, View y0, View y1, View y2)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    x2.update(home,share,y2);
+  }
+
+  template <class View, PropCond pc>
+  PropCost
+  TernaryPropagator<View,pc>::cost(void) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View, PropCond pc>
+  size_t
+  TernaryPropagator<View,pc>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc);
+      x1.cancel(home,this,pc);
+      x2.cancel(home,this,pc);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Nary propagators
+   *
+   */
+
+  template <class View, PropCond pc>
+  NaryPropagator<View,pc>::NaryPropagator
+  (Space* home, ViewArray<View>& y, bool fd)
+    : Propagator(home,fd), x(y) {
+    x.subscribe(home,this,pc);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  NaryPropagator<View,pc>::NaryPropagator
+  (Space* home, bool share, NaryPropagator<View,pc>& p)
+    : Propagator(home,share,p) {
+    x.update(home,share,p.x);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  NaryPropagator<View,pc>::NaryPropagator
+  (Space* home, bool share, Propagator& p, ViewArray<View>& x0)
+    : Propagator(home,share,p) {
+    x.update(home,share,x0);
+  }
+
+  template <class View, PropCond pc>
+  PropCost
+  NaryPropagator<View,pc>::cost(void) const {
+    return cost_lo(x.size(), PC_LINEAR_LO);
+  }
+
+  template <class View, PropCond pc>
+  size_t
+  NaryPropagator<View,pc>::dispose(Space* home) {
+    if (!home->failed())
+      x.cancel(home,this,pc);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * NaryOne (one additional variable) propagators
+   *
+   */
+
+  template <class View, PropCond pc>
+  NaryOnePropagator<View,pc>::NaryOnePropagator
+  (Space* home, ViewArray<View>& x0, View y0, bool fd)
+    : Propagator(home,fd), x(x0), y(y0) {
+    x.subscribe(home,this,pc);
+    y.subscribe(home,this,pc);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  NaryOnePropagator<View,pc>::NaryOnePropagator
+  (Space* home, bool share, NaryOnePropagator<View,pc>& p)
+    : Propagator(home,share,p) {
+    x.update(home,share,p.x);
+    y.update(home,share,p.y);
+  }
+
+  template <class View, PropCond pc>
+  forceinline
+  NaryOnePropagator<View,pc>::NaryOnePropagator
+  (Space* home, bool share, Propagator& p, ViewArray<View>& x0, View y0)
+    : Propagator(home,share,p) {
+    x.update(home,share,x0);
+    y.update(home,share,y0);
+  }
+
+  template <class View, PropCond pc>
+  PropCost
+  NaryOnePropagator<View,pc>::cost(void) const {
+    return cost_lo(x.size()+1, PC_LINEAR_LO);
+  }
+
+  template <class View, PropCond pc>
+  size_t
+  NaryOnePropagator<View,pc>::dispose(Space* home) {
+    if (!home->failed()) {
+      x.cancel(home,this,pc);
+      y.cancel(home,this,pc);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Inhomogeneous binary propagators
+   *
+   */
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  InhomBinaryPropagator<View0,pc0,View1,pc1>::InhomBinaryPropagator
+  (Space* home, View0 y0, View1 y1, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1) {
+    x0.subscribe(home,this,pc0);
+    x1.subscribe(home,this,pc1);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  forceinline
+  InhomBinaryPropagator<View0,pc0,View1,pc1>::InhomBinaryPropagator
+  (Space* home, bool share, InhomBinaryPropagator<View0,pc0,View1,pc1>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  forceinline
+  InhomBinaryPropagator<View0,pc0,View1,pc1>::InhomBinaryPropagator
+  (Space* home, bool share, Propagator& p, View0 y0, View1 y1)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  PropCost
+  InhomBinaryPropagator<View0,pc0,View1,pc1>::cost(void) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  size_t
+  InhomBinaryPropagator<View0,pc0,View1,pc1>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc0);
+      x1.cancel(home,this,pc1);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * Inhomogeneous ternary propagators
+   *
+   */
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  InhomTernaryPropagator<View0,pc0,View1,pc1,View2,pc2>::
+  InhomTernaryPropagator(Space* home, View0 y0, View1 y1, View2 y2, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1), x2(y2) {
+    x0.subscribe(home,this,pc0);
+    x1.subscribe(home,this,pc1);
+    x2.subscribe(home,this,pc2);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  forceinline
+  InhomTernaryPropagator<View0,pc0,View1,pc1,View2,pc2>::
+  InhomTernaryPropagator(Space* home, bool share,
+			 InhomTernaryPropagator<View0,pc0,View1,pc1,
+			 View2,pc2>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    x2.update(home,share,p.x2);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  forceinline
+  InhomTernaryPropagator<View0,pc0,View1,pc1,View2,pc2>::InhomTernaryPropagator
+  (Space* home, bool share, Propagator& p, View0 y0, View1 y1, View2 y2)
+    : Propagator(home,share,p) {
+    x0.update(home,share,y0);
+    x1.update(home,share,y1);
+    x2.update(home,share,y2);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  PropCost
+  InhomTernaryPropagator<View0,pc0,View1,pc1,View2,pc2>::cost(void) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1,
+	    class View2, PropCond pc2>
+  size_t
+  InhomTernaryPropagator<View0,pc0,View1,pc1,View2,pc2>::
+  dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pc0);
+      x1.cancel(home,this,pc1);
+      x2.cancel(home,this,pc2);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  /*
+   * InhomNaryOne (one additional variable) propagators
+   *
+   */
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  InhomNaryOnePropagator<View0,pc0,View1,pc1>::InhomNaryOnePropagator
+  (Space* home, ViewArray<View0>& x0, View1 y0, bool fd)
+    : Propagator(home,fd), x(x0), y(y0) {
+    x.subscribe(home,this,pc0);
+    y.subscribe(home,this,pc1);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  forceinline
+  InhomNaryOnePropagator<View0,pc0,View1,pc1>::InhomNaryOnePropagator
+  (Space* home, bool share, InhomNaryOnePropagator<View0,pc0,View1,pc1>& p)
+    : Propagator(home,share,p) {
+    x.update(home,share,p.x);
+    y.update(home,share,p.y);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  forceinline
+  InhomNaryOnePropagator<View0,pc0,View1,pc1>::InhomNaryOnePropagator
+  (Space* home, bool share, Propagator& p, ViewArray<View0>& x0, View1 y0)
+    : Propagator(home,share,p) {
+    x.update(home,share,x0);
+    y.update(home,share,y0);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  PropCost
+  InhomNaryOnePropagator<View0,pc0,View1,pc1>::cost(void) const {
+    return cost_lo(x.size()+1, PC_LINEAR_LO);
+  }
+
+  template <class View0, PropCond pc0, class View1, PropCond pc1>
+  size_t
+  InhomNaryOnePropagator<View0,pc0,View1,pc1>::dispose(Space* home) {
+    if (!home->failed()) {
+      x.cancel(home,this,pc0);
+      y.cancel(home,this,pc1);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+}
+
+// STATISTICS: kernel-other