gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -1,271 +0,0 @@
-/* -*- 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-01-29 13:37:51 +0100 (Tue, 29 Jan 2008) $ by $Author: tack $
- *     $Revision: 5993 $
- *
- *  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
-    ExecStatus es = ES_FIX;
-    while (!tell.empty()) {
-      int i = tell.pop();
-      assert(end[i] >= 0);
-      ModEvent me = x[end[i]].nq(home,i);
-      if (me_failed(me))
-        return ES_FAILED;
-      if (me_modified(me))
-        es = ES_NOFIX;
-    }
-    return es;
-  }
-
-  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.1.1/gecode/int/circuit/val.icc

@@ -1,122 +0,0 @@
-/* -*- 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-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 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;
-    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.1.1/gecode/int/count.hh

@@ -1,487 +0,0 @@
-/* -*- 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-01-29 13:37:51 +0100 (Tue, 29 Jan 2008) $ by $Author: tack $
- *     $Revision: 5993 $
- *
- *  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
-