gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/sortedness/narrowing.icc

@@ -0,0 +1,243 @@
+/*
+ *  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.
+ *
+ */	
+
+#include "gecode/support/static-stack.hh"
+
+namespace Gecode { namespace Int { namespace Sortedness {
+
+  /**
+   *   \brief Compute the sccs of the oriented intersection-graph
+   *
+   *   An y-node \f$y_j\f$ and its corresponding matching mate
+   *   \f$x_{\phi(j)}\f$ form the smallest possible scc, since both
+   *   edges \f$e_1(y_j, x_{\phi(j)})\f$ and \f$e_2(x_{\phi(j)},y_j)\f$
+   *   are both contained in the oriented intersection graph.
+   *
+   *   Hence a scc containg more than two nodes is represented as an
+   *   array of SccComponent entries,
+   *   \f$[ y_{j_0},x_{\phi(j_0)},\dots,y_{j_k},x_{\phi(j_k)}]\f$.
+   *
+   *   Parameters
+   *   scclist ~ resulting sccs
+   */
+
+  template<class View, class Tuple>
+  forceinline void
+  computesccs(Space* home,
+	      ViewArray<Tuple>& xz,
+	      ViewArray<View>& y,
+	      int phi[],
+	      SccComponent sinfo[],
+	      int scclist[]) {
+
+    // number of sccs is bounded by xs (number of x-nodes)
+    int xs = xz.size();
+    Support::StaticStack<int> cs(xs);
+
+    //select an y node from the graph
+    for (int j = 0; j < xs; j++) {
+      int yjmin      = y[j].min();    // the processed min
+      while (!cs.empty() && xz[phi[sinfo[cs.top()].rightmost]][0].max() < yjmin) {
+	// the topmost scc cannot "reach" y_j or a node to the right of it
+	cs.pop();
+      }
+
+      // a component has the form C(y-Node, matching x-Node)
+      // C is a minimal scc in the oriented intersection graph
+      // we only store y_j-Node, since \phi(j) gives the matching X-node
+      int i     = phi[j];
+      int ximin = xz[i][0].min();
+      while (!cs.empty() && ximin <= y[sinfo[cs.top()].rightmost].max()) {
+	// y_j can "reach" cs.top() ,
+	// i.e. component c can reach component cs.top()
+	// merge c and cs.top() into new component
+	int top = cs.top();
+	// connecting
+	sinfo[sinfo[j].leftmost].left        = top;
+	sinfo[top].right                     = sinfo[j].leftmost;
+	// moving leftmost
+	sinfo[j].leftmost                    = sinfo[top].leftmost;
+	// moving rightmost
+	sinfo[sinfo[top].leftmost].rightmost = j;
+	cs.pop();
+      }
+      cs.push(j);
+    }
+    cs.reset();
+
+
+    // now we mark all components with the respective scc-number
+    // labeling is bound by O(k) which is bound by O(n)
+
+    for (int i = 0; i < xs; i++) {
+      if (sinfo[i].left == i) { // only label variables in sccs
+	int scc = sinfo[i].rightmost;
+	int z   = i;
+	//bound by the size of the largest scc = k
+	while (sinfo[z].right != z) {
+	  sinfo[z].rightmost   = scc;
+	  scclist[phi[z]]      = scc;
+	  z                    = sinfo[z].right;
+	}
+	sinfo[z].rightmost     = scc;
+	scclist[phi[z]]        = scc;
+      }
+    }
+  }
+
+  /**
+   *   \brief Narrowing the domains of the x variables
+   *
+   *   Due to the correspondance between perfect matchings in the "reduced"
+   *   intersection graph of \a x and \a y views and feasible
+   *   assignments for the Sortedness constraint the new domain bounds for
+   *   views in \a x are computed as
+   *      - lower bounds:
+   *        \f$ S_i \geq E_l \f$
+   *        where \f$y_l\f$ is the leftmost neighbour of \f$x_i\f$
+   *      - upper bounds:
+   *        \f$ S_i \leq  E_h \f$
+   *        where \f$y_h\f$ is the rightmost neighbour of \f$x_i\f$
+   */
+
+  template<class View, class Tuple, bool Perm>
+  forceinline bool
+  narrow_domx(Space* home,
+	      ViewArray<Tuple>& xz,
+	      ViewArray<View>& y,
+	      int tau[],
+	      int phi[],
+	      int scclist[],
+	      SccComponent sinfo[],
+	      bool& nofix) {
+
+    int xs        = xz.size();
+
+    // For every x node
+    for (int i = 0; i < xs; i++) {
+
+      int xmin = xz[i][0].min();
+      /*
+       * take the scc-list for the current x node
+       * start from the leftmost reachable y node of the scc
+       * and check which Y node in the scc is
+       * really the rightmost node intersecting x, i.e.
+       * search for the greatest lower bound of x
+       */
+      int start = sinfo[scclist[i]].leftmost;
+      while (y[start].max() < xmin) {
+	start = sinfo[start].right;
+      }
+	
+      if (Perm) {
+	// start is the leftmost-position for x_i
+	// that denotes the lower bound on p_i
+
+	ModEvent me_plb = xz[i][1].gq(home, start);
+	if (me_failed(me_plb)) {
+	  return false;
+	}
+	nofix |= (me_modified(me_plb) && start != xz[i][1].min());
+      }
+
+      ModEvent me_lb = xz[i][0].gq(home, y[start].min());
+      if (me_failed(me_lb)) {
+	return false;
+      }
+      nofix |= (me_modified(me_lb) &&
+		y[start].min() != xz[i][0].min());
+	
+      int ptau = tau[xs - 1 - i];
+      int xmax = xz[ptau][0].max();
+      /*
+       * take the scc-list for the current x node
+       * start from the rightmost reachable node and check which
+       * y node in the scc is
+       * really the rightmost node intersecting x, i.e.
+       * search for the smallest upper bound of x
+       */
+      start = sinfo[scclist[ptau]].rightmost;
+      while (y[start].min() > xmax) {
+	start = sinfo[start].left;
+      }
+
+      if (Perm) {
+	//start is the rightmost-position for x_i
+	//that denotes the upper bound on p_i
+	ModEvent me_pub = xz[ptau][1].lq(home, start);
+	if (me_failed(me_pub)) {
+	  return false;
+	}
+	nofix |= (me_modified(me_pub) && start != xz[ptau][1].max());
+      }
+
+      ModEvent me_ub = xz[ptau][0].lq(home, y[start].max());
+      if (me_failed(me_ub)) {
+	return false;
+      }
+      nofix |= (me_modified(me_ub) &&
+		y[start].max() != xz[ptau][0].max());
+    }
+    return true;
+  }
+
+  /**
+   * \brief Narrowing the domains of the y views
+   *
+   * analogously to the x views we take
+   *    - for the upper bounds the matching \f$\phi\f$ computed in  glover
+   *      and compute the new upper bound by \f$T_j=min(E_j, D_{\phi(j)})\f$
+   *    - for the lower bounds the matching \f$\phi'\f$ computed in  revglover
+   *      and update the new lower bound by \f$T_j=max(E_j, D_{\phi'(j)})\f$
+   */
+
+  template<class View, class Tuple, bool Perm>
+  forceinline bool
+  narrow_domy(Space* home,
+	      ViewArray<Tuple>& xz,
+	      ViewArray<View>& y,
+	      int phi[],
+	      int phiprime[],
+	      bool& nofix) {
+
+    int xs = xz.size();
+    for (int i = xs; i--; ) {
+      ModEvent me_lb = y[i].gq(home, xz[phiprime[i]][0].min());
+      if (me_failed(me_lb)) {
+	return false;
+      }
+      nofix |= (me_modified(me_lb) &&
+		xz[phiprime[i]][0].min() != y[i].min());
+
+      ModEvent me_ub = y[i].lq(home, xz[phi[i]][0].max());
+      if (me_failed(me_ub)) {
+	return false;
+      }
+      nofix |= (me_modified(me_ub) &&
+		xz[phi[i]][0].max() != y[i].max());
+    }
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/sortedness/order.icc

@@ -0,0 +1,232 @@
+/*
+ *  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.
+ *
+ */	
+
+#include "gecode/support/sort.hh"
+
+namespace Gecode { namespace Int { namespace Sortedness {
+
+  /**
+   *  \brief Build \f$\sigma\f$
+   *
+   *  Creates a sorting permutation \f$\sigma\f$ by sorting the
+   *  views in \a x according to their lower bounds
+   */
+
+  template <class View, class Tuple, bool Perm>
+  forceinline void
+  sort_sigma(ViewArray<Tuple>& xz, bool fixed) {
+    int xs = xz.size();
+
+    // test for equal bounds
+
+    if (Perm) {
+      bool eqbnd = true;
+      for (int i = xs - 1; i--; ) {
+	eqbnd &= ( (xz[i][0].min() == xz[i + 1][0].min()) &&
+		   (xz[i][0].max() == xz[i + 1][0].max()));
+      }
+//       std::cout << "what sort\n";
+//       if (eqbnd || fixed) {
+// 	std::cout << "eqbnd & fixed";
+// 	TupleMinIncPerm<Tuple> min_inc;
+// 	Support::quicksort<Tuple, TupleMinIncPerm<Tuple> >
+// 	  (&xz[0], xs, min_inc);
+//       } else {
+// 	std::cout << "normal sort";
+// 	TupleMinInc<Tuple> min_inc;
+// 	Support::quicksort<Tuple, TupleMinInc<Tuple> >(&xz[0], xs, min_inc);
+//       }
+//       std::cout << "\n";
+	TupleMinIncExt<Tuple> min_inc;
+	Support::quicksort<Tuple, TupleMinIncExt<Tuple> >(&xz[0], xs, min_inc);
+
+    } else {
+      TupleMinInc<Tuple> min_inc;
+      Support::quicksort<Tuple, TupleMinInc<Tuple> >(&xz[0], xs, min_inc);
+    }
+  }
+
+  /**
+   *  \brief Build \f$\tau\f$
+   *
+   *  Creates a sorting permutation \f$\tau\f$ by sorting
+   *  a given array of indices in \a tau according to the upper bounds
+   *  of the views in \a x
+   */
+
+  template <class View, class Tuple, bool Perm>
+  forceinline void
+  sort_tau(ViewArray<Tuple>& xz, int tau[]) {
+    int xs = xz.size();
+
+    if (Perm) {
+//       bool eqbnd = true;
+//       for (int i = xs - 1; i--;) {
+// 	eqbnd &= ( (xz[i][0].min() == xz[i + 1][0].min()) &&
+// 		   (xz[i][0].max() == xz[i + 1][0].max()));
+//       }
+
+//       if (eqbnd) {
+// 	TupleMaxIncPerm<Tuple> max_inc;
+// 	Support::quicksort<Tuple, TupleMaxIncPerm<Tuple> >
+// 	  (&xz[0], xs, max_inc);
+//       } else {
+// 	TupleMaxInc<Tuple> ltmax(xz);
+// 	Support::quicksort(&(*tau), xs, ltmax);
+//       }
+	TupleMaxIncExt<Tuple> ltmax(xz);
+	Support::quicksort(&(*tau), xs, ltmax);
+
+    } else {
+      TupleMaxInc<Tuple> ltmax(xz);
+      Support::quicksort(&(*tau), xs, ltmax);
+    }
+  }
+
+  /**
+   * \brief Performing normalization on the views in \a y
+   *
+   * The views in \a y are called normalized if
+   * \f$\forall i\in\{0,\dots, n-1\}: min(y_0) \leq \dots \leq min(y_{n-1}) \wedge
+   *  max(y_0) \leq \dots \leq max(y_{n-1})\f$ holds.
+   */
+  template <class View, class Tuple>
+  forceinline bool
+  normalize(Space* home,
+	    ViewArray<View>& y,
+	    ViewArray<Tuple>& xz,
+	    bool& nofix) {
+
+    int ys = y.size();
+    for (int i = 1; i < ys; i++) {
+      ModEvent me_lb = y[i].gq(home, y[i - 1].min());
+      if (me_failed(me_lb)) {
+	return false;
+      }
+      nofix |= (me_modified(me_lb) && y[i - 1].min() != y[i].min());
+    }
+
+    for (int i = ys - 1; i--; ) {
+      ModEvent me_ub = y[i].lq(home, y[i + 1].max());
+      if (me_failed(me_ub)) {
+	return false;
+      }
+      nofix |= (me_modified(me_ub) && y[i + 1].max() != y[i].max());
+    }
+
+    int xs = xz.size();
+    for (int i = xs; i--; ) {
+      ModEvent me = xz[i][0].gq(home, y[0].min());
+      if (me_failed(me)) {
+	return false;
+      }
+      nofix |= (me_modified(me) && xz[i][0].min() != y[0].min());
+
+      me = xz[i][0].lq(home, y[xs - 1].max());
+      if (me_failed(me)) {
+	return false;
+      }
+      nofix |= (me_modified(me) && xz[i][0].max() != y[xs - 1].max());
+    }
+    return true;
+  }
+
+  /**
+   *  \brief Bounds consistency on the permutation views
+   *
+   *  Check, whether the permutation view are bounds consistent.
+   *  This function tests, whether there are "crossing edges", i.e.
+   *  whether the current domains permit matchings between unsorted views
+   *  \a x and the sorted variables \a y violating the property
+   *  that \a y is sorted.
+   */
+
+  template<class View, class Tuple, bool Perm>
+  forceinline bool
+  perm_bc(Space* home, int tau[],
+	  SccComponent sinfo[],	
+	  int scclist[],
+	  ViewArray<Tuple>& xz,
+	  bool& crossingedge,
+	  bool& nofix) {
+
+    int ps = xz.size();
+
+    for (int i = 1; i < ps; i++) {
+      // if there are "crossed edges"
+      if (xz[i - 1][0].min() < xz[i][0].min()) {
+	if (xz[i - 1][1].min() > xz[i][1].min()) {
+	  if (xz[i][1].min() != sinfo[scclist[i]].leftmost) {
+	    // edge does not take part in solution
+	    if (xz[i][1].assigned()) { // vital edge do not remove it
+	      if (xz[i - 1][0].max() < xz[i][0].min()) {
+		// invalid permutation
+		// the upper bound sorting cannot fix this
+		return false;
+	      }
+	    } else {
+	      crossingedge = true;
+	      // and the permutation can still be changed
+	      // fix the permutation, i.e. modify z
+	      ModEvent me_z = xz[i][1].gq(home, xz[i - 1][1].min());
+	      if (me_failed(me_z)) {
+		return false;
+	      }
+	      nofix |= ( me_modified(me_z) &&
+			 xz[i - 1][1].min() != xz[i][1].min());
+	    }
+	  }
+	}
+      }
+    }
+
+    // the same check as above for the upper bounds
+    for (int i = ps - 1; i--; ) {
+      if (xz[tau[i]][0].max() < xz[tau[i + 1]][0].max()) {
+	if (xz[tau[i]][1].max() > xz[tau[i + 1]][1].max()) {
+	  if (xz[tau[i]][1].max() != sinfo[scclist[tau[i]]].rightmost) {
+	    // edge does not take part in solution
+	    if (xz[tau[i]][1].assigned()) {
+	      if (xz[tau[i + 1]][0].min() > xz[tau[i]][0].max()) {
+		// invalid permutation
+		return false;
+	      }
+	    } else {
+	      crossingedge = true;
+	      ModEvent me_z = xz[tau[i]][1].lq(home, xz[tau[i + 1]][1].max());
+	      if (me_failed(me_z)) {
+		return false;
+	      }
+	      nofix |= (me_modified(me_z) &&
+			xz[tau[i + 1]][1].max() != xz[tau[i]][1].max());
+	    }
+	  }
+	}
+      }
+    }
+
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+