gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/distinct/edge.icc

@@ -0,0 +1,96 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  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 Distinct {
+
+  template <class View>
+  forceinline
+  Edge<View>::Edge(Node<View>* s, Node<View>* d)
+    : sd(s,d) {
+    s->add(this);
+  }
+
+  template <class View>
+  forceinline Node<View>*
+  Edge<View>::dst(Node<View>* s) const {
+    return sd.ptr(s);
+  }
+
+  template <class View>
+  forceinline void
+  Edge<View>::revert(Node<View>* d) {
+    unlink();
+    d->add(this);
+  }
+
+  template <class View>
+  forceinline ViewNode<View>*
+  Edge<View>::view(ValNode<View>* n) const {
+    return static_cast<ViewNode<View>*>(sd.ptr(n));
+  }
+  template <class View>
+  forceinline ValNode<View>*
+  Edge<View>::val(ViewNode<View>* x) const {
+    return static_cast<ValNode<View>*>(sd.ptr(x));
+  }
+
+  template <class View>
+  forceinline bool
+  Edge<View>::used(Node<View>* v) const {
+    return sd.is_set() || (v->comp == sd.ptr(v)->comp);
+  }
+  template <class View>
+  forceinline void
+  Edge<View>::use(void) {
+    sd.set();
+  }
+  template <class View>
+  forceinline void
+  Edge<View>::free(void) {
+    sd.unset();
+  }
+
+  template <class View>
+  forceinline Edge<View>*
+  Edge<View>::next_edge(void) const {
+    return _next_edge;
+  }
+  template <class View>
+  forceinline Edge<View>**
+  Edge<View>::next_edge_ref(void) {
+    return &_next_edge;
+  }
+  template <class View>
+  forceinline Edge<View>*
+  Edge<View>::next(void) const {
+    return static_cast<Edge<View>*>(BiLink::next());
+  }
+
+  template <class View>
+  forceinline void*
+  Edge<View>::operator new(size_t, void* p) {
+    return p;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/distinct/node.icc

@@ -0,0 +1,107 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2005-07-28 22:52:19 +0200 (Thu, 28 Jul 2005) $ by $Author: schulte $
+ *     $Revision: 2072 $
+ *
+ *  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 Distinct {
+
+  /*
+   * Nodes
+   *
+   */
+
+  template <class View>
+  forceinline
+  Node<View>::Node(void)
+    : pre(0), low(0), comp(0) {}
+  template <class View>
+  forceinline Edge<View>*
+  Node<View>::edge_fst(void) const {
+    return static_cast<Edge<View>*>(BiLink::next());
+  }
+  template <class View>
+  forceinline Edge<View>*
+  Node<View>::edge_lst(void) const {
+    return static_cast<Edge<View>*>(static_cast<BiLink*>(const_cast<Node<View>*>(this)));
+  }
+  template <class View>
+  forceinline void*
+  Node<View>::operator new(size_t, void* p) {
+    return p;
+  }
+
+
+
+  /*
+   * Value nodes
+   *
+   */
+
+
+  template <class View>
+  forceinline
+  ValNode<View>::ValNode(int v)
+    : _val(v), _matching(NULL) {}
+  template <class View>
+  forceinline int
+  ValNode<View>::val(void) const {
+    return _val;
+  }
+  template <class View>
+  forceinline void
+  ValNode<View>::matching(Edge<View>* e) {
+    _matching = e;
+  }
+  template <class View>
+  forceinline Edge<View>*
+  ValNode<View>::matching(void) const {
+    return _matching;
+  }
+
+
+
+  /*
+   * View nodes
+   *
+   */
+
+  template <class View>
+  forceinline
+  ViewNode<View>::ViewNode(View x)
+    : _view(x) {}
+  template <class View>
+  forceinline Edge<View>*
+  ViewNode<View>::val_edges(void) const {
+    return _val_edges;
+  }
+  template <class View>
+  forceinline Edge<View>**
+  ViewNode<View>::val_edges_ref(void) {
+    return &_val_edges;
+  }
+  template <class View>
+  forceinline View
+  ViewNode<View>::view(void) const {
+    return _view;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/distinct/ter-dom.icc

@@ -0,0 +1,97 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-07-24 16:50:30 +0200 (Mon, 24 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3446 $
+ *
+ *  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 Distinct {
+
+
+  /*
+   * Ternary domain-consistent distinct
+   *
+   */
+
+  template <class View>
+  forceinline
+  TerDom<View>::TerDom(Space* home, View x0, View x1, View x2)
+    : TernaryPropagator<View,PC_INT_DOM>(home,x0,x1,x2) {}
+
+  template <class View>
+  ExecStatus
+  TerDom<View>::post(Space* home, View x0, View x1, View x2) {
+    (void) new (home) TerDom<View>(home,x0,x1,x2);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  TerDom<View>::TerDom(Space* home, bool share, TerDom<View>& p)
+    : TernaryPropagator<View,PC_INT_DOM>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  TerDom<View>::copy(Space* home, bool share) {
+    return new (home) TerDom<View>(home,share,*this);
+  }
+
+  // Check whether x0 forms a Hall set of cardinality one
+#define GECODE_INT_HALL_ONE(x0,x1,x2)				\
+  if (x0.assigned()) {						\
+    GECODE_ME_CHECK(x1.nq(home,x0.val()));			\
+    GECODE_ME_CHECK(x2.nq(home,x0.val()));			\
+    if (x1.assigned()) {					\
+      GECODE_ME_CHECK(x2.nq(home,x1.val()));			\
+      return ES_SUBSUMED;					\
+    }								\
+    if (x2.assigned()) {					\
+      GECODE_ME_CHECK(x1.nq(home,x2.val()));			\
+      return ES_SUBSUMED;					\
+    }								\
+    return ES_FIX;                                              \
+  }
+
+
+  // Check whether x0 and x1 form a Hall set of cardinality two
+#define GECODE_INT_HALL_TWO(x0,x1,x2)				\
+  if ((x0.size() == 2) && (x1.size() == 2) &&			\
+      (x0.min() == x1.min()) && (x0.max() == x1.max())) {	\
+    GECODE_ME_CHECK(x2.nq(home,x0.min()));			\
+    GECODE_ME_CHECK(x2.nq(home,x0.max()));			\
+    return ES_FIX;                                              \
+  }
+
+  template <class View>
+  ExecStatus
+  TerDom<View>::propagate(Space* home) {
+    GECODE_INT_HALL_ONE(x0,x1,x2);
+    GECODE_INT_HALL_ONE(x1,x0,x2);
+    GECODE_INT_HALL_ONE(x2,x0,x1);
+    GECODE_INT_HALL_TWO(x0,x1,x2);
+    GECODE_INT_HALL_TWO(x0,x2,x1);
+    GECODE_INT_HALL_TWO(x1,x2,x0);
+    return ES_FIX;
+  }
+
+#undef GECODE_INT_HALL_ONE
+#undef GECODE_INT_HALL_TWO
+
+}}}
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,171 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-03-21 16:46:51 +0100 (Tue, 21 Mar 2006) $ by $Author: schulte $
+ *     $Revision: 3093 $
+ *
+ *  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 Distinct {
+
+  /*
+   * Eliminating singleton variables
+   *
+   */
+  template <class View, bool complete>
+  ExecStatus
+  prop_val(Space* home, ViewArray<View>& x) {
+    assert(x.size() > 1);
+    int n = x.size();
+
+    GECODE_AUTOARRAY(int, stack, n);
+    int* c_v = &stack[0];
+    // c_n is the current number of values on stack
+    int c_n = 0;
+
+    // Collect all assigned variables on stack
+    for (int i = n; i--; )
+      if (x[i].assigned()) {
+	c_v[c_n++]=x[i].val(); x[i]=x[--n];
+      }
+
+    // The number of trips
+    int t = 0;
+    do {
+      t++;
+      if (!complete && (t > 16)) {
+	// Give up after sixteeen iterations, but the values must be
+	// propagated first
+	// Maybe we are lucky in that this iteration does the trick...
+	ExecStatus es = ES_FIX;
+	while (c_n > 0) {
+	  int v = c_v[--c_n];
+	  // Check whether value is on stack only once
+	  for (int i = c_n; i--; )
+	    if (c_v[i] == v)
+	      goto failed;
+	  // Tell and do not collect new values
+	  for (int i = n; i--; ) {
+	    ModEvent me = x[i].nq(home,v);
+	    if (me_failed(me))
+	      goto failed;
+	    if (me == ME_INT_VAL)
+	      es = ES_NOFIX;
+	  }
+	}
+	x.size(n);
+	return es;
+      }
+      if (c_n > 31) {
+	// Many values, use full domain operation
+	IntSet d(&c_v[0],c_n);
+	// Check for failure
+	unsigned int s = 0;
+	for (int i = d.size(); i--; )
+	  s += d.width(i);
+	// If the size s of d is different from the number of values,
+	// a value must have appeared multiply: failure
+	if (s != static_cast<unsigned int>(c_n))
+	  goto failed;
+	// We do not need the values on the stack any longer, reset
+	c_n = 0;
+	// Tell and collect new values
+	for (int i = n; i--; )
+	  if ((d.min() <= x[i].max()) && (d.max() >= x[i].min())) {
+	    IntSetRanges dr(d);
+	    ModEvent me = x[i].minus(home,dr);
+	    if (me_failed(me))
+	      goto failed;
+	    if (me == ME_INT_VAL) {
+	      c_v[c_n++]=x[i].val(); x[i]=x[--n];
+	    }
+	  }
+      } else {
+	// Values for next iteration
+	int* n_v = &c_v[c_n];
+	// Stack top for the next iteration
+	int n_n = 0;
+	while (c_n > 0) {
+	  int v = c_v[--c_n];
+	  // Check whether value is not on current stack
+	  for (int i = c_n; i--; )
+	    if (c_v[i] == v)
+	      goto failed;
+	  // Check whether value is not on next stack
+	  for (int i = n_n; i--; )
+	    if (n_v[i] == v)
+	      goto failed;
+	  // Tell and collect new values
+	  for (int i = n; i--; ) {
+	    ModEvent me = x[i].nq(home,v);
+	    if (me_failed(me))
+	      goto failed;
+	    if (me == ME_INT_VAL) {
+	      n_v[n_n++]=x[i].val(); x[i]=x[--n];
+	    }
+	  }
+	}
+	c_v = n_v; c_n = n_n;
+      }
+    } while (c_n > 0);
+    x.size(n);
+    return (n < 2) ? ES_SUBSUMED : ES_FIX;
+  failed:
+    x.size(0);
+    return ES_FAILED;
+  }
+
+
+  /*
+   * The propagator proper
+   *
+   */
+  template <class View>
+  forceinline
+  Val<View>::Val(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_VAL>(home,x) {}
+
+  template <class View>
+  forceinline
+  Val<View>::Val(Space* home, bool share, Val<View>& p)
+    : NaryPropagator<View,PC_INT_VAL>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Val<View>::copy(Space* home, bool share) {
+    return new (home) Val<View>(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  Val<View>::propagate(Space* home) {
+    return prop_val<View,true>(home,x);
+  }
+
+  template <class View>
+  ExecStatus
+  Val<View>::post(Space* home, ViewArray<View>& x) {
+    if (x.size() == 2)
+      return Rel::Nq<View>::post(home,x[0],x[1]);
+    if (x.size() > 2)
+      (void) new (home) Val<View>(home,x);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+