gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,391 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-08-09 15:30:21 +0200 (Thu, 09 Aug 2007) $ by $Author: tack $
+ *     $Revision: 4790 $
+ *
+ *  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 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-2.1.1/gecode/int/gcc/occur.icc

@@ -0,0 +1,829 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified: $Date: 2008-02-27 11:24:12 +0100 (Wed, 27 Feb 2008) $ by $Author: tack $
+ *  $Revision: 6323 $
+ *
+ *  This file is part of Gecode, the generic constrain
+ *  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 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 range(void) const;
+    ModEvent inc(void);
+
+    void cancel(Space*, Propagator* , PropCond ) {}
+    void subscribe(Space*, Propagator* , PropCond, bool=true) {}
+
+    void cancel(Space*, Advisor*) {}
+    void subscribe(Space*, Advisor*) {}
+
+    void update(Space*, bool, OccurBndsView&);
+
+    Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
+    OccurBndsView(Space* home, const Reflection::VarMap& m,
+                  Reflection::Arg* arg);
+    static Support::Symbol type(void);
+    
+  };
+
+  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*, 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::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
+inline std::ostream&
+operator<<(std::ostream& os, Gecode::Int::GCC::OccurBndsView& xs) {
+  os << xs.card() << "("<< xs.counter() <<")[";
+  os << xs.min() << "," << xs.max() << "]";
+  return os;
+}
+
+namespace Gecode { namespace Int { namespace GCC {
+
+  forceinline void
+  OccurBndsView::update(Space*, bool, OccurBndsView& oc) {
+    _min = oc._min;
+    _max = oc._max;
+    c = oc.c;
+    count = oc.count;
+  }
+
+  forceinline Reflection::Arg*
+  OccurBndsView::spec(const Space*, Reflection::VarMap&) const {
+    return Reflection::Arg::newPair(
+      Reflection::Arg::newPair(Reflection::Arg::newInt(_min),
+        Reflection::Arg::newInt(_max)),
+      Reflection::Arg::newPair(Reflection::Arg::newInt(c),
+        Reflection::Arg::newInt(count)));
+  }
+  inline Support::Symbol
+  OccurBndsView::type(void) {
+    return Support::Symbol("Gecode::Int::GCC::OccurBndsView");
+  }
+
+  forceinline
+  OccurBndsView::OccurBndsView(Space*, const Reflection::VarMap&,
+                               Reflection::Arg* arg) {
+    _min = arg->first()->first()->toInt();
+    _max = arg->first()->second()->toInt();
+    c    = arg->second()->first()->toInt();
+    count = arg->second()->second()->toInt();
+  }
+
+  /**
+   * \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 iterator
+     * 
+     * Views can be both updated by range and value iterators.
+     * Value iterators do not need to be strict in that the same value
+     * is allowed to occur more than once in the iterated sequence.
+     *
+     * The argument \a depends must be true, if the iterator
+     * passed as argument depends on the view on which the operation 
+     * is invoked. In this case, the view is only updated after the 
+     * iterator has been consumed. Otherwise, the domain might be updated 
+     * concurrently while following the iterator.
+     *
+     */
+    //@{
+    /// Replace domain by ranges described by \a i
+    template <class I> 
+    ModEvent narrow_r(Space* home, I& i, bool depends=true);
+    /// Intersect domain with ranges described by \a i
+    template <class I> 
+    ModEvent inter_r(Space* home, I& i, bool depends=true);
+    /// Remove from domain the ranges described by \a i
+    template <class I> 
+    ModEvent minus_r(Space* home, I& i, bool depends=true);
+    /// Replace domain by values described by \a i
+    template <class I> 
+    ModEvent narrow_v(Space* home, I& i, bool depends=true);
+    /// Intersect domain with values described by \a i
+    template <class I> 
+    ModEvent inter_v(Space* home, I& i, bool depends=true);
+    /// Remove from domain the values described by \a i
+    template <class I> 
+    ModEvent minus_v(Space* home, I& i, bool depends=true);
+    //@}
+
+    /// \name View-dependent propagator support
+    ///@{
+    /// Schedule propagator \a p with modification event \a me
+    static void schedule(Space* home, Propagator* p, ModEvent me);
+    /// Return modification event for view type in \a med
+    static ModEvent me(ModEventDelta med);
+    /// Translate modification event \a me to modification event delta for view
+    static ModEventDelta med(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);
+    /// Subscribe advisor \a a to variable
+    void subscribe(Space* home, Advisor* a);
+    /// Cancel subscription of advisor \a a
+    void cancel(Space* home, Advisor* a);
+    
+    ///@}
+
+    /// \name Cloning
+    ///@{
+    /// Update this view to be a clone of view \a x
+    void update(Space* home, bool share, CardView& x);
+    ///@}
+
+    /// \name Reflection
+    ///@{
+    /// Return specification for this view, using variable map \a m
+    Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
+    /// Return type of this view
+    static Support::Symbol type(void);
+    /// Create from specification
+    CardView(Space* home, const Reflection::VarMap& m,
+             Reflection::Arg* arg);
+    ///@}
+
+    /// \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 iterator
+   *
+   */
+  template <class I>
+  ModEvent
+  CardView::narrow_r(Space* home, I& i, bool depends) {
+    return view.narrow_r(home,i,depends);
+  }
+  template <class I>
+  ModEvent
+  CardView::inter_r(Space* home, I& i, bool depends) {
+    return view.inter_r(home,i,depends);
+  }
+  template <class I>
+  ModEvent
+  CardView::minus_r(Space* home, I& i, bool depends) {
+    return view.minus_r(home,i,depends);
+  }
+  template <class I>
+  ModEvent
+  CardView::narrow_v(Space* home, I& i, bool depends) {
+    return view.narrow_v(home,i,depends);
+  }
+  template <class I>
+  ModEvent
+  CardView::inter_v(Space* home, I& i, bool depends) {
+    return view.inter_v(home,i,depends);
+  }
+  template <class I>
+  ModEvent
+  CardView::minus_v(Space* home, I& i, bool depends) {
+    return view.minus_v(home,i,depends);
+  }
+
+
+
+  /*
+   * Propagator modification events
+   *
+   */
+  forceinline void
+  CardView::schedule(Space* home, Propagator* p, ModEvent me) {
+    return IntView::schedule(home,p,me);
+  }
+  forceinline ModEvent
+  CardView::me(ModEventDelta med) {
+    return IntView::me(med);
+  }
+  forceinline ModEventDelta
+  CardView::med(ModEvent me) {
+    return IntView::med(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);
+  }
+  forceinline void
+  CardView::subscribe(Space* home, Advisor* a) {
+    view.subscribe(home, a);
+  }
+  forceinline void
+  CardView::cancel(Space* home, Advisor* a) {
+    view.cancel(home, a);
+  }
+
+
+  /*
+   * Cloning
+   *
+   */
+  forceinline void
+  CardView::update(Space* home, bool share, CardView& x) {
+    c     = x.c;
+    count = x.count;
+    view.update(home,share,x.view);
+  }
+
+  /*
+   * Serialization
+   *
+   */
+  forceinline Reflection::Arg*
+  CardView::spec(const Space* home, Reflection::VarMap& m) const {
+    return Reflection::Arg::newPair(
+      Reflection::Arg::newPair(Reflection::Arg::newInt(c),
+        Reflection::Arg::newInt(count)), view.spec(home, m));
+  }
+  inline Support::Symbol
+  CardView::type(void) {
+    return Support::Symbol("Gecode::Int::GCC::CardView");
+  }
+  forceinline
+  CardView::CardView(Space* home, const Reflection::VarMap& m,
+                     Reflection::Arg* arg)
+   : DerivedViewBase<IntView>(IntView(home, m, arg->second())) {
+    c = arg->first()->first()->toInt();
+    count = arg->first()->second()->toInt();
+  }
+
+
+}
+
+
+  /**
+   * \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
+inline std::ostream&
+operator<<(std::ostream& os, Gecode::Int::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 << "{";
+      Gecode::Int::ViewValues<Gecode::Int::GCC::CardView> iter(v);
+      while(iter()){
+        os << iter.val() <<",";
+        ++iter;
+      }
+      os << "}";
+    }
+  }
+  os << ")";
+  return os;
+}
+
+namespace Gecode { namespace Int {
+
+  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