gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,212 @@
+/*
+ *  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 Rel {
+
+  template <class View>
+  inline
+  Lex<View>::Lex(Space* home,
+		 ViewArray<ViewTuple<View,2> >& xy, bool s)
+    : NaryPropagator<ViewTuple<View,2>,PC_INT_BND>(home,xy), strict(s) {}
+
+  template <class View>
+  forceinline
+  Lex<View>::Lex(Space* home, bool share, Lex<View>& p)
+    : NaryPropagator<ViewTuple<View,2>,PC_INT_BND>(home,share,p),
+      strict(p.strict) {}
+
+  template <class View>
+  Actor*
+  Lex<View>::copy(Space* home, bool share) {
+    return new (home) Lex<View>(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  Lex<View>::propagate(Space* home) {
+    /*
+     * State 1
+     *
+     */
+    {
+      int i = 0;
+      int n = x.size();
+
+      while ((i < n) && (x[i][0].min() == x[i][1].max())) {
+	// case: =, >=
+	GECODE_ME_CHECK(x[i][0].lq(home,x[i][1].max()));
+	GECODE_ME_CHECK(x[i][1].gq(home,x[i][0].min()));
+	i++;
+      }
+
+      if (i == n) // case: $
+	return strict ? ES_FAILED : ES_SUBSUMED;
+
+      // Possible cases left: <, <=, > (yields failure), ?
+      GECODE_ME_CHECK(x[i][0].lq(home,x[i][1].max()));
+      GECODE_ME_CHECK(x[i][1].gq(home,x[i][0].min()));
+
+      if (x[i][0].max() < x[i][1].min()) // case: < (after tell)
+	return ES_SUBSUMED;
+
+      // x[i][0] can never be equal to x[i][1] (otherwise: >=)
+      assert(!(x[i][0].assigned() && x[i][1].assigned() &&
+	       x[i][0].val() == x[i][1].val()));
+      // Remove all elements between 0...i-1 as they are assigned and equal
+      x.drop_fst(i);
+      // After this, execution continues at [1]
+    }
+
+    /*
+     * State 2
+     *   prefix: (?|<=)
+     *
+     */
+    {
+      int i = 1;
+      int n = x.size();
+
+      while ((i < n) &&
+	     (x[i][0].min() == x[i][1].max()) &&
+	     (x[i][0].max() == x[i][1].min())) { // case: =
+	assert(x[i][0].assigned() && x[i][1].assigned() &&
+	       (x[i][0].val() == x[i][1].val()));
+	i++;
+      }
+
+      if (i == n) { // case: $
+	if (strict)
+	  goto rewrite_le;
+	else
+	  goto rewrite_lq;
+      }
+
+      if (x[i][0].max() < x[i][1].min()) // case: <
+	goto rewrite_lq;
+
+      if (x[i][0].min() > x[i][1].max()) // case: >
+	goto rewrite_le;
+
+      if (i > 1) {
+	// Remove equal elements [1...i-1], keep element [0]
+	x[i-1]=x[0]; x.drop_fst(i-1);
+      }
+    }
+
+    if (x[1][0].max() <= x[1][1].min()) {
+      // case: <= (invariant: not =, <)
+      /*
+       * State 3
+       *   prefix: (?|<=),<=
+       *
+       */
+      int i = 2;
+      int n = x.size();
+
+      while ((i < n) && (x[i][0].max() == x[i][1].min())) // case: <=, =
+	i++;
+
+      if (i == n) { // case: $
+	if (strict)
+	  return ES_FIX;
+	else
+	  goto rewrite_lq;
+      }
+
+      if (x[i][0].max() < x[i][1].min()) // case: <
+	goto rewrite_lq;
+
+      if (x[i][0].min() > x[i][1].max()) { // case: >
+	// Eliminate [i]...[n-1]
+	for (int j=i; j<n; j++)
+	  x[j].cancel(home,this,PC_INT_BND);
+	x.size(i);
+	strict = true;
+      }
+
+      return ES_FIX;
+    }
+
+    if (x[1][0].min() >= x[1][1].max()) {
+      // case: >= (invariant: not =, >)
+      /*
+       * State 4
+       *   prefix: (?|<=) >=
+       *
+       */
+      int i = 2;
+      int n = x.size();
+
+      while ((i < n) && (x[i][0].min() == x[i][1].max()))
+	// case: >=, =
+	i++;
+
+      if (i == n) { // case: $
+	if (strict)
+	  goto rewrite_le;
+	else
+	  return ES_FIX;
+      }
+
+      if (x[i][0].min() > x[i][1].max()) // case: >
+	goto rewrite_le;
+
+      if (x[i][0].max() < x[i][1].min()) { // case: <
+	// Eliminate [i]...[n-1]
+	for (int j=i; j<n; j++)
+	  x[j].cancel(home,this,PC_INT_BND);
+	x.size(i);
+	strict = false;
+      }
+
+      return ES_FIX;
+    }
+
+    return ES_FIX;
+
+  rewrite_le:
+    GECODE_ES_CHECK(Le<View>::post(home,x[0][0],x[0][1]));
+    return ES_SUBSUMED;
+
+  rewrite_lq:
+    GECODE_ES_CHECK(Lq<View>::post(home,x[0][0],x[0][1]));
+    return ES_SUBSUMED;
+  }
+
+  template <class View>
+  ExecStatus
+  Lex<View>::post(Space* home,
+		  ViewArray<ViewTuple<View,2> >& xy, bool strict){
+    if (xy.size() == 0)
+      return strict ? ES_FAILED : ES_OK;
+    if (xy.size() == 1)
+      if (strict)
+	return Le<View>::post(home,xy[0][0],xy[0][1]);
+      else
+	return Lq<View>::post(home,xy[0][0],xy[0][1]);
+    (void) new (home) Lex<View>(home,xy,strict);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/rel/lq-le.icc

@@ -0,0 +1,246 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *     Gabor Szokoli, 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 Rel {
+
+  /*
+   * Less or equal propagator
+   *
+   */
+
+  template <class View>
+  forceinline
+  Lq<View>::Lq(Space* home, View x0, View x1)
+    : BinaryPropagator<View,PC_INT_BND>(home,x0,x1) {}
+
+  template <class View>
+  ExecStatus
+  Lq<View>::post(Space* home, View x0, View x1) {
+    GECODE_ME_CHECK(x0.lq(home,x1.max()));
+    GECODE_ME_CHECK(x1.gq(home,x0.min()));
+    if (!same(x0,x1) && (x0.max() > x1.min()))
+      (void) new (home) Lq<View>(home,x0,x1);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  Lq<View>::Lq(Space* home, bool share, Lq<View>& p)
+    : BinaryPropagator<View,PC_INT_BND>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Lq<View>::copy(Space* home, bool share) {
+    return new (home) Lq<View>(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  Lq<View>::propagate(Space* home) {
+    GECODE_ME_CHECK(x0.lq(home,x1.max()));
+    GECODE_ME_CHECK(x1.gq(home,x0.min()));
+    return (x0.max() <= x1.min()) ? ES_SUBSUMED : ES_FIX;
+  }
+
+
+
+
+  /*
+   * Less propagator
+   *
+   */
+
+  template <class View>
+  forceinline
+  Le<View>::Le(Space* home, View x0, View x1)
+    : BinaryPropagator<View,PC_INT_BND>(home,x0,x1) {}
+
+  template <class View>
+  ExecStatus
+  Le<View>::post(Space* home, View x0, View x1) {
+    if (same(x0,x1))
+      return ES_FAILED;
+    GECODE_ME_CHECK(x0.le(home,x1.max()));
+    GECODE_ME_CHECK(x1.gr(home,x0.min()));
+    if (x0.max() >= x1.min())
+      (void) new (home) Le<View>(home,x0,x1);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  Le<View>::Le(Space* home, bool share, Le<View>& p)
+    : BinaryPropagator<View,PC_INT_BND>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Le<View>::copy(Space* home, bool share) {
+    return new (home) Le<View>(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  Le<View>::propagate(Space* home) {
+    GECODE_ME_CHECK(x0.le(home,x1.max()));
+    GECODE_ME_CHECK(x1.gr(home,x0.min()));
+    return (x0.max() < x1.min()) ? ES_SUBSUMED : ES_FIX;
+  }
+
+
+  /*
+   * Reified less or equal propagator
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReLq<View,CtrlView>::ReLq(Space* home, View x0, View x1, CtrlView b)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,x0,x1,b) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReLq<View,CtrlView>::post(Space* home, View x0, View x1, CtrlView b) {
+    if (b.one())
+      return Lq<View>::post(home,x0,x1);
+    if (b.zero())
+      return Le<View>::post(home,x1,x0);
+    if (!same(x0,x1)) {
+      switch (rtest_lq(x0,x1)) {
+      case RT_TRUE:
+	b.t_one_none(home); break;
+      case RT_FALSE:
+	b.t_zero_none(home); break;
+      case RT_MAYBE:
+	(void) new (home) ReLq<View,CtrlView>(home,x0,x1,b); break;
+      default: GECODE_NEVER;
+      }
+    } else {
+      b.t_one_none(home);
+    }
+    return ES_OK;
+  }
+
+  template <class View, class CtrlView>
+  forceinline
+  ReLq<View,CtrlView>::ReLq(Space* home, bool share, ReLq& p)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReLq<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReLq<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReLq<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      if (Lq<View>::post(home,x0,x1) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      if (Le<View>::post(home,x1,x0) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    switch (rtest_lq(x0,x1)) {
+    case RT_TRUE:
+      b.t_one_none(home);  return ES_SUBSUMED;
+    case RT_FALSE:
+      b.t_zero_none(home); return ES_SUBSUMED;
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  }
+
+  /*
+   * Reified less or equal propagator involving one variable
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReLqInt<View,CtrlView>::ReLqInt(Space* home, View x, int c0, CtrlView b)
+    : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,x,b), c(c0) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReLqInt<View,CtrlView>::post(Space* home, View x, int c, CtrlView b) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x.lq(home,c));
+    } else if (b.zero()) {
+      GECODE_ME_CHECK(x.gr(home,c));
+    } else {
+      switch (rtest_lq(x,c)) {
+      case RT_TRUE:
+	b.t_one_none(home); break;
+      case RT_FALSE:
+	b.t_zero_none(home); break;
+      case RT_MAYBE:
+	(void) new (home) ReLqInt<View,CtrlView>(home,x,c,b); break;
+      default: GECODE_NEVER;
+      }
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReLqInt<View,CtrlView>::ReLqInt(Space* home, bool share, ReLqInt& p)
+    : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p), c(p.c) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReLqInt<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReLqInt<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReLqInt<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.lq(home,c)); return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.gr(home,c));  return ES_SUBSUMED;
+    }
+    switch (rtest_lq(x0,c)) {
+    case RT_TRUE:
+      b.t_one_none(home);  return ES_SUBSUMED;
+    case RT_FALSE:
+      b.t_zero_none(home); return ES_SUBSUMED;
+    case RT_MAYBE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+