dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/gcc.hh

@@ -0,0 +1,268 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004/2005
+ *     Christian Schulte, 2009
+ *     Guido Tack, 2009
+ *
+ *  Last modified:
+ *     $Date: 2009-10-13 02:36:53 +1100 (Tue, 13 Oct 2009) $ by $Author: schulte $
+ *     $Revision: 9878 $
+ *
+ *  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_GCC_HH__
+#define __GECODE_INT_GCC_HH__
+
+#include <gecode/int.hh>
+
+/**
+ * \namespace Gecode::Int::GCC
+ * \brief Global cardinality propagators (Counting)
+ */
+
+#include <gecode/int/gcc/view.hpp>
+#include <gecode/int/gcc/bnd-sup.hpp>
+#include <gecode/int/gcc/dom-sup.hpp>
+
+namespace Gecode { namespace Int { namespace GCC {
+
+  /**
+   * \brief Value consistent global cardinality propagator
+   *
+   * Requires \code #include <gecode/int/gcc.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class Card>
+  class Val : public Propagator {
+  protected:
+    /// Views on which to perform value-propagation
+    ViewArray<IntView> x;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /// Constructor for posting
+    Val(Home home, ViewArray<IntView>& x, ViewArray<Card>& k);
+    /// Constructor for cloning \a p
+    Val(Space& home, bool share, Val<Card>& p);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space& home, bool share);
+    /// Cost funtion returning high linear
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Destructor
+    virtual size_t dispose(Space& home);
+    /// Post propagator for views \a x and cardinalities \a k
+    static ExecStatus post(Home home,
+                           ViewArray<IntView>& x, ViewArray<Card>& k);
+  };
+
+  /**
+   * \brief Bounds consistent global cardinality propagator
+   * 
+   * The algorithm is taken from:
+   *    Claude-Guy Quimper, Peter van Beek, Alejandro L�pez-Ortiz,
+   *    Alexander Golynski, and Sayyed Bashir Sadjad. An Efficient 
+   *    Bounds Consistency Algorithm for the Global Cardinality 
+   *    Constraint, CP 2003, pages 600-614.
+   *
+   * This implementation uses the code that is provided
+   * by Peter Van Beek:
+   *   http://ai.uwaterloo.ca/~vanbeek/software/software.html
+   * The code here has only been slightly modified to fit Gecode
+   * (taking idempotent/non-idempotent propagation into account)
+   * and uses a more efficient layout of datastructures (keeping the
+   * number of different arrays small).
+   *
+   * The Bnd class is used to post the propagator and BndImp
+   * is the actual implementation taking shared variables into account.
+   *
+   * Requires \code #include <gecode/int/gcc.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class Card>
+  class Bnd : public Propagator {
+  protected:
+    /// Views on which to perform bounds-propagation
+    ViewArray<IntView> x;
+    /// Views on which to perform value-propagation (subset of \c x)
+    ViewArray<IntView> y;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /**
+     * \brief  Data structure storing the sum of the views lower bounds
+     * Necessary for reasoning about the interval capacities in the
+     * propagation algorithm.
+     */
+    PartialSum<Card> lps;
+    /// Data structure storing the sum of the views upper bounds
+    PartialSum<Card> ups;
+    /**
+     * \brief Stores whether cardinalities are all assigned
+     *
+     * If all cardinalities are assigned the propagation algorithm
+     * only has to perform propagation for the upper bounds.
+     */
+    bool card_fixed;
+    /**
+     * \brief Stores whether the minium required occurences of
+     *        the cardinalities are all zero. If so, we do not need
+     *        to perform lower bounds propagation.
+     */
+    bool skip_lbc;
+    /// Constructor for cloning \a p
+    Bnd(Space& home, bool share, Bnd<Card>& p);
+
+    /// Prune cardinality variables with 0 maximum occurrence
+    ExecStatus pruneCards(Space& home);
+
+    /**
+     * \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 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 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$
+     */
+    ExecStatus lbc(Space& home, int& nb, HallInfo hall[], Rank rank[],
+                   int mu[], int nu[]);
+
+    /**
+     * \brief Upper Bounds constraint (UBC) stating
+     * \f$ \forall j \in \{0, \dots, |k|-1\}:
+     * \#\{i\in\{0, \dots, |x| - 1\} | x_i = card(k_j)\} \leq max(k_j)\f$
+     * Hence the ubc constraints the variables such that no value occurs
+     * more often than specified by its upper cardinality bound.
+     * \param home current space
+     * \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 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$
+     */
+    ExecStatus ubc(Space& home, int& nb, HallInfo hall[], Rank rank[],
+                   int mu[], int nu[]);
+    /// Constructor for posting
+    Bnd(Home home, ViewArray<IntView>&, ViewArray<Card>&, bool, bool);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space& home, bool share);
+    /// Cost funtion
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Destructor
+    virtual size_t dispose(Space& home);
+    /// Post propagator for views \a x and cardinalities \a k
+    static ExecStatus post(Home home,
+                           ViewArray<IntView>& x, ViewArray<Card>& k);
+  };
+
+  /**
+   * \brief Domain consistent global cardinality propagator
+   * 
+   * The algorithm is taken from:
+   *   Claude-Guy Quimper, Peter van Beek, Alejandro L�pez-Ortiz,
+   *   and Alexander Golynski. Improved Algorithms for the
+   *   Global Cardinality Constraint, CP 2004, pages 542-556.
+   *
+   * Requires \code #include <gecode/int/gcc.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class Card>
+  class Dom : public Propagator {
+  protected:
+    /// Views on which to perform domain-propagation
+    ViewArray<IntView> x;
+    /**
+     * \brief Views used to channel information between \c x and \c k
+     * (\f$ x \subseteq y \f$).
+     */
+    ViewArray<IntView> y;
+    /// Array containing either fixed cardinalities or CardViews
+    ViewArray<Card> k;
+    /// Propagation is performed on a variable-value graph (used as cache)
+    VarValGraph<Card>* vvg;
+    /**
+     * \brief Stores whether cardinalities are all assigned
+     *
+     * If all cardinalities are assigned the propagation algorithm
+     * only has to perform propagation for the upper bounds.
+     */
+    bool card_fixed;
+    /// Constructor for cloning \a p
+    Dom(Space& home, bool share, Dom<Card>& p);
+    /// Constructor for posting
+    Dom(Home home, ViewArray<IntView>&, ViewArray<Card>&, bool);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space& home, bool share);
+    /// Cost function
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Destructor
+    virtual size_t dispose(Space& home);
+    /// Post propagator for views \a x and cardinalities \a k
+    static ExecStatus post(Home home,
+                           ViewArray<IntView>& x, ViewArray<Card>& k);
+  };
+
+}}}
+
+#include <gecode/int/gcc/post.hpp>
+#include <gecode/int/gcc/val.hpp>
+#include <gecode/int/gcc/bnd.hpp>
+#include <gecode/int/gcc/dom.hpp>
+
+#endif
+
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/gcc/bnd-sup.hpp

@@ -0,0 +1,608 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *     Christian Schulte, 2009
+ *     Guido Tack, 2009
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 20:35:31 +1000 (Thu, 08 Apr 2010) $ by $Author: schulte $
+ *     $Revision: 10684 $
+ *
+ *  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 {
+
+  /**
+   * \defgroup GCCBndSup Support for GCC bounds propagation
+   * 
+   * \ingroup FuncIntProp
+   */
+
+  /**
+   * \brief Class for computing unreachable values in the value %GCC propagator
+   *
+   * \ingroup GCCBndSup
+   */
+  class UnReachable {
+  public:
+    /// Number of variables with lower bound
+    int minb;
+    /// Number of variables with upper bound
+    int maxb;
+    /// Number of equal variables
+    int eq;
+    /// Number of smaller variables
+    int le;
+    /// Number of greater variables
+    int gr;
+  };
+
+  /**
+   * \brief Bounds consistency check for cardinality variables.
+   * \ingroup GCCBndSup
+   */
+
+  template<class Card>
+  ExecStatus
+  prop_card(Space& home, 
+            ViewArray<IntView>& x, ViewArray<Card>& k) {
+    int n = x.size();
+    int m = k.size();
+    Region r(home);
+    UnReachable* rv = r.alloc<UnReachable>(m);
+    for(int i = m; i--; )
+      rv[i].minb=rv[i].maxb=rv[i].le=rv[i].gr=rv[i].eq=0;
+
+    for (int i = n; i--; ) {
+      int min_idx;
+      if (!lookupValue(k,x[i].min(),min_idx))
+        return ES_FAILED;
+      if (x[i].assigned()) {
+        rv[min_idx].minb++;
+        rv[min_idx].maxb++;
+        rv[min_idx].eq++;
+      } else {
+        // count the number of variables
+        // with lower bound k[min_idx].card()
+        rv[min_idx].minb++;
+        int max_idx;
+        if (!lookupValue(k,x[i].max(),max_idx))
+          return ES_FAILED;
+        // count the number of variables
+        // with upper bound k[max_idx].card()
+        rv[max_idx].maxb++;
+      }
+    }
+
+    rv[0].le = 0;
+    int c_min = 0;
+    for (int i = 1; i < m; i++) {
+      rv[i].le = c_min + rv[i - 1].maxb;
+      c_min += rv[i - 1].maxb;
+    }
+
+    rv[m-1].gr = 0;
+    int c_max = 0;
+    for (int i = m-1; i--; ) {
+      rv[i].gr = c_max + rv[i + 1].minb;
+      c_max += rv[i + 1].minb;
+    }
+
+    for (int i = m; i--; ) {
+      int reachable = x.size() - rv[i].le - rv[i].gr;
+      if (!k[i].assigned()) {
+        GECODE_ME_CHECK(k[i].lq(home, reachable));
+        GECODE_ME_CHECK(k[i].gq(home, rv[i].eq));
+      } else {
+        // check validity of the cardinality value
+        if ((rv[i].eq > k[i].max()) || (k[i].max() > reachable))
+          return ES_FAILED;
+      }
+    }
+
+    return ES_OK;
+  }
+
+
+  /** \brief Consistency check, whether the cardinality values are feasible.
+   * \ingroup GCCBndSup
+   */
+  template<class Card>
+  forceinline bool
+  card_consistent(ViewArray<IntView>& x, ViewArray<Card>& k) {
+    int smin = 0;
+    int smax = 0;
+    for (int i = k.size(); i--; ) {
+      smax += k[i].max();
+      smin += k[i].min();
+    }
+    // Consistent if number of variables within cardinality bounds
+    return (smin <= x.size()) && (x.size() <= smax);
+  }
+
+  /**
+   * \brief Maps domain bounds to their position in hall[].bounds.
+   * \ingroup GCCBndSup
+   */
+  class Rank {
+  public:
+    /**
+     * \brief \f$ rank[i].min = z
+     * \Leftrightarrow min(x_i) = hall[z].bounds \f$
+     */
+    int min;
+    /**
+     * \brief \f$ rank[i].max = z
+     * \Leftrightarrow max(x_i) = hall[z].bounds \f$
+     */
+    int max;
+  };
+
+  /**
+   * \brief Compares two indices \a i, \a j of two views
+   * \a \f$ x_i \f$ \f$ x_j\f$ according to the
+   * ascending order of the views upper bounds
+   *
+   * \ingroup GCCBndSup
+   */
+  template<class View>
+  class MaxInc {
+  protected:
+    /// View array for comparison
+    ViewArray<View> x;
+  public:
+    /// Constructor
+    MaxInc(const ViewArray<View>& x0) : x(x0) {}
+    /// Order
+    forceinline bool
+    operator ()(const int i, const int j) {
+      return x[i].max() < x[j].max();
+    }
+  };
+
+
+  /**
+   * \brief Compares two indices \a i, \a j of two views
+   * \a \f$ x_i \f$ \f$ x_j\f$ according to the
+   * ascending order of the views lower bounds
+   *
+   * \ingroup GCCBndSup
+   */
+  template<class View>
+  class MinInc {
+  protected:
+    /// View array for comparison
+    ViewArray<View> x;
+  public:
+    /// Constructor
+    MinInc(const ViewArray<View>& x0) : x(x0) {}
+    /// Comparison
+    forceinline bool
+    operator ()(const int i, const int j) {
+      return x[i].min() < x[j].min();
+    }
+  };
+
+
+  /**
+   * \brief Compares two cardinality views
+   * \a \f$ x_i \f$ \f$ x_j\f$ according to the index
+   *
+   * \ingroup GCCBndSup
+   */
+  template<class Card>
+  class MinIdx {
+  public:
+    /// Comparison
+    forceinline bool
+    operator ()(const Card& x, const Card& y) {
+      return x.card() < y.card();
+    }
+  };
+
+  /**
+   * \brief Partial sum structure for constant
+   *  time computation of the maximal capacity of an interval.
+   *
+   * \ingroup GCCBndSup
+   */
+  template<class Card>
+  class PartialSum {
+  private:
+    /// sum[i] contains the partial sum from 0 to i
+    int* sum;
+    /// the size of the sum
+    int size;
+  public:
+    /// Sentinels indicating whether an end of sum is reached
+    int firstValue, lastValue;
+    /// \name Initialization
+    //@{
+    /// Constructor
+    PartialSum(void);
+    /// Initialization
+    void init(Space& home, ViewArray<Card>& k, bool up);
+    /// Mark datstructure as requiring reinitialization
+    void reinit(void);
+    /// Test whether already initialized
+    bool initialized(void) const;
+    //@}
+    /// \name Access
+    //@{
+    /// Compute the maximum capacity of an interval
+    int sumup(int from, int to) const;
+    /// Return smallest bound of variables
+    int minValue(void) const;
+    /// Return largest bound of variables
+    int maxValue(void) const;
+    /// Skip neigbouring array entries if their values do not differ
+    int skipNonNullElementsRight(int v) const;
+    /// Skip neigbouring array entries if their values do not differ
+    int skipNonNullElementsLeft(int v) const;
+    //@}
+    /// \name Update
+    //@{
+    /**
+     * \brief Check whether the values in the
+     *        partial sum structure containting
+     *        the lower cardinality bounds differ
+     *        from the actual lower bounds of the
+     *        cardinalities.
+     */
+    bool check_update_min(ViewArray<Card>& k);
+    /**
+     * \brief Check whether the values in the
+     *        partial sum structure containting
+     *        the upper cardinality bounds differ
+     *        from the actual upper bounds of the
+     *        cardinalities.
+     */
+    bool check_update_max(ViewArray<Card>& k);
+    //@}
+  };
+
+
+  template<class Card>
+  forceinline
+  PartialSum<Card>::PartialSum(void) : sum(NULL), size(-1) {}
+
+  template<class Card>
+  forceinline bool
+  PartialSum<Card>::initialized(void) const {
+    return size != -1;
+  }
+  template<class Card>
+  inline void
+  PartialSum<Card>::init(Space& home, ViewArray<Card>& elements, bool up) {
+    int i = 0;
+    int j = 0;
+
+    // Determine number of holes in the index set
+    int holes = 0;
+    for (i = 1; i < elements.size(); i++) {
+      if (elements[i].card() != elements[i-1].card() + 1)
+        holes += elements[i].card()-elements[i-1].card()-1;
+    }
+
+    // we add three elements at the beginning and two at the end
+    size  = elements.size() + holes + 5;
+
+    // memory allocation
+    if (sum == NULL) {
+      sum = home.alloc<int>(2*size);
+    }
+    int* ds  = &sum[size];
+
+    int first = elements[0].card();
+
+    firstValue = first - 3;
+    lastValue  = first + elements.size() + holes + 1;
+
+    // the first three elements
+    for (i = 3; i--; )
+      sum[i] = i;
+
+    /*
+     * copy the bounds into sum, filling up holes with zeroes
+     */
+    int prevCard = elements[0].card()-1;
+    i = 0;
+    for (j = 2; j < elements.size() + holes + 2; j++) {
+      if (elements[i].card() != prevCard + 1) {
+        sum[j + 1] = sum[j];
+      } else if (up) {
+        sum[j + 1] = sum[j] + elements[i].max();
+        i++;
+      } else {
+        sum[j + 1] = sum[j] + elements[i].min();
+        i++;
+      }
+      prevCard++;
+    }
+    sum[j + 1] = sum[j] + 1;
+    sum[j + 2] = sum[j + 1] + 1;
+
+    // Compute distances, eliminating zeroes
+    i = elements.size() + holes + 3;
+    j = i + 1;
+    for ( ; i > 0; ) {
+      while(sum[i] == sum[i - 1]) {
+        ds[i] = j;
+        i--;
+      }
+      ds[j] = i;
+      i--;
+      j = ds[j];
+    }
+    ds[j] = 0;
+    ds[0] = 0;
+  }
+
+  template<class Card>
+  forceinline void
+  PartialSum<Card>::reinit(void) {
+    size = -1;
+  }
+
+
+  template<class Card>
+  forceinline int
+  PartialSum<Card>::sumup(int from, int to) const {
+    if (from <= to) {
+      return sum[to - firstValue] - sum[from - firstValue - 1];
+    } else {
+      assert(to - firstValue - 1 >= 0);
+      assert(to - firstValue - 1 < size);
+      assert(from - firstValue >= 0);
+      assert(from - firstValue < size);
+      return sum[to - firstValue - 1] - sum[from - firstValue];
+    }
+  }
+
+  template<class Card>
+  forceinline int
+  PartialSum<Card>::minValue(void) const {
+    return firstValue + 3;
+  }
+  template<class Card>
+  forceinline int
+  PartialSum<Card>::maxValue(void) const {
+    return lastValue - 2;
+  }
+
+
+  template<class Card>
+  forceinline int
+  PartialSum<Card>::skipNonNullElementsRight(int value) const {
+    value -= firstValue;
+    int* ds  = &sum[size];
+    return (ds[value] < value ? value : ds[value]) + firstValue;
+  }
+  template<class Card>
+  forceinline int
+  PartialSum<Card>::skipNonNullElementsLeft(int value) const {
+    value -= firstValue;
+    int* ds  = &sum[size];
+    return (ds[value] > value ? ds[ds[value]] : value) + firstValue;
+  }
+
+  template<class Card>
+  inline bool
+  PartialSum<Card>::check_update_max(ViewArray<Card>& k) {
+    int j = 0;
+    for (int i = 3; i < size - 2; i++) {
+      int max = 0;
+      if (k[j].card() == i+firstValue)
+        max = k[j++].max();
+      if ((sum[i] - sum[i - 1]) != max)
+        return true;
+    }
+    return false;
+  }
+
+  template<class Card>
+  inline bool
+  PartialSum<Card>::check_update_min(ViewArray<Card>& k) {
+    int j = 0;
+    for (int i = 3; i < size - 2; i++) {
+      int min = 0;
+      if (k[j].card() == i+firstValue)
+        min = k[j++].min();
+      if ((sum[i] - sum[i - 1]) != min)
+        return true;
+    }
+    return false;
+  }
+
+
+  /**
+   * \brief Container class provding information about the Hall
+   *  structure of the problem variables.
+   *
+   *  This class is used to
+   *  keep the number of different arrays small, that is
+   *  an array of type %HallInfo replaces integer arrays for each
+   *  of the class members.
+   *
+   * \ingroup GCCBndSup
+   */
+  class HallInfo {
+  public:
+    /// Represents the union of all lower and upper domain bounds
+    int bounds;
+    /**
+     * \brief Critical capacity pointer
+     * \a t represents a predecessor function where \f$ t_i \f$ denotes the
+     * predecessor of i in bounds
+     */
+    int t;
+    /**
+     * \brief Difference between critical capacities
+     *
+     * \a d_i is the difference between the capacities of hall[i].bounds
+     * and its predecessor in bounds hall[t[i]].bounds
+     *
+     */
+    int d;
+    /**
+     * \brief Hall set pointer
+     *
+     * If hall[i].h < i then the half-open interval
+     * [hall[h[i]].bounds,hall[i].bounds) is containd in a Hall
+     * set.
+     * Otherwise holds a pointer to the Hall intervall it belongs to.
+     */
+    int h;
+    /// Stable Set pointer
+    int s;
+    /// Potentially Stable Set pointer
+    int ps;
+    /**
+     * \brief Bound update
+     *
+     * \a newBound contains either a narrowed domain bound
+     * or is stores the old domain bound of a variable.
+     */
+    int newBound;
+  };
+
+
+  /**
+   * \name Path compression
+   *
+   * Each of the nodes on the path from \a start to \a end
+   * becomes a direct child of \a to.
+   * \ingroup GCCBndSup
+   */
+  //@{
+  /// Path compression for potentially stable set structure
+  forceinline void
+  pathset_ps(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].ps=to) {
+      l = hall[k].ps;
+    }
+  }
+  /// Path compression for stable set structure
+  forceinline void
+  pathset_s(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].s=to) {
+      l = hall[k].s;
+    }
+  }
+  /// Path compression for capacity pointer structure
+  forceinline void
+  pathset_t(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].t=to) {
+      l = hall[k].t;
+    }
+  }
+  /// Path compression for hall pointer structure
+  forceinline void
+  pathset_h(HallInfo hall[], int start, int end, int to) {
+    int k, l;
+    for (l=start; (k=l) != end; hall[k].h=to) {
+      l = hall[k].h;
+      assert(l != k);
+    }
+  }
+  //@}
+
+  /**
+   *  \name Path minimum
+   *
+   *  Returns the smalles reachable index starting from \a i.
+   * \ingroup GCCBndSup
+   */
+  //@{
+  /// Path minimum for hall pointer structure
+  forceinline int
+  pathmin_h(const HallInfo hall[], int i) {
+    while (hall[i].h < i)
+      i = hall[i].h;
+    return i;
+  }
+  /// Path minimum for capacity pointer structure
+  forceinline int
+  pathmin_t(const HallInfo hall[], int i) {
+    while (hall[i].t < i)
+      i = hall[i].t;
+    return i;
+  }
+  //@}
+
+  /**
+   *  \name Path maximum
+   *
+   *  Returns the greatest reachable index starting from \a i.
+   * \ingroup GCCBndSup
+   */
+  //@{
+  /// Path maximum for hall pointer structure
+  forceinline int
+  pathmax_h(const HallInfo hall[], int i) {
+    while (hall[i].h > i)
+      i = hall[i].h;
+    return i;
+  }
+  /// Path maximum for capacity pointer structure
+  forceinline int
+  pathmax_t(const HallInfo hall[], int i) {
+    while (hall[i].t > i) {
+      i = hall[i].t;
+    }
+    return i;
+  }
+  /// Path maximum for stable set pointer structure
+  forceinline int
+  pathmax_s(const HallInfo hall[], int i) {
+    while (hall[i].s > i)
+      i = hall[i].s;
+    return i;
+  }
+  /// Path maximum for potentially stable set pointer structure
+  forceinline int
+  pathmax_ps(const HallInfo hall[], int i) {
+    while (hall[i].ps > i)
+      i = hall[i].ps;
+    return i;
+  }
+  //@}
+
+}}}
+
+// STATISTICS: int-prop
+