gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/circuit/base.icc

@@ -0,0 +1,266 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:26:26 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7330 $
+ *
+ *  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 Circuit {
+
+  template <class View>
+  forceinline
+  Base<View>::Base(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_DOM>(home,x), y(home,x) {}
+
+  template <class View>
+  forceinline
+  Base<View>::Base(Space* home, bool share, Base<View>& p)
+    : NaryPropagator<View,PC_INT_DOM>(home,share,p) {
+    y.update(home,share,p.y);
+  }
+
+  /// Information required for non-recursive checking for a single scc
+  template <class View>
+  class SsccInfo {
+  public:
+    int min, low, pre;
+    ViewValues<View> v;
+  };
+
+  /// Information for performing a recorded tell
+  template<class View>
+  class TellInfo {
+  public:
+    View x; int n;
+  };
+
+  template <class View>
+  ExecStatus
+  Base<View>::connected(Space* home) {
+    int n = x.size();
+
+    /// First non-assigned node.
+    int start = 0;
+    while (x[start].assigned()) {
+      start = x[start].val();
+      if (start == 0) break;
+    }
+
+    /// Information needed for checking scc's
+    GECODE_AUTOARRAY(SsccInfo<View>,si,n);
+    unsigned int n_edges = 0;
+    for (int i=n; i--; ) {
+      n_edges += x[i].size();
+      si[i].pre=-1;
+    }
+
+    // Stack to remember which nodes have not been processed completely
+    GECODE_AUTOSTACK(int,-1,next,n);
+
+    // Array to remember which mandatory tells need to be done
+    GECODE_AUTOARRAY(TellInfo<View>,eq,n);
+    int n_eq = 0;
+
+    // Array to remember which edges need to be pruned
+    GECODE_AUTOARRAY(TellInfo<View>,nq,n_edges);
+    int n_nq = 0;
+
+    /* 
+     * Check whether there is a single strongly connected component.
+     * This is a downstripped version of Tarjan's algorithm as
+     * the computation of sccs proper is not needed. In addition, it
+     * checks a mandatory condition for a graph to be Hamiltonian
+     * (due to Mats Carlsson).
+     *
+     * To quote Mats: Suppose you do a depth-first search of the graph. 
+     * In that search, the root node will have a number of child subtrees 
+     * T1, ..., Tn. By construction, if i<j then there is no edge from 
+     * Ti to Tj. The necessary condition for Hamiltonianicity is that 
+     * there be an edge from Ti+1 to Ti, for 0 < i < n.
+     *
+     * In addition, we do the following: if there is only a single edge
+     * from Ti+1 to Ti, then it must be mandatory and the variable must
+     * be assigned to that value.
+     *
+     * The same holds true for a back edge from T0 to the root node.
+     *
+     * Then, all edges that reach from Ti+k+1 to Ti can be pruned.
+     *
+     */
+
+    // Start always at node start
+    int i = start;
+    // Counter for scc
+    int cnt = 0;
+    // Smallest preorder number of last subtree (initially, the root node)
+    int subtree_min = 0;
+    // Largest preorder number of last subtree (initially, the root node)
+    int subtree_max = 0;
+    // Number of back edges into last subtree or root
+    int back = 0;
+  start:
+    si[i].min = si[i].pre = si[i].low = cnt++;
+    si[i].v.init(x[i]);
+    do {
+      if (si[si[i].v.val()].pre < 0) {
+        next.push(i);
+        i=si[i].v.val();
+        goto start;
+      } else if ((subtree_min <= si[si[i].v.val()].pre) &&
+                 (si[si[i].v.val()].pre <= subtree_max)) {
+        back++;
+        eq[n_eq].x = x[i];
+        eq[n_eq].n = si[i].v.val();
+      } else if (si[si[i].v.val()].pre < subtree_min) {
+        nq[n_nq].x = x[i];
+        nq[n_nq].n = si[i].v.val();
+        n_nq++;
+      }
+    cont:
+      if (si[si[i].v.val()].low < si[i].min)
+        si[i].min = si[si[i].v.val()].low;
+      ++si[i].v;
+    } while (si[i].v());
+    if (si[i].min < si[i].low) {
+      si[i].low = si[i].min;
+    } else if (i != start) {
+      // If it is not the first node visited, there is more than one SCC
+      return ES_FAILED;
+    }
+    if (!next.empty()) {
+      i=next.pop(); 
+      if (i == start) {
+        // No back edge
+        if (back == 0)
+          return ES_FAILED;
+        // Exactly one back edge, make it mandatory (keep topmost entry on ti)
+        if (back == 1)
+          n_eq++;
+        back        = 0;
+        subtree_min = subtree_max+1;
+        subtree_max = cnt-1;
+      }
+      goto cont;
+    }
+    // Whether all nodes have been visited
+    if (cnt != n)
+      return ES_FAILED;
+    ExecStatus es = ES_FIX;
+    // Assign all mandatory edges
+    while (n_eq-- > 0) {
+      ModEvent me = eq[n_eq].x.eq(home,eq[n_eq].n);
+      if (me_failed(me))
+        return ES_FAILED;
+      if (me_modified(me))
+        es = ES_NOFIX;
+    }      
+    // Remove all edges that would require a non-simple cycle
+    while (n_nq-- > 0) {
+      ModEvent me = nq[n_nq].x.nq(home,nq[n_nq].n);
+      if (me_failed(me))
+        return ES_FAILED;
+      if (me_modified(me))
+        es = ES_NOFIX;
+    }      
+    return es;
+  }
+
+  template <class View>
+  ExecStatus
+  Base<View>::path(Space* home) {
+    // Prunes that partial assigned paths are not completed to cycles
+
+    int n=x.size();
+
+    // The path starting at assigned x[i] ends at x[end[j]] which is
+    // not assigned.
+    GECODE_AUTOARRAY(int,end,n);
+    for (int i=n; i--; )
+      end[i]=-1;
+
+    // A stack that records all indices i such that end[i] != -1
+    GECODE_AUTOSTACK(int,-1,tell,n);
+
+    for (int i=y.size(); i--; ) {
+      assert(!y[i].assigned());
+      // Non-assigned views serve as starting points for assigned paths
+      ViewValues<View> v(y[i]);
+      // Try all connected values
+      do {
+        int j0=v.val();
+        // Starting point for not yet followed assigned path found
+        if (x[j0].assigned() && (end[j0] < 0)) {
+          // Follow assigned path until non-assigned view:
+          // all assigned view on the paths can be skipped, as
+          // if x[i] is assigned to j, then x[j] will only have
+          // x[i] as predecessor due to propagating distinct.
+          int j = j0;
+          do {
+            j=x[j].val();
+          } while (x[j].assigned());
+          // Now there cannot be a cycle from x[j] to x[v.val()]!
+          // However, the tell cannot be done here as j might be
+          // equal to i and might hence kill the iterator v!
+          end[j0]=j; tell.push(j0);
+        }
+        ++v;
+      } while (v());
+    }
+
+    // Now do the tells based on the end information
+    while (!tell.empty()) {
+      int i = tell.pop();
+      assert(end[i] >= 0);
+      GECODE_ME_CHECK(x[end[i]].nq(home,i));
+    }
+    return ES_NOFIX;
+  }
+
+  template <class View>
+  forceinline size_t
+  Base<View>::dispose(Space* home) {
+    (void) NaryPropagator<View,PC_INT_DOM>::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View>
+  Reflection::ActorSpec
+  Base<View>::spec(const Space* home, Reflection::VarMap& m,
+                   const Support::Symbol& name) const {
+    return NaryPropagator<View,PC_INT_DOM>::spec(home, m, name);                   
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.2.0/gecode/int/circuit/val.icc

@@ -0,0 +1,126 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:26:26 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7330 $
+ *
+ *  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 Circuit {
+
+  /*
+   * The actual propagator
+   *
+   */
+  template <class View>
+  forceinline
+  Val<View>::Val(Space* home, ViewArray<View>& x)
+    : Base<View>(home,x) {}
+
+  template <class View>
+  forceinline
+  Val<View>::Val(Space* home, bool share, Val<View>& p)
+    : Base<View>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Val<View>::copy(Space* home, bool share) {
+    return new (home) Val<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  Val<View>::cost(ModEventDelta) const {
+    return PC_LINEAR_HI;
+  }
+
+  template <class View>
+  Support::Symbol
+  Val<View>::ati(void) {
+    return Reflection::mangle<View>("Gecode::Int::Circuit::Val");
+  }
+
+  template <class View>
+  Reflection::ActorSpec
+  Val<View>::spec(const Space* home, Reflection::VarMap& m) const {
+    return Base<View>::spec(home, m, ati());
+  }
+
+  template <class View>
+  void
+  Val<View>::post(Space* home, Reflection::VarMap& vars,
+                  const Reflection::ActorSpec& spec) {
+    spec.checkArity(1);
+    ViewArray<View> x(home, vars, spec[0]);
+    (void) new (home) Val<View>(home, x);
+  }
+
+  template <class View>
+  ExecStatus
+  Val<View>::propagate(Space* home, ModEventDelta) {
+    GECODE_ES_CHECK((Distinct::prop_val<View,true>(home,y)));
+    ExecStatus esc = connected(home);
+    if (esc != ES_FIX)
+      return esc;
+    /*
+     * One cannot have a single unassigned view as the views constitute
+     * a permutation.
+     */
+    if (y.size() < 2)
+      return ES_SUBSUMED(this,home);
+    return path(home);
+  }
+
+  template <class View>
+  ExecStatus
+  Val<View>::post(Space* home, ViewArray<View>& x) {
+    int n = x.size();
+    if (n == 1) {
+      GECODE_ME_CHECK(x[0].eq(home,0));
+    } else if (n == 2) {
+      GECODE_ME_CHECK(x[0].eq(home,1));
+      GECODE_ME_CHECK(x[1].eq(home,0));
+    } else {
+      for (int i=n; i--; ) {
+        GECODE_ME_CHECK(x[i].gq(home,0));
+        GECODE_ME_CHECK(x[i].le(home,n));
+        GECODE_ME_CHECK(x[i].nq(home,i));
+      }
+      (void) new (home) Val<View>(home,x);
+    }
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.2.0/gecode/int/count.hh

@@ -0,0 +1,487 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_COUNT_HH__
+#define __GECODE_INT_COUNT_HH__
+
+#include "gecode/int.hh"
+
+/**
+ * \namespace Gecode::Int::Count
+ * \brief Counting propagators
+ */
+
+namespace Gecode { namespace Int { namespace Count {
+
+  /**
+   * Relations for domain consistent counting
+   *
+   */
+  //@{
+  /// Test whether \a x and \a y are equal
+  template <class VX>
+  RelTest holds(VX x, VX y);
+  /// Test whether \a x and \a y are equal
+  template <class VX>
+  RelTest holds(VX x, ConstIntView y);
+  /// Post that all views in \a x are equal to \a y
+  template <class VX>
+  bool post_true(Space* home, ViewArray<VX>& x, VX y);
+  /// Post that all views in \a x are equal to \a y
+  template <class VX>
+  bool post_true(Space* home, ViewArray<VX>& x, ConstIntView y);
+  /// Post that all views in \a x are not equal to \a y
+  template <class VX>
+  bool post_false(Space* home, ViewArray<VX>& x, VX y);
+  /// Post that all views in \a x are not equal to \a y
+  template <class VX>
+  bool post_false(Space* home, ViewArray<VX>& x, ConstIntView y);
+  //@}
+
+}}}
+
+#include "gecode/int/count/rel.icc"
+
+
+namespace Gecode { namespace Int { namespace Count {
+
+  /**
+   * \brief Baseclass for count propagators (integer)
+   *
+   */
+  template <class VX, class VY>
+  class BaseInt : public Propagator {
+  protected:
+    /// Views still to count
+    ViewArray<VX> x;
+    /// Views from x[0] ... x[n_s-1] have subscriptions
+    int n_s;
+    /// View to compare to
+    VY y;
+    /// Number of views which are equal and have been eliminated
+    int c;
+    /// Constructor for cloning \a p
+    BaseInt(Space* home, bool share, BaseInt& p);
+    /// Constructor for creation
+    BaseInt(Space* home, ViewArray<VX>& x, int n_s, VY y, int c);
+    /// Specification for this propagator
+    Reflection::ActorSpec spec(const Space* home, Reflection::VarMap& m,
+                                const Support::Symbol& name) const;
+  public:
+    /// Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief %Propagator for counting views (equal integer to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY>
+  class EqInt : public BaseInt<VX,VY> {
+  protected:
+    using BaseInt<VX,VY>::x;
+    using BaseInt<VX,VY>::n_s;
+    using BaseInt<VX,VY>::y;
+    using BaseInt<VX,VY>::c;
+    /// Constructor for cloning \a p
+    EqInt(Space* home, bool share, EqInt& p);
+    /// Constructor for creation
+    EqInt(Space* home, ViewArray<VX>& x, int n_s, VY y, int c);
+  public:
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, int c);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+  };
+
+  /**
+   * \brief %Propagator for counting views (greater or equal integer to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY>
+  class GqInt : public BaseInt<VX,VY> {
+  protected:
+    using BaseInt<VX,VY>::x;
+    using BaseInt<VX,VY>::n_s;
+    using BaseInt<VX,VY>::y;
+    using BaseInt<VX,VY>::c;
+    /// Constructor for cloning \a p
+    GqInt(Space* home, bool share, GqInt& p);
+    /// Constructor for creation
+    GqInt(Space* home, ViewArray<VX>& x, int n_s, VY y, int c);
+  public:
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, int c);
+  };
+
+  /**
+   * \brief %Propagator for counting views (less or equal integer to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY>
+  class LqInt : public BaseInt<VX,VY> {
+  protected:
+    using BaseInt<VX,VY>::x;
+    using BaseInt<VX,VY>::n_s;
+    using BaseInt<VX,VY>::y;
+    using BaseInt<VX,VY>::c;
+    /// Constructor for cloning \a p
+    LqInt(Space* home, bool share, LqInt& p);
+    /// Constructor for creation
+    LqInt(Space* home, ViewArray<VX>& x, int n_s, VY y, int c);
+  public:
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, int c);
+  };
+
+  /**
+   * \brief %Propagator for counting views (not equal integer to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class VX, class VY>
+  class NqInt : public BinaryPropagator<VX,PC_INT_DOM> {
+  protected:
+    using BinaryPropagator<VX,PC_INT_DOM>::x0;
+    using BinaryPropagator<VX,PC_INT_DOM>::x1;
+    /// Views not yet subscribed to
+    ViewArray<VX> x;
+    /// View to compare with
+    VY y;
+    /// Righthandside
+    int c;
+    /// Update subscription
+    bool resubscribe(Space* home, VX& z);
+    /// Constructor for posting
+    NqInt(Space* home,  ViewArray<VX>& x, VY y, int c);
+    /// Constructor for cloning \a p
+    NqInt(Space* home, bool share, NqInt& p);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost function (defined as PC_LINEAR_LO)
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\neq c\f$
+    static  ExecStatus post(Space* home, ViewArray<VX>& x, VY y, int c);
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+}}}
+
+#include "gecode/int/count/int.icc"
+
+
+namespace Gecode { namespace Int { namespace Count {
+
+  /**
+   * \brief Base-class for count propagators (view)
+   *
+   */
+  template <class VX, class VY, class VZ, bool shr>
+  class BaseView : public Propagator {
+  protected:
+    /// Views still to count
+    ViewArray<VX> x;
+    /// View to compare to
+    VY y;
+    /// View which yields result of counting
+    VZ z;
+    /// Number of views which are equal and have been eliminated
+    int   c;
+    /// Constructor for cloning \a p
+    BaseView(Space* home, bool shr, BaseView& p);
+    /// Constructor for creation
+    BaseView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+    /// Specification for this propagator
+    Reflection::ActorSpec spec(const Space* home, Reflection::VarMap& m,
+                                const Support::Symbol& name) const;
+  public:
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(ModEventDelta med) const;
+  protected:
+    /// Count how many views are equal now
+    void count(Space* home);
+    /// How many views are at least equal
+    int atleast(void) const;
+    /// How many views are at most equal
+    int atmost(void) const;
+    /// Test whether there is sharing of \a z with \a x or \a y
+    static bool sharing(const ViewArray<VX>& x, const VY& y, const VZ& z);
+  };
+
+  /**
+   * \brief %Propagator for counting views (equal to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY, class VZ, bool shr>
+  class EqView : public BaseView<VX,VY,VZ,shr> {
+  protected:
+    using BaseView<VX,VY,VZ,shr>::x;
+    using BaseView<VX,VY,VZ,shr>::z;
+    using BaseView<VX,VY,VZ,shr>::c;
+    using BaseView<VX,VY,VZ,shr>::y;
+    using BaseView<VX,VY,VZ,shr>::count;
+    using BaseView<VX,VY,VZ,shr>::atleast;
+    using BaseView<VX,VY,VZ,shr>::atmost;
+
+    /// Constructor for cloning \a p
+    EqView(Space* home, bool shr, EqView& p);
+  public:
+    /// Constructor for creation
+    EqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool shr);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}=z+c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+  };
+
+  /**
+   * \brief %Propagator for counting views (different from number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY, class VZ, bool shr>
+  class NqView : public BaseView<VX,VY,VZ,shr> {
+  protected:
+    using BaseView<VX,VY,VZ,shr>::x;
+    using BaseView<VX,VY,VZ,shr>::z;
+    using BaseView<VX,VY,VZ,shr>::c;
+    using BaseView<VX,VY,VZ,shr>::y;
+    using BaseView<VX,VY,VZ,shr>::count;
+    using BaseView<VX,VY,VZ,shr>::atleast;
+    using BaseView<VX,VY,VZ,shr>::atmost;
+
+    /// Constructor for cloning \a p
+    NqView(Space* home, bool shr, NqView& p);
+  public:
+    /// Constructor for creation
+    NqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool shr);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\neq z+c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+  };
+
+  /**
+   * \brief %Propagator for counting views (less or equal to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY, class VZ, bool shr>
+  class LqView : public BaseView<VX,VY,VZ,shr> {
+  protected:
+    using BaseView<VX,VY,VZ,shr>::x;
+    using BaseView<VX,VY,VZ,shr>::z;
+    using BaseView<VX,VY,VZ,shr>::c;
+    using BaseView<VX,VY,VZ,shr>::y;
+    using BaseView<VX,VY,VZ,shr>::count;
+    using BaseView<VX,VY,VZ,shr>::atleast;
+    using BaseView<VX,VY,VZ,shr>::atmost;
+
+    /// Constructor for cloning \a p
+    LqView(Space* home, bool shr, LqView& p);
+  public:
+    /// Constructor for creation
+    LqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool shr);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\leq z+c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+  };
+
+  /**
+   * \brief %Propagator for counting views (greater or equal to number of equal views)
+   *
+   * Not all combinations of views are possible. The types \a VX
+   * and \a VY must be either equal, or \a VY must be ConstIntView.
+   *
+   * Requires \code #include "gecode/int/count.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class VX, class VY, class VZ, bool shr>
+  class GqView : public BaseView<VX,VY,VZ,shr> {
+  protected:
+    using BaseView<VX,VY,VZ,shr>::x;
+    using BaseView<VX,VY,VZ,shr>::z;
+    using BaseView<VX,VY,VZ,shr>::c;
+    using BaseView<VX,VY,VZ,shr>::y;
+    using BaseView<VX,VY,VZ,shr>::count;
+    using BaseView<VX,VY,VZ,shr>::atleast;
+    using BaseView<VX,VY,VZ,shr>::atmost;
+
+    /// Constructor for cloning \a p
+    GqView(Space* home, bool shr, GqView& p);
+  public:
+    /// Constructor for creation
+    GqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+    /// Create copy during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post propagator according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+    /// Post propagator for \f$\#\{i\in\{0,\ldots,|x|-1\}\;|\;x_i=y\}\geq z+c\f$
+    static ExecStatus post(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
+  };
+
+}}}
+
+#include "gecode/int/count/view.icc"
+
+#endif
+
+// STATISTICS: int-prop
+