gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/gcc/lbc.icc

@@ -0,0 +1,375 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 { namespace Int { namespace GCC {
+
+  /**
+   * \brief Lower Bounds constraint (LBC) stating
+   * \f$ \forall j \in \{0, \dots, |k|-1\}:
+   * \#\{i\in\{0, \dots, |x| - 1\} | x_i = card(k_j)\} \geq min(k_j)\f$
+   * Hence the lbc constraints the variables such that every value occurs
+   * at least as often as specified by its lower cardinality bound.
+   * \param home current space
+   * \param x  the problem variables
+   * \param nb denotes number of unique bounds
+   * \param hall contains information about the hall structure of the problem
+   *        (cf. HallInfo)
+   * \param rank ranking information about the variable bounds (cf. Rank)
+   * \param lps partial sum structure for the lower cardinality bounds (cf. PartialSum)
+   * \param mu permutation \f$ \mu \f$ such that
+   *        \f$ \forall i\in \{0, \dots, |x|-2\}:
+   *        max(x_{\mu(i)}) \leq max(x_{\mu(i+1)})\f$
+   * \param nu permutation \f$ \nu \f$ such that
+   *        \f$ \forall i\in \{0, \dots, |x|-2\}:
+   *        min(x_{\mu(i)}) \leq min(x_{\mu(i+1)})\f$
+   */
+
+  template <class View, class Card, bool shared>
+  inline ExecStatus
+  lbc(Space* home, ViewArray<View>& x, int& nb,
+      HallInfo hall[], Rank rank[],
+      PartialSum<Card>* lps,
+      int mu[], int nu[]){
+
+    ExecStatus es = ES_FIX;
+    int n = x.size();
+
+    /*
+     *  Let I(S) denote the number of variables whose domain intersects
+     *  the set S and C(S) the number of variables whose domain is containded
+     *  in S. Let further  min_cap(S) be the minimal number of variables
+     *  that must be assigned to values, that is
+     *  min_cap(S) is the sum over all l[i] for a value v_i that is an
+     *  element of S.
+     *
+     *  A failure set is a set F if
+     *       I(F) < min_cap(F)
+     *  An unstable set is a set U if
+     *       I(U) = min_cap(U)
+     *  A stable set is a set S if
+     *      C(S) > min_cap(S) and S intersetcs nor
+     *      any failure set nor any unstable set
+     *      forall unstable and failure sets
+     *
+     *  failure sets determine the satisfiability of the LBC
+     *  unstable sets have to be pruned
+     *  stable set do not have to be pruned
+     *
+     * hall[].ps ~ stores the unstable
+     *             sets that have to be pruned
+     * hall[].s  ~ stores sets that must not be pruned
+     * hall[].h  ~ contains stable and unstable sets
+     * hall[].d  ~ contains the difference between interval bounds, i.e.
+     *             the minimal capacity of the interval
+     * hall[].t  ~ contains the critical capacity pointer, pointing to the
+     *             values
+     */
+
+    // LBC lower bounds
+
+    int i = 0;
+    int j = 0;
+    int w = 0;
+    int z = 0;
+    int v = 0;
+
+    //initialization of the tree structure
+    int rightmost = nb + 1; // rightmost accesible value in bounds
+    int bsize     = nb + 2;
+    w = rightmost;
+
+    // test
+    // unused but uninitialized
+    hall[0].d = 0;
+    hall[0].s = 0;
+    hall[0].ps = 0;
+
+    for (i = bsize; --i; ) { // i must not be zero
+      int pred   = i - 1;
+      hall[i].s  = pred;
+      hall[i].ps = pred;
+      hall[i].d  = lps->sumup(hall[pred].bounds, hall[i].bounds - 1);
+
+      /* Let [hall[i].bounds,hall[i-1].bounds]=:I
+       * If the capacity is zero => min_cap(I) = 0
+       * => I cannot be a failure set
+       * => I is an unstable set
+       */
+      if (hall[i].d == 0) {
+	hall[pred].h = w;
+      } else {
+	hall[w].h = pred;
+	w         = pred;
+      }
+    }
+
+    w = rightmost;
+    for (i = bsize; i--; ) { // i can be zero
+      hall[i].t = i - 1;
+      if (hall[i].d == 0) {
+	hall[i].t = w;
+      } else {
+	hall[w].t = i;
+	w = i;
+      }
+    }
+
+    /*
+     * The algorithm assigns to each value v in bounds
+     * empty buckets corresponding to the minimal capacity l[i] to be
+     * filled for v. (the buckets correspond to hall[].d containing the
+     * difference between the interval bounds) Processing it
+     * searches for the smallest value v in dom(x_i) that has an
+     * empty bucket, i.e. if all buckets are filled it is guaranteed
+     * that there are at least l[i] variables that will be
+     * instantiated to v. Since the buckets are initially empty,
+     * they are considered as FAILURE SETS
+     */
+
+    for (i = 0; i < n; i++) {
+      // visit intervals in increasing max order
+      int x0   = rank[mu[i]].min;
+      int y    = rank[mu[i]].max;
+      int succ = x0 + 1;
+      z        = pathmax_t(hall, succ);
+      j        = hall[z].t;
+
+      /*
+       * POTENTIALLY STABLE SET:
+       *  z \neq succ \Leftrigharrow z>succ, i.e.
+       *  min(D_{\mu(i)}) is guaranteed to occur min(K_i) times
+       *  \Rightarrow [x0, min(y,z)] is potentially stable
+       */
+
+      if (z != succ) {
+	w = pathmax_ps(hall, succ);
+	v = hall[w].ps;
+	pathset_ps(hall, succ, w, w);
+	w = std::min(y, z);
+	pathset_ps(hall, hall[w].ps, v, w);
+	hall[w].ps = v;
+      }
+
+      /*
+       * STABLE SET:
+       *   being stable implies being potentially stable, i.e.
+       *   [hall[y].ps, hall[y].bounds-1] is the largest stable subset of
+       *   [hall[j].bounds, hall[y].bounds-1].
+       */
+
+      if (hall[z].d <= lps->sumup(hall[y].bounds, hall[z].bounds - 1)) {
+	w = pathmax_s(hall, hall[y].ps);
+	pathset_s(hall, hall[y].ps, w, w);
+	// Path compression
+	v = hall[w].s;
+	pathset_s(hall, hall[y].s, v, y);
+	hall[y].s = v;
+      } else {
+	/*
+	 * FAILURE SET:
+	 * If the considered interval [x0,y] is neither POTENTIALLY STABLE
+	 * nor STABLE there are still buckets that can be filled,
+	 * therefore d can be decreased. If d equals zero the intervals
+	 * minimum capacity is met and thepath can be compressed to the
+	 * next value having an empty bucket.
+	 * see DOMINATION in "gcc/ubc.icc"
+	 */
+	if (--hall[z].d == 0) {
+	  hall[z].t = z + 1;
+	  z         = pathmax_t(hall, hall[z].t);
+	  hall[z].t = j;
+	}
+
+	/*
+	 * FINDING NEW LOWER BOUND:
+	 * If the lower bound belongs to an unstable or a stable set,
+	 * remind the new value we might assigned to the lower bound
+	 * in case the variable doesn't belong to a stable set.
+	 */
+	if (hall[x0].h > x0) {
+	  hall[i].newBound = pathmax_h(hall, x0);
+	  w                = hall[i].newBound;
+	  pathset_h(hall, x0, w, w); // path compression
+	} else {
+	  // Do not shrink the variable: take old min as new min
+	  hall[i].newBound = x0;
+	}
+
+	/* UNSTABLE SET
+	 * If an unstable set is discovered
+	 * the difference between the interval bounds is equal to the
+	 * number of variables whose domain intersect the interval
+	 * (see ZEROTEST in "gcc/ubc.icc")
+	 */
+	// CLEARLY THIS WAS NOT STABLE == UNSTABLE
+	if (hall[z].d == lps->sumup(hall[y].bounds, hall[z].bounds - 1)) {
+	  if (hall[y].h > y)
+	    /*
+	     * y is not the end of the potentially stable set
+	     * thus ensure that the potentially stable superset is marked
+	     */
+	    y = hall[y].h;
+	  // Equivalent to pathmax since the path is fully compressed
+	  int predj = j - 1;
+	  pathset_h(hall, hall[y].h, predj, y);
+	  // mark the new unstable set [j,y]
+	  hall[y].h = predj;
+	}
+      }
+      pathset_t(hall, succ, z, z); // path compression
+    }
+
+    /* If there is a FAILURE SET left the minimum occurences of the values
+     * are not guaranteed. In order to satisfy the LBC the last value
+     * in the stable and unstable datastructure hall[].h must point to
+     * the sentinel at the beginning of bounds.
+     */
+    if (hall[nb].h != 0) {
+      return ES_FAILED; // no solution
+    }
+
+    // Perform path compression over all elements in
+    // the stable interval data structure. This data
+    // structure will no longer be modified and will be
+    // accessed n or 2n times. Therefore, we can afford
+    // a linear time compression.
+    for (i = bsize; --i;) {
+      if (hall[i].s > i) {
+	hall[i].s = w;
+      } else {
+	w = i;
+      }
+    }
+
+    /*
+     * UPDATING LOWER BOUND:
+     * For all variables that are not a subset of a stable set,
+     * shrink the lower bound, i.e. forall stable sets S we have:
+     * x0 < S_min <= y <=S_max  or S_min <= x0 <= S_max < y
+     * that is [x0,y] is NOT a proper subset of any stable set S
+     */
+    for (i = n; i--; ) {
+      int x0 = rank[mu[i]].min;
+      int y  = rank[mu[i]].max;
+      // update only those variables that are not contained in a stable set
+      if ((hall[x0].s <= x0) || (y > hall[x0].s)) {
+	//still have to check this out, how skipping works (consider dominated indices)
+	int m = lps->skipNonNullElementsRight(hall[hall[i].newBound].bounds);
+	ModEvent me = x[mu[i]].gq(home, m);
+	GECODE_ME_CHECK(me);
+	if (me_modified(me) && m != x[mu[i]].min()) {
+	  es = ES_NOFIX;
+	}
+	if (shared && me_modified(me)) {
+	  es = ES_NOFIX;
+	}
+      }
+    }
+
+    //LBC narrow upper bounds
+
+    w = 0;
+    for (i = 0; i <= nb; i++) {
+      hall[i].d = lps->sumup(hall[i].bounds, hall[i + 1].bounds - 1);
+      if (hall[i].d == 0) {
+	hall[i].t = w;
+      } else {
+	hall[w].t = i;
+	w         = i;
+      }
+    }
+    hall[w].t = i;
+
+    w         = 0;
+    for (i = 1; i <= nb; i++) {
+      if (hall[i - 1].d == 0) {
+	hall[i].h = w;
+      } else {
+         hall[w].h = i;
+         w         = i;
+      }
+    }
+    hall[w].h = i;
+
+    for (i = n; i--; ) {
+      // visit intervals in decreasing min order
+      // i.e. minsorted from right to left
+      int x0   = rank[nu[i]].max;
+      int y    = rank[nu[i]].min;
+      int pred = x0 - 1; // predecessor of x0 in the indices
+      z        = pathmin_t(hall, pred);
+      j        = hall[z].t;
+
+      /* If the variable is not in a discovered stable set
+       * (see above condition for STABLE SET)
+       */
+      if (hall[z].d > lps->sumup(hall[z].bounds, hall[y].bounds - 1)) {
+	//FAILURE SET
+	if (--hall[z].d == 0) {
+	  hall[z].t = z - 1;
+	  z         = pathmin_t(hall, hall[z].t);
+	  hall[z].t = j;
+	}
+	//FINDING NEW UPPER BOUND
+	if (hall[x0].h < x0) {
+	  w                = pathmin_h(hall, hall[x0].h);
+	  hall[i].newBound = w;
+	  pathset_h(hall, x0, w, w); // path compression
+	} else {
+	  hall[i].newBound = x0;
+	}
+	//UNSTABLE SET
+	if (hall[z].d == lps->sumup(hall[z].bounds, hall[y].bounds - 1)) {
+	  if (hall[y].h < y) {
+	    y = hall[y].h;
+	  }
+	  int succj = j + 1;
+	  //mark new unstable set [y,j]
+	  pathset_h(hall, hall[y].h, succj, y);
+	  hall[y].h = succj;
+	}
+      }
+      pathset_t(hall, pred, z, z);
+    }
+
+    // UPDATING UPPER BOUND
+    for (i = n; i--; ) {
+      int x0 =  rank[nu[i]].min;
+      int y  =  rank[nu[i]].max;
+      if ((hall[x0].s <= x0) || (y > hall[x0].s)){
+	int m = lps->skipNonNullElementsLeft(hall[hall[i].newBound].bounds - 1);
+	ModEvent me = x[nu[i]].lq(home, m);
+	GECODE_ME_CHECK(me);
+	if (me_modified(me) && m != x[nu[i]].max()) {
+	  es = ES_NOFIX;
+	}
+	if (shared && me_modified(me)) {
+	  es = ES_NOFIX;
+	}
+      }
+    }
+    return es;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/gcc/occur.icc

@@ -0,0 +1,687 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified: $Date: 2006-08-24 11:25:05 +0200 (Thu, 24 Aug 2006) $ by $Author: schulte $
+ *  $Revision: 3559 $
+ *
+ *  This file is part of Gecode, the generic constrain
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#include "gecode/iter.hh"
+
+namespace Gecode { namespace Int { namespace GCC {
+  /**
+   * \brief Tuple conataining the lower and upper cardinality bounds
+   *
+   */
+  class OccurBndsView {
+  private:
+    int _min;
+    int _max;
+    int c;
+    int count;
+  public:
+    OccurBndsView(void);
+    int min(void) const;
+    int max(void) const;
+    int card(void) const;
+    int counter(void) const;
+
+    void min(int);
+    void max(int);
+    void card(int c);
+    void counter(int c);
+
+    void init(Space* home, int min, int max, int c);
+    ModEvent lq(Space* home, int n);
+    ModEvent gq(Space* home, int n);
+    ModEvent eq(Space* home, int n);
+    bool assigned(void) const;
+    bool modified(void) const;
+    bool range(void) const;
+    ModEvent inc(void);
+
+    void cancel(Space* home, Propagator* , PropCond ) {}
+    void subscribe(Space*, Propagator* , PropCond, bool=true) {}
+
+    void update(Space*, bool, OccurBndsView&);
+  };
+
+  forceinline
+  OccurBndsView::OccurBndsView(void) {}
+
+  forceinline int
+  OccurBndsView::min(void) const {
+    return _min;
+  }
+
+  forceinline int
+  OccurBndsView::max(void) const {
+    return _max;
+  }
+
+  forceinline int
+  OccurBndsView::card(void) const {
+    return c;
+  }
+
+  forceinline int
+  OccurBndsView::counter(void) const {
+    return count;
+  }
+
+  forceinline void
+  OccurBndsView::min(int m) {
+    _min = m;
+  }
+
+  forceinline void
+  OccurBndsView::max(int m) {
+    _max = m;
+  }
+
+  forceinline void
+  OccurBndsView::card(int ca) {
+    c = ca;
+  }
+
+  forceinline void
+  OccurBndsView::counter(int count0) {
+    count = count0;
+  }
+
+  forceinline void
+  OccurBndsView::init(Space* home, int min, int max, int val) {
+    _min = min; _max=max;
+    c = val;
+    count = 0;
+  }
+
+  forceinline ModEvent
+  OccurBndsView::inc(void) {
+    count++;
+    if (count > _max) {
+      return ME_GEN_FAILED;
+    } else {
+      return ME_GEN_NONE;
+    }
+  }
+
+  forceinline bool
+  OccurBndsView::assigned(void) const {
+    return _min==_max;
+  }
+
+  forceinline bool
+  OccurBndsView::modified(void) const {
+    return false;
+  }
+
+  forceinline bool
+  OccurBndsView::range(void) const {
+    return true;
+  }
+
+
+  forceinline ModEvent
+  OccurBndsView::lq(Space*, int i){
+    // the maximum can be made consistent
+    if (_min > i) {
+      return ME_GEN_FAILED;
+    } else {
+      return ME_GEN_NONE;
+    }
+  }
+
+  forceinline ModEvent
+  OccurBndsView::gq(Space*, int i){
+    // this bound is fix
+    if (_max < i) {
+      return ME_GEN_FAILED;
+    }
+    return ME_GEN_NONE;
+  }
+
+  forceinline ModEvent
+  OccurBndsView::eq(Space*, int i){
+    if (_min > i || _max < i) {
+      return ME_GEN_FAILED;
+    } else {
+      return ME_GEN_NONE;
+    }
+  }
+
+  /// \brief Debugging: print a fixed cardinality
+  forceinline std::ostream&
+  operator<<(std::ostream& os, OccurBndsView& xs) {
+    os << xs.card() << "("<< xs.counter() <<")[";
+    os << xs.min() << "," << xs.max() << "]";
+    return os;
+  }
+
+  forceinline void
+  OccurBndsView::update(Space*, bool, OccurBndsView& oc) {
+    _min = oc._min;
+    _max = oc._max;
+    c = oc.c;
+    count = oc.count;
+  }
+
+  /**
+   * \brief Return the index of v in the array
+   *
+   *  Complexity is \f$O(log(|k|))\f$
+   */
+  template <class T>
+  forceinline int
+  lookupValue(T& a, int v){
+    int idx = -1;
+
+    int l  = 0;
+    int r  = a.size() - 1;
+
+    if (r == 0) {
+      if (a[0].card() == v) {
+	return 0;
+      } else {
+	return -1;
+      }
+    }
+
+    while ( l < r ) {
+      if ( a[l].card() == v) {
+	idx = l;
+	break;
+      }
+      if ( a[r].card() == v) {
+	idx = r;
+	break;
+      }
+      int p  = (l + r) / 2;
+      if ( v == a[p].card()) {
+	idx = p;
+	break;
+      } else {
+	if ( v < a[p].card()) {
+	  r = p;
+	} else {
+	  l = p;
+	}
+      }
+      if (l == r - 1) {
+	break;
+      }
+    }
+
+    return idx;
+  }
+
+
+  /**
+   * \brief Card integer view
+   *
+   */
+  class CardView : public DerivedViewBase<IntView> {
+  protected:
+    /// Card
+    int c;
+    /// Counter
+    int count;
+    using DerivedViewBase<IntView>::view;
+  public:
+    CardView(void);
+    /// Initialize with integer view \a x and value \a c
+    CardView(const IntView& x, int c);
+    /// Initialize with integer view \a x and value \a c
+    void init(const IntView& x, int c);
+    void init(Space* home, int mi, int ma , int c);
+
+    /// Return value
+    int card(void) const;
+    void card(int ca);
+
+    /// Increment counter
+    ModEvent inc(void);
+    /// Set the counter to the number of times value \a c occurs
+    void counter(int);
+    /// Return the number of times value \a c occurs
+    int counter(void);
+
+    /// \name Value access
+    //@{
+    void operator=(const IntView& x);
+    void operator=(const Gecode::Int::GCC::CardView& x);
+    /// Return minimum of domain
+    int min(void) const;
+    /// Return maximum of domain
+    int max(void) const;
+    /// Return median of domain
+    int med(void) const;
+    /// Return assigned value (only if assigned)
+    int val(void) const;
+    /// Return used IntView
+    IntView intview(void);
+    /// Return size (cardinality) of domain
+    unsigned int size(void) const;
+    /// Return width of domain (distance between maximum and minimum)
+    unsigned int width(void) const;
+    /// Return regret of domain minimum (distance to next larger value)
+    unsigned int regret_min(void) const;
+    /// Return regret of domain maximum (distance to next smaller value)
+    unsigned int regret_max(void) const;
+    ///@}
+
+    /// \name Domain tests
+    ///@{
+    /// Test whether domain is a range
+    bool range(void) const;
+    /// Test whether view is assigned
+    bool assigned(void) const;
+
+    /// Test whether \a n is contained in domain
+    bool in(int n) const;
+    /// Test whether \a n is contained in domain
+    bool in(double n) const;
+    ///@}
+
+    /// \name Domain update by value
+    ///@{
+    /// Restrict domain values to be less or equal than \a n
+    ModEvent lq(Space* home, int n);
+    /// Restrict domain values to be less or equal than \a n
+    ModEvent lq(Space* home, double n);
+    /// Restrict domain values to be less than \a n
+    ModEvent le(Space* home, int n);
+    /// Restrict domain values to be less than \a n
+    ModEvent le(Space* home, double n);
+    /// Restrict domain values to be greater or equal than \a n
+    ModEvent gq(Space* home, int n);
+    /// Restrict domain values to be greater or equal than \a n
+    ModEvent gq(Space* home, double n);
+    /// Restrict domain values to be greater than \a n
+    ModEvent gr(Space* home, int n);
+    /// Restrict domain values to be greater than \a n
+    ModEvent gr(Space* home, double n);
+    /// Restrict domain values to be different from \a n
+    ModEvent nq(Space* home, int n);
+    /// Restrict domain values to be different from \a n
+    ModEvent nq(Space* home, double n);
+    /// Restrict domain values to be equal to \a n
+    ModEvent eq(Space* home, int n);
+    /// Restrict domain values to be equal to \a n
+    ModEvent eq(Space* home, double n);
+    ///@}
+
+    /// \name Domain update by range iterator
+    ///@{
+    /// Replace domain by range sequence described by \a i
+    /// Intersect domain with range sequence described by \a i
+    template <class I> ModEvent inter(Space* home, I& i);
+    /// Remove from domain the range sequence described by \a i
+    template <class I> ModEvent minus(Space* home, I& i);
+    ///@}
+
+    /// \name Propagator modification events
+    ///@{
+    /// Return modification event of propagator \a p for view
+    static ModEvent     pme(const Propagator* p);
+    /// Translate modification event \a me to propagator modification event for view
+    static PropModEvent pme(ModEvent me);
+    ///@}
+
+    /// \name Dependencies
+    ///@{
+    /// Subscribe propagator \a p with propagation condition \a pc to view
+    void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+    /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+    void cancel(Space* home, Propagator* p, PropCond pc);
+    ///@}
+
+    /// \name Cloning
+    ///@{
+    /// Update this view to be a clone of view \a x
+    void update(Space* home, bool share, CardView& x);
+    ///@}
+
+    /// \name View comparison
+    ///@{
+    /// Test whether this view is the same as \a x
+    bool operator ==(const CardView& x) const;
+    /// Test whether this view is not the same as \a x
+    bool operator !=(const CardView& x) const;
+    /// Test whether this view is smaller than \a x (arbitrary order)
+    bool operator < (const CardView& x) const;
+    /// Test whether this view is larger than \a x (arbitrary order)
+    bool operator > (const CardView& x) const;
+    ///@}
+  };
+
+  /*
+   * Constructors and initialization
+   *
+   */
+  forceinline
+  CardView::CardView(void) {}
+
+  forceinline
+  CardView::CardView(const IntView& x, int d)
+    : DerivedViewBase<IntView>(x), c(d), count(0) {}
+
+  forceinline void
+  CardView::init(const IntView& x, int d) {
+    view  = x;
+    c     = d;
+    count = 0;
+  }
+
+
+  forceinline void
+  CardView::init(Space* home, int mi, int ma, int d) {
+    IntVar ivar(home, mi, ma);
+    IntView iview(ivar);
+    view  = iview;
+    c     = d;
+    count = 0;
+  }
+
+  forceinline void
+  CardView::card(int ca) {
+    c = ca;
+  }
+
+  forceinline int
+  CardView::card(void) const {
+    return c;
+  }
+
+  forceinline ModEvent
+  CardView::inc(void) {
+    count++;
+    if (count > this->max()) {
+      return ME_GEN_FAILED;
+    } else {
+      return ME_GEN_NONE;
+    }
+  }
+
+  forceinline void
+  CardView::counter(int c) {
+    count = c;
+  }
+
+  forceinline int
+  CardView::counter(void) {
+    return count;
+  }
+
+  /*
+   * Value access
+   *
+   */
+
+  forceinline void
+  CardView::operator=(const IntView& x) {
+    view  = x;
+    c     = 0;
+    count = 0;
+  }
+
+  forceinline void
+  CardView::operator=(const CardView& x) {
+    view  = x.view;
+    c     = x.c;
+    count = x.count;
+  }
+
+
+  forceinline int
+  CardView::min(void) const {
+    return view.min();
+  }
+  forceinline int
+  CardView::max(void) const {
+    return view.max();
+  }
+  forceinline int
+  CardView::med(void) const {
+    return view.med();
+  }
+
+  forceinline int
+  CardView::val(void) const {
+    return view.val();
+  }
+
+  forceinline IntView
+  CardView::intview(void){
+    return view;
+  }
+
+
+  forceinline unsigned int
+  CardView::width(void) const {
+    return view.width();
+  }
+  forceinline unsigned int
+  CardView::size(void) const {
+    return view.size();
+  }
+  forceinline unsigned int
+  CardView::regret_min(void) const {
+    return view.regret_min();
+  }
+  forceinline unsigned int
+  CardView::regret_max(void) const {
+    return view.regret_max();
+  }
+
+  /*
+   * Domain tests
+   *
+   */
+  forceinline bool
+  CardView::range(void) const {
+    return view.range();
+  }
+  forceinline bool
+  CardView::assigned(void) const {
+    return view.assigned();
+  }
+
+  forceinline bool
+  CardView::in(int n) const {
+    return view.in(n);
+  }
+  forceinline bool
+  CardView::in(double n) const {
+    return view.in(n);
+  }
+
+
+  /*
+   * Domain update by value
+   *
+   */
+  forceinline ModEvent
+  CardView::lq(Space* home, int n) {
+    return view.lq(home,n);
+  }
+  forceinline ModEvent
+  CardView::lq(Space* home, double n) {
+    return view.lq(home,n);
+  }
+  forceinline ModEvent
+  CardView::le(Space* home, int n) {
+    return view.le(home,n);
+  }
+  forceinline ModEvent
+  CardView::le(Space* home, double n) {
+    return view.le(home,n);
+  }
+  forceinline ModEvent
+  CardView::gq(Space* home, int n) {
+    return view.gq(home,n);
+  }
+  forceinline ModEvent
+  CardView::gq(Space* home, double n) {
+    return view.gq(home,n);
+  }
+  forceinline ModEvent
+  CardView::gr(Space* home, int n) {
+    return view.gr(home,n);
+  }
+  forceinline ModEvent
+  CardView::gr(Space* home, double n) {
+    return view.gr(home,n);
+  }
+  forceinline ModEvent
+  CardView::nq(Space* home, int n) {
+    return view.nq(home,n);
+  }
+  forceinline ModEvent
+  CardView::nq(Space* home, double n) {
+    return view.nq(home,n);
+  }
+  forceinline ModEvent
+  CardView::eq(Space* home, int n) {
+    return view.eq(home,n);
+  }
+  forceinline ModEvent
+  CardView::eq(Space* home, double n) {
+    return view.eq(home,n);
+  }
+
+
+  /*
+   * Domain update by range iterator
+   *
+   */
+  template <class I>
+  ModEvent
+  CardView::inter(Space* home, I& i) {
+    return view.inter(home,i);
+  }
+  template <class I>
+  ModEvent
+  CardView::minus(Space* home, I& i) {
+    return view.minus(home,i);
+  }
+
+
+
+  /*
+   * Propagator modification events
+   *
+   */
+  forceinline ModEvent
+  CardView::pme(const Propagator* p) {
+    return IntView::pme(p);
+  }
+  forceinline PropModEvent
+  CardView::pme(ModEvent me) {
+    return IntView::pme(me);
+  }
+
+
+  /*
+   * Dependencies
+   *
+   */
+  forceinline void
+  CardView::subscribe(Space* home, Propagator* p, PropCond pc, bool process) {
+    view.subscribe(home, p, pc, process);
+  }
+  forceinline void
+  CardView::cancel(Space* home, Propagator* p, PropCond pc) {
+    view.cancel(home,p, pc);
+  }
+
+
+  /*
+   * Cloning
+   *
+   */
+  forceinline void
+  CardView::update(Space* home, bool share, CardView& x) {
+    c     = x.c;
+    count = x.count;
+    view.update(home,share,x.view);
+  }
+
+
+
+}
+
+
+  /**
+   * \brief %Range iterator for indexed problem variables
+   */
+  template <>
+  class ViewRanges<GCC::CardView>
+    : public Gecode::Int::ViewRanges<IntView> {
+  public:
+    /// \name Constructors and initialization
+    ///@{
+    /// Default constructor
+    ViewRanges(void);
+    /// Initialize with ranges for view \a x
+    ViewRanges(const GCC::CardView& x);
+    /// Initialize with ranges for view \a x
+    void init(const GCC::CardView& x);
+    ///@}
+  };
+
+
+  /// \brief Debugging: print a cardinality variable
+  forceinline std::ostream&
+  operator<<(std::ostream& os, GCC::CardView& v) {
+    os << "("<<v.card() << ","<< v.counter() <<",";
+    if (v.min() == v.max()) {
+      os << v.min() <<" ";
+    } else {
+      if (v.range()){
+	os << "["<<v.min() <<".."<<v.max()<<"] ";
+      } else {
+	os << "{";
+	ViewValues<GCC::CardView> iter(v);
+	while(iter()){
+	  os << iter.val() <<",";
+	  ++iter;
+	}
+	os << "}";
+      }
+    }
+    os << ")";
+    return os;
+  }
+
+
+  forceinline
+  ViewRanges<GCC::CardView>::ViewRanges(void) :
+    Gecode::Int::ViewRanges<IntView>()  {}
+
+  forceinline
+  ViewRanges<GCC::CardView>::ViewRanges (const GCC::CardView& x)
+    : Gecode::Int::ViewRanges<IntView>(x.base())  {}
+
+  forceinline void
+  ViewRanges<GCC::CardView>::init(const GCC::CardView& x) {
+    Gecode::Int::ViewRanges<IntView> xi(x.base());
+  }
+
+}}
+
+
+
+// STATISTICS: int-prop