gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/rel/nq.icc

@@ -0,0 +1,188 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3579 $
+ *
+ *  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 Rel {
+
+  /*
+   * Disequality
+   *
+   */
+
+  template <class View>
+  forceinline
+  Nq<View>::Nq(Space* home, View x0, View x1)
+    : BinaryPropagator<View,PC_INT_VAL>(home,x0,x1) {}
+
+  template <class View>
+  ExecStatus
+  Nq<View>::post(Space* home, View x0, View x1){
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.nq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.nq(home,x1.val()));
+    } else if (same(x0,x1)) {
+      return ES_FAILED;
+    } else {
+      (void) new (home) Nq<View>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  Nq<View>::Nq(Space* home, bool share, Nq<View>& p)
+    : BinaryPropagator<View,PC_INT_VAL>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Nq<View>::copy(Space* home, bool share) {
+    return new (home) Nq<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  Nq<View>::cost(void) const {
+    return PC_UNARY_LO;
+  }
+
+  template <class View>
+  ExecStatus
+  Nq<View>::propagate(Space* home) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.nq(home,x0.val()));
+    } else {
+      GECODE_ME_CHECK(x0.nq(home,x1.val()));
+    }
+    return ES_SUBSUMED;
+  }
+
+  /*
+   * Nary disequality
+   *
+   */
+  template<class View>
+  forceinline
+  NaryNq<View>::NaryNq(Space* home, ViewArray<ViewTuple<View,2> >& x0)
+    : BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>(home,
+						     x0[x0.size()-2],
+						     x0[x0.size()-1]), x(x0) {
+    assert(x.size() >= 2);
+    x.size(x.size()-2);
+  }
+
+  template<class View>
+  forceinline
+  NaryNq<View>::NaryNq(Space* home, bool share, NaryNq<View>& p)
+    : BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>(home,share,p) {
+    x.update(home,share,p.x);
+  }
+
+  template<class View>
+  forceinline ExecStatus
+  NaryNq<View>::post(Space* home, ViewArray<ViewTuple<View,2> >& x) {
+    int n = x.size();
+    for (int i=n; i--; )
+      switch (rtest_nq_dom(x[i][0],x[i][1])) {
+      case RT_FALSE: 
+	x[i]=x[--n]; 
+	break;
+      case RT_TRUE:  
+	return ES_OK;
+      case RT_MAYBE: 
+	break;
+      default:
+	GECODE_NEVER;
+      }
+    x.size(n);
+    if (n == 0)
+      return ES_FAILED;
+    if (n == 1)
+      return Nq<View>::post(home,x[0][0],x[0][1]);
+    (void) new (home) NaryNq(home,x);
+    return ES_OK;
+  }
+
+  template<class View>
+  Actor*
+  NaryNq<View>::copy(Space* home, bool share) {
+    return new (home) NaryNq<View>(home,share,*this);
+  }
+
+  template<class View>
+  ExecStatus
+  NaryNq<View>::propagate(Space* home) {
+    // Eliminate equal pairs
+    int n = x.size();
+    for (int i=n; i--; )
+      switch (rtest_nq_dom(x[i][0],x[i][1])) {
+      case RT_TRUE:  
+	return ES_SUBSUMED;
+      case RT_FALSE: 
+	x[i].cancel(home,this,PC_INT_DOM);
+	x[i]=x[--n]; 
+	break;
+      case RT_MAYBE: 
+	break;
+      default:
+	GECODE_NEVER;
+      }
+    switch (rtest_nq_dom(x0[0],x0[1])) {
+    case RT_TRUE: 
+      return ES_SUBSUMED;
+    case RT_FALSE:
+      if (n == 0) {
+	GECODE_ES_CHECK(Nq<View>::post(home,x1[0],x1[1]));
+	return ES_SUBSUMED;
+      }
+      x0.cancel(home,this,PC_INT_DOM);
+      x0=x[--n];
+      x0.subscribe(home,this,PC_INT_DOM);
+      break;
+    case RT_MAYBE: 
+      break;
+    default:
+      GECODE_NEVER;
+    }
+    switch (rtest_nq_dom(x1[0],x1[1])) {
+    case RT_TRUE: 
+      return ES_SUBSUMED;
+    case RT_FALSE:
+      if (n == 0) {
+	GECODE_ES_CHECK(Nq<View>::post(home,x0[0],x0[1]));
+	return ES_SUBSUMED;
+      }
+      x1.cancel(home,this,PC_INT_DOM);
+      x1=x[--n];
+      x1.subscribe(home,this,PC_INT_DOM);
+      break;
+    case RT_MAYBE: 
+      break;
+    default:
+      GECODE_NEVER;
+    }
+    x.size(n);
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/sortedness.cc

@@ -0,0 +1,124 @@
+/*
+ *  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/int/sortedness.hh"
+namespace Gecode {
+
+  using namespace Int;
+  void sortedness(Space* home,
+		  const IntVarArgs& x,
+		  const IntVarArgs& y,
+		  IntConLevel) {
+
+    if (home->failed()) {
+      return;
+    }
+
+    int n  = x.size();
+    int n2 = 2*n;
+
+    // construct single tuple for propagation without permutation variables
+    ViewArray<ViewTuple<IntView,1> > x0(home, n);
+    for (int i = n; i--; ) {
+      x0[i][0] = x[i];
+    }
+    ViewArray<IntView> y0(home, y);
+
+    ViewArray<IntView> xy(home, n2);
+    for (int i = 0; i < n; i++) {
+      xy[i] = x0[i][0];
+    }
+    for (int i = n; i < n2; i++) {
+      xy[i] = y0[i - n];
+    }
+    if (xy.shared()) {
+      throw ArgumentSame("Int::Sortedness");
+    }
+    if (n != y.size()) {
+      throw ArgumentSizeMismatch("Int::Sortedness");
+    }
+
+
+    GECODE_ES_FAIL(home,
+		   (Sortedness::
+		    Sortedness<IntView, ViewTuple<IntView,1>, false>::
+		    post(home, x0, y0)));
+  }
+
+  void sortedness(Space* home,
+		  const IntVarArgs& x,
+		  const IntVarArgs& y,
+		  const IntVarArgs& z,
+		  IntConLevel) {
+    int n = x.size();
+    int n2 = 2*n;
+    int n3 = 3*n;
+
+    if ((n != y.size()) || (n != z.size())) {
+      throw ArgumentSizeMismatch("Int::sortedness");
+    }
+    if (home->failed()) {
+      return;
+    }
+
+    ViewArray<ViewTuple<IntView, 2> > xz0(home, n);
+
+    // assert that permutation variables encode a permutation
+    ViewArray<IntView> pz0(home, n);
+    ViewArray<IntView> y0(home, y);
+    ViewArray<IntView> xyz(home, n3);
+
+
+
+    for (int i = n; i--; ) {
+      xz0[i][0] = x[i];
+      xz0[i][1] = z[i];
+      pz0[i]    = z[i];
+      // Constrain z_i to a valid index
+      GECODE_ME_FAIL(home,xz0[i][1].gq(home,0));
+      GECODE_ME_FAIL(home,xz0[i][1].lq(home,n - 1));
+    }
+
+    // assert permutation
+    distinct(home, z, ICL_BND);
+
+    for (int i = 0; i < n; i++) {
+      xyz[i] = xz0[i][0];
+    }
+    for (int i = n; i < n2; i++) {
+      xyz[i] = y0[i - n];
+    }
+    for (int i = n2; i < n3; i++) {
+      xyz[i] = xz0[i - n2][1];
+    }
+
+    if (xyz.shared()) {
+      throw ArgumentSame("Int::sortedness");
+    }
+
+    GECODE_ES_FAIL(home,
+		   (Sortedness::
+		    Sortedness<IntView, ViewTuple<IntView,2>, true>::
+		    post(home, xz0, y0)));
+  }
+}
+
+// STATISTICS: int-post

data/ext/gecode-1.3.1/gecode/int/sortedness.hh

@@ -0,0 +1,108 @@
+/*
+ *  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.
+ *
+ *
+ */
+
+#ifndef __GECODE_INT_SORTEDNESS_HH__
+#define __GECODE_INT_SORTEDNESS_HH__
+
+
+#include "gecode/int.hh"
+#include "gecode/int/rel.hh"
+
+/**
+ * \namespace Gecode::Int::Sortedness
+ * \brief %Sortedness propagators
+ */
+
+namespace Gecode { namespace Int { namespace Sortedness {
+
+  /**
+   * \brief Bounds consistent sortedness propagator
+   * \par [Reference]
+   *  The algorithm is taken from: \n
+   *  Sven Thiel: Efficient Algorithms for Constraint Propagation
+   *  and for Processing Tree Descriptions (pages 39 to 59)
+   *  [http://www.mpi-sb.mpg.de/~sthiel/thesis.pdf]
+   *
+   * Requires \code #include "gecode/int/sortedness.hh" \endcode
+   * and \code #include "gecode/int/distinct.hh" \endcode.
+   * The latter is required for the extended version of sortedness
+   * including permutation views.
+   * \ingroup FuncIntProp
+   * \note The sortedness propagator does not support sharing!
+   */
+
+  template<class View, class Tuple, bool Perm>
+  class Sortedness : public Propagator {
+  protected:
+
+    /**
+     *  \brief Views to be sorted
+     *
+     *   If Tuple is instantiated to ViewTuple<View,2>,
+     *   \f$xz_i\f$ is a pair \f$(x_i, z_i)\f$, where
+     *   \f$x_i\f$ denotes an unsorted view
+     *   and \f$z_i\f$ is the explicit
+     *   permutation view mapping \f$x_i\f$ to its unsorted counterpart
+     *   \f$y_{z_i}\f$.
+     *   If Tuple is instantiated to ViewTuple<View,1>,
+     *   \f$xz_i\f$ is the unsorted view \f$x_i\f$ lifted to a ViewTuple.
+     */
+    ViewArray<Tuple> xz;
+
+    /// Views denoting the sorted version of \a x
+    ViewArray<View> y;
+    /// original y array
+    ViewArray<View> w;
+    /// connection to dropped view
+    int reachable;
+    /// Constructor for posting
+    Sortedness(Space*, ViewArray<Tuple>&, ViewArray<View>&);
+    /// Constructor for cloning
+    Sortedness(Space* home, bool share, Sortedness<View, Tuple, Perm>& p);
+
+  public:
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost function returning PC_LINEAR_HI
+    virtual PropCost cost (void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for the views \a xz and \a y
+    static  ExecStatus post(Space*, ViewArray<Tuple>&, ViewArray<View>&);
+  };
+
+
+}}}
+
+#include "gecode/int/sortedness/sortsup.icc"
+#include "gecode/int/sortedness/order.icc"
+#include "gecode/int/sortedness/matching.icc"
+#include "gecode/int/sortedness/narrowing.icc"
+#include "gecode/int/sortedness/sortedness.icc"
+
+#endif
+
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,177 @@
+/*
+ *  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 Sortedness {
+
+  /**
+   * \brief Glover's maximum matching in a bipartite graph
+   *
+   * Compute a matching in the bipartite convex intersection graph with
+   * one partition containing the x views and the other containing
+   * the y views. The algorithm works with an implicit array structure
+   * of the intersection graph.
+   *
+   * Union-Find Implementation of F.Glover's matching algorithm.
+   *
+   * The idea is to mimick a priority queue storing x-indices
+   * \f$[i_0,\dots, i_{n-1}]\f$, s.t. the upper domain bounds are sorted
+   * \f$D_{i_0} \leq\dots\leq D_{i_{n-1}}\f$ where \f$ D_{i_0}\f$
+   * is the top element
+   *
+   */
+
+  template <class View, class Tuple, bool Perm>
+  forceinline bool
+  glover(Space* home,
+	 ViewArray<Tuple>& xz,
+	 ViewArray<View>& y,
+	 int tau[],
+	 int phi[],
+	 OfflineMinItem sequence[],
+	 int vertices[]) {
+
+    int xs = xz.size();
+    OfflineMin seq(sequence, vertices, xs);
+    int s  = 0;
+    seq.makeset();
+
+    for (int z = 0; z < xs; z++) {  // forall y nodes
+      int maxy = y[z].max();
+      // creating the sequence of inserts and extractions from the queue
+//       for( ; s <xs && xz[s][0].min() <= maxy; s++) {
+      for( ; s <xs && xz[s][0].min() <= maxy; s++) {
+	seq[s].iset = z;
+	seq[z].rank++;
+      }
+    }
+
+    // offline-min-procedure
+    for (int i = 0; i < xs; i++) {
+      // the upper bound of the x-node should be minimal
+      int perm = tau[i];
+      // find the iteration where \tau(i) became a maching candidate
+      int iter = seq[perm].iset;
+      if (iter<0) {
+	return false;
+      }
+      int j = 0;
+      j = seq.find_pc(iter);
+      // check whether the sequence is valid
+      if (j >= xs) {
+	return false;
+      }
+      // if there is no intersection between the matching candidate
+      // and the y node then there exists NO perfect matching
+      if (xz[perm][0].max() < y[j].min()) {
+	return false;
+      }
+      phi[j]         = perm;
+      seq[perm].iset = -5;           //remove from candidate set
+      int sqjsucc    = seq[j].succ;
+      if (sqjsucc < xs){
+	seq.unite(j,sqjsucc,sqjsucc);
+      } else {
+	seq[seq[j].root].name = sqjsucc; // end of sequence achieved
+      }
+
+      // adjust tree list
+      int pr = seq[j].pred;
+      if (pr != -1) {
+	seq[pr].succ = sqjsucc;
+      }
+      if (sqjsucc != xs) {
+	seq[sqjsucc].pred = pr;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * \brief Symmetric glover function for the upper domain bounds
+   *
+   */
+  template <class View, class Tuple, bool Perm>
+  forceinline bool
+  revglover(Space* home,
+	    ViewArray<Tuple>& xz,
+	    ViewArray<View>& y,
+	    int tau[],
+	    int phiprime[],
+	    OfflineMinItem sequence[],
+	    int vertices[]) {
+
+    int xs = xz.size();
+    OfflineMin seq(sequence, vertices, xs);
+    int s  = xs - 1;
+    seq.makeset();
+
+    int miny = 0;
+    for (int z = xs; z--; ) {     // forall y nodes
+      miny = y[z].min();
+      // creating the sequence of inserts and extractions from the queue
+      for ( ; s > -1 && xz[tau[s]][0].max() >= miny; s--) {
+	seq[tau[s]].iset = z;
+	seq[z].rank++;
+      }
+    }
+
+    // offline-min-procedure
+    for (int i = xs; i--; ) {
+      int perm = i;
+      int iter = seq[perm].iset;
+      if (iter < 0) {
+	return false;
+      }
+      int j = 0;
+      j = seq.find_pc(iter);
+      if (j <= -1) {
+	return false;
+      }
+      // if there is no intersection between the matching candidate
+      // and the y node then there exists NO perfect matching
+      if (xz[perm][0].min() > y[j].max()) {
+	return false;
+      }
+      phiprime[j]    = perm;
+      seq[perm].iset = -5;
+      int sqjsucc    = seq[j].pred;
+      if (sqjsucc >= 0) {
+	seq.unite(j, sqjsucc, sqjsucc);
+      } else {
+	seq[seq[j].root].name = sqjsucc; // end of sequence achieved
+      }
+
+      // adjust tree list
+      int pr = seq[j].succ;
+      if (pr != xs) {
+	seq[pr].pred = sqjsucc;
+      }
+      if (sqjsucc != -1) {
+	seq[sqjsucc].succ = pr;
+      }
+    }
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+