gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,236 @@
+/*
+ *  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 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 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 ups partial sum structure for the upper 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
+  ubc(Space* home, ViewArray<View>& x, int& nb,
+      HallInfo hall[], Rank rank[],
+      PartialSum<Card>* ups,
+      int mu[], int nu[]){
+    ExecStatus es = ES_FIX;
+
+    int rightmost = nb + 1; // rightmost accesible value in bounds
+    int bsize     = nb + 2; // number of unique bounds including sentinels
+
+    //Narrow lower bounds (UBC)
+
+    /*
+     * Initializing tree structure with the values from bounds
+     * and the interval capacities of neighboured values
+     * from left to right
+     */
+
+
+    hall[0].h = 0;
+    hall[0].t = 0;
+    hall[0].d = 0;
+
+    for (int i = 1; i < bsize; i++) {
+      int pred  = i - 1;
+      hall[i].h = pred;
+      hall[i].t = pred;
+      hall[i].d = ups->sumup(hall[pred].bounds, hall[i].bounds - 1);
+    }
+
+    int n          = x.size();
+
+    for (int i = 0; i < n; i++) {
+
+      // visit intervals in increasing max order
+      int x0   = rank[mu[i]].min;
+      int succ = x0 + 1;
+      int y    = rank[mu[i]].max;
+      int z    = pathmax_t(hall, succ);
+      int j    = hall[z].t;
+
+      /* DOMINATION:
+       *     v^i_j denotes
+       *     unused values in the current interval. If the difference d
+       *     between to critical capacities v^i_j and v^i_z
+       *     is equal to zero, j dominates z
+       *
+       *     i.e. [hall[l].bounds, hall[nb+1].bounds] is not left-maximal and
+       *     [hall[j].bounds, hall[l].bounds] is a Hall set iff
+       *     [hall[j].bounds, hall[l].bounds] processing a variable x_i uses up a value in the interval
+       *     [hall[z].bounds,hall[z+1].bounds] according to the intervals
+       *     capacity. Therefore, if d = 0
+       *     the considered value has already been used by processed variables
+       *     m-times, where m = u[i] for value v_i. Since this value must not
+       *     be reconsidered the path can be compressed
+       */
+      if (--hall[z].d == 0){
+	hall[z].t = z + 1;
+	z         = pathmax_t(hall, hall[z].t);
+	if (z >= bsize) {
+	  z--;
+	}
+	hall[z].t = j;
+      }
+      pathset_t(hall, succ, z, z); // path compression
+      /* NEGATIVE CAPACITY:
+       *     A negative capacity results in a failure.Since a
+       *     negative capacity signals that the number of variables
+       *     whose domain is contained in the set S is larger than
+       *     the maximum capacity of S => UBC is not satisfiable,
+       *     i.e. there are more variables than values to instantiate them
+       */
+
+      if (hall[z].d < ups->sumup(hall[y].bounds, hall[z].bounds - 1)){
+	return ES_FAILED;
+      }
+
+      /* UPDATING LOWER BOUND:
+       *   If the lower bound min_i lies inside a Hall interval [a,b]
+       *   i.e. a <= min_i <=b <= max_i
+       *   min_i is set to  min_i := b+1
+       */
+      if (hall[x0].h > x0) {
+	int w       = pathmax_h(hall, hall[x0].h);
+	int m       = hall[w].bounds;
+
+	ModEvent me = x[mu[i]].gq(home, m);
+	if (me_failed(me)) {
+	  return ES_FAILED;
+	}
+	if (me_modified(me) && (m != x[mu[i]].min())) {
+	  es = ES_NOFIX;
+	}
+	if (shared && me_modified(me)) {
+	  es = ES_NOFIX;
+	}
+	pathset_h(hall, x0, w, w); // path compression
+      }
+
+      /* ZEROTEST:
+       *     (using the difference between capacity pointers)
+       *     zero capacity => the difference between critical capacity
+       *     pointers is equal to the maximum capacity of the interval,i.e.
+       *     the number of variables whose domain is contained in the
+       *     interval is equal to the sum over all u[i] for a value v_i that
+       *     lies in the Hall-Intervall which can also be thought of as a
+       *     Hall-Set
+       *
+       *    ZeroTestLemma: Let k and l be succesive critical indices.
+       *          v^i_k=0  =>  v^i_k = max_i+1-l+d
+       *                   <=> v^i_k = y + 1 - z + d
+       *                   <=> d = z-1-y
+       *    if this equation holds the interval [j,z-1] is a hall intervall
+       */
+
+      if (hall[z].d == ups->sumup(hall[y].bounds, hall[z].bounds - 1)) {
+	/*
+	 *mark hall interval [j,z-1]
+	 * hall pointers form a path to the upper bound of the interval
+	 */
+	int predj = j - 1;
+	pathset_h(hall, hall[y].h, predj, y);
+	hall[y].h = predj;
+      }
+    }
+
+    /* Narrow upper bounds (UBC)
+     * symmetric to the narrowing of the lower bounds
+     */
+    for (int i = 0; i < rightmost; i++) {
+      int succ  = i + 1;
+      hall[i].h = succ;
+      hall[i].t = succ;
+      hall[i].d = ups->sumup(hall[i].bounds, hall[succ].bounds - 1);
+    }
+
+    for (int i = n; i--; ) {
+      // visit intervals in decreasing min order
+      int x0   = rank[nu[i]].max;
+      int pred = x0 - 1;
+      int y    = rank[nu[i]].min;
+      int z    = pathmin_t(hall, pred);
+      int j    = hall[z].t;
+
+      // DOMINATION:
+      if (--hall[z].d == 0){
+	hall[z].t = z - 1;
+	z         = pathmin_t(hall, hall[z].t);
+	hall[z].t = j;
+      }
+      pathset_t(hall, pred, z, z);
+
+      // NEGATIVE CAPACITY:
+      if (hall[z].d < ups->sumup(hall[z].bounds,hall[y].bounds-1)){
+	return ES_FAILED;
+      }
+
+      /* UPDATING UPPER BOUND:
+       *   If the upper bound max_i lies inside a Hall interval [a,b]
+       *   i.e. min_i <= a <= max_i < b
+       *   max_i is set to  max_i := a-1
+       */
+      if (hall[x0].h < x0) {
+	int w       = pathmin_h(hall, hall[x0].h);
+	int m       = hall[w].bounds - 1;
+	ModEvent me = x[nu[i]].lq(home, m);
+	if (me_failed(me)) {
+	  return ES_FAILED;
+	}
+	if (me_modified(me) && (m != x[nu[i]].max())) {
+	  es = ES_NOFIX;
+	}
+	if (me_modified(me) && shared) {
+	  es = ES_NOFIX;
+	}
+	pathset_h(hall, x0, w, w);
+      }
+      // ZEROTEST
+      if (hall[z].d == ups->sumup(hall[z].bounds, hall[y].bounds - 1)) {
+	//mark hall interval [y,j]
+	int succj = j + 1;
+	pathset_h(hall, hall[y].h, succj, y);
+	hall[y].h = succj;
+      }
+    }
+    return es;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,373 @@
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2005
+ *
+ *  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 Perform value propagation.
+  template <class View, class Card, bool isView>
+  inline ExecStatus
+  prop_val(Space* home, ViewArray<View>& x, ViewArray<Card>& k,
+	   bool& _cardall){
+
+    bool mod = false;
+    int  n   = x.size();
+    int  m   = k.size();
+
+    // count[i] denotes how often value k[i].card() occurs in x
+    GECODE_AUTOARRAY(int,  count, m);
+    // stack of values having reached their maximum occurence
+    GECODE_AUTOARRAY(int,  rem,   m);
+    // keep track whether a value is already on the stack
+    GECODE_AUTOARRAY(bool, onrem, m);
+    // stacksize
+    int rs = 0;
+
+    // initialization
+    int sum_min = 0;
+    int removed = 0;
+    for (int i = m; i--; ) {
+
+      removed += k[i].counter();
+      sum_min += k[i].min();
+
+      count[i] = 0;
+      onrem[i] = false;
+    }
+
+    for (int i = m; i--; ) {
+      // less than or equal than the total number of free variables
+      // to satisfy the required occurences
+      if (!k[i].assigned()) {
+	int mub     = n + removed - (sum_min - k[i].min());
+	ModEvent me = k[i].lq(home, mub);
+	GECODE_ME_CHECK(me);
+	mod |= (me_modified(me) && k[i].max() != mub);
+      }
+    }
+
+    // Due to lookup operation counting requires O(n \cdot log(n)) time
+    bool all_assigned = true;
+    // number of assigned views with respect to the current problem size
+    int  noa   = 0;
+    // total number of assigned views wrt. the original probem size
+    int  t_noa = 0;
+    for (int i = n; i--; ) {
+      bool b = x[i].assigned();
+      all_assigned &= b;
+      if (b) {
+	int idx = lookupValue(k,x[i].val());
+	if (idx == -1) {
+	  return ES_FAILED;
+	}
+	count[idx]++;
+	noa++;
+      }
+    }
+
+    // number of unassigned views
+    int  non = x.size() - noa;
+
+    // check for subsumption
+    if (all_assigned) {
+
+      for (int i = m; i--; ) {
+	int ci = count[i] + k[i].counter();
+	if (!(k[i].min() <= ci && ci <= k[i].max())) {
+	  return ES_FAILED;
+	}
+	// the solution contains ci occurences of value k[i].card();
+	if (isView) {
+	  if (!k[i].assigned()) {
+	    ModEvent me = k[i].eq(home, ci);
+	    GECODE_ME_CHECK(me);
+	    mod |= k[i].assigned();
+	  }
+	}
+      }
+      return ES_SUBSUMED;
+    }
+
+    // total number of unsatisfied miminum occurences
+    int req = 0;
+
+    // number of values whose min requirements are not yet met
+    int n_r = 0;
+
+    // if only one value is unsatisified single holds the index of that value
+    int single = 0;
+
+    for (int i = m; i--; ) {
+      int ci = count[i] + k[i].counter();
+      t_noa += ci;
+      if (ci == 0) { // this works
+	req += k[i].min();
+	n_r++;
+	single = i;
+      }
+
+      // number of unassigned views cannot satisfy
+      // the required minimum occurence
+      if (req > non) {
+	return ES_FAILED;
+      }
+    }
+
+    // if only one unsatisfied occurences is left
+    if (req == non && n_r == 1) {
+      for (int i = n; i--; ) {
+	// try to assign it
+	if (!x[i].assigned()) {
+	  ModEvent me = x[i].eq(home, k[single].card());
+	  count[single]++;
+	  GECODE_ME_CHECK(me);
+	}
+      }
+
+      for (int i = m; i--; ) {
+	int ci = count[i] + k[i].counter();
+	// consistency check
+	if (!(k[i].min() <= ci && ci <= k[i].max())) {
+	  return ES_FAILED;
+	}
+	// the solution contains ci occurences of value k[i].card();
+	if (isView) {
+	  if (!k[i].assigned()) {
+	    ModEvent me = k[i].eq(home, ci);
+	    GECODE_ME_CHECK(me);
+	  }
+	}
+      }
+      return ES_SUBSUMED;
+    }
+
+    for (int i = m; i--; ) {
+      int ci = count[i] + k[i].counter();
+      if (ci == k[i].max() && !onrem[i]) {
+	rem[rs] = k[i].card();
+	k[i].counter(ci);
+	rs++;
+	onrem[i] = true;
+	if (isView) {
+	  // the solution contains ci occurences of value k[i].card();
+	  if (!k[i].assigned()) {
+	    ModEvent me = k[i].eq(home, ci);
+	    GECODE_ME_CHECK(me);
+	    mod |= k[i].assigned();
+	  }
+	}
+      } else {
+	if (ci > k[i].max()) {
+	  return ES_FAILED;
+	}
+
+	// in case of variable cardinalities
+	if (isView) {
+	  if (!k[i].assigned()) {
+	    if (ci > k[i].min()) {
+	      ModEvent me = k[i].gq(home, ci);
+	      GECODE_ME_CHECK(me);
+	      mod |= k[i].assigned();
+	      mod |= (me_modified(me) && k[i].min() != ci);
+	    }
+	    int occupied = t_noa - ci;
+	    int mub = x.size() + removed - occupied;
+	
+	    ModEvent me = k[i].lq(home, mub);
+	    GECODE_ME_CHECK(me);
+	    mod |= k[i].assigned();
+	    mod |= (me_failed(me) && k[i].max() != mub);
+	  }
+	}
+      }
+      // reset counter
+      count[i] = 0;
+    }
+
+    // reduce the problem size
+    for (int i = n; i--; ) {
+      bool b = x[i].assigned();
+      if (b) {
+	int idx = lookupValue(k,x[i].val());
+	if (idx == -1) {
+	  return ES_FAILED;
+	}
+	if (onrem[idx]) {
+	  x[i] = x[--n];
+	  x.size(n);
+	}
+      }
+    }
+
+    // remove alredy satisfied values
+    if (rs > 0) {
+      IntSet remset(&rem[0], rs);
+      IntSetRanges rr(remset);
+      for (int i = x.size(); i--;) {
+	if (!x[i].assigned()) {
+	  ModEvent me = x[i].minus(home, rr);
+	  if (me_failed(me)) {
+	    return ES_FAILED;
+	  }
+	  mod |= x[i].assigned();
+	}
+      }
+    }
+
+    all_assigned = true;
+
+    for (int i = x.size(); i--; ) {
+      bool b = x[i].assigned();
+      all_assigned &= b;
+      if (b) {
+	int idx = lookupValue(k,x[i].val());
+	if (idx == -1) {
+	  return ES_FAILED;
+	}
+	count[idx]++;
+      }
+    }
+
+    if (all_assigned) {
+      for (int i = k.size(); i--; ) {
+	int ci = count[i] + k[i].counter();
+	if (!(k[i].min() <= ci && ci <= k[i].max())) {
+	  return ES_FAILED;
+	}
+	// the solution contains ci occurences of value k[i].card();
+	if (isView) {
+	  if (!k[i].assigned()) {
+	    ModEvent me = k[i].eq(home, ci);
+	    GECODE_ME_CHECK(me);
+	    mod |= k[i].assigned();
+	  }
+	}
+      }
+      return ES_SUBSUMED;
+    }
+
+    if (isView) {
+      // check again consistnecy of cardinalities
+      int reqmin = 0;
+      int allmax = 0;
+      m    = k.size();
+      n    = x.size();
+      for (int i = m; i--; ) {
+	int ci = k[i].counter();
+	if (ci > k[i].max() ) {
+	  return ES_FAILED;
+	} else {
+	  allmax += (k[i].max() - ci);
+	  if (ci < k[i].min()) {
+	    reqmin += (k[i].min() - ci);
+	  }
+	}
+	if (k[i].min() > n) {
+	  return ES_FAILED;
+	}
+	if (!k[i].assigned()) {
+	  ModEvent me = k[i].lq(home, n);
+	  if (me_failed(me)) {
+	    return ES_FAILED;
+	  }
+	}
+      }
+
+      if (n < reqmin) {
+	return ES_FAILED;
+      }
+
+      if (_cardall && allmax < n) {
+	return ES_FAILED;
+      }
+    }
+    return mod ? ES_NOFIX : ES_FIX;
+  }
+
+  /*
+   * The propagator proper
+   *
+   */
+
+  template <class View, class Card, bool isView>
+  inline
+  Val<View, Card, isView>::Val(Space* home, ViewArray<View>& x0,
+			       ViewArray<Card>& k0,
+			       bool all)
+    :Propagator(home,true), x(x0), k(k0), card_all(all){
+    x.subscribe(home, this, PC_INT_VAL);
+    k.subscribe(home, this, PC_INT_VAL);
+  }
+
+  template <class View, class Card, bool isView>
+  forceinline
+  Val<View, Card, isView>::Val(Space* home, bool share,
+			       Val<View, Card, isView>& p)
+    : Propagator(home,share,p), card_all(p.card_all){
+    x.update(home,share, p.x);
+    k.update(home,share, p.k);
+  }
+
+  template <class View, class Card, bool isView>
+  size_t
+  Val<View, Card, isView>::dispose(Space* home) {
+    if (!home->failed()) {
+      x.cancel(home,this, PC_INT_VAL);
+      k.cancel(home,this, PC_INT_VAL);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View, class Card, bool isView>
+  Actor*
+  Val<View, Card, isView>::copy(Space* home, bool share) {
+    return new (home) Val<View, Card, isView>(home,share,*this);
+  }
+
+  template <class View, class Card, bool isView>
+  ExecStatus
+  Val<View, Card, isView>::post(Space* home,
+				ViewArray<View>& x0,
+				ViewArray<Card>& k0, bool all) {
+    new (home) Val<View, Card, isView>(home, x0, k0, all);
+    return ES_OK;
+  }
+
+  /**
+   * \brief Complexity depends on the time needed for value lookup in \a k
+   * which is O(n log n).
+   *
+   */
+  template <class View, class Card, bool isView>
+  PropCost
+  Val<View, Card, isView>::cost (void) const {
+    return PC_LINEAR_HI;
+  }
+
+  template <class View, class Card, bool isView>
+  ExecStatus
+  Val<View, Card, isView>::propagate(Space* home) {
+    assert(x.size() > 0);
+    return prop_val<View, Card, isView>(home, x, k, card_all);
+  }
+
+}}}
+
+// STATISTICS: int-prop
+