gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,640 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 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 Rel {
+
+  /*
+   * Binary bounds consistent equality
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, View0 x0, View1 x1)
+    : InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,x0,x1) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  EqBnd<View0,View1>::post(Space* home, View0 x0, View1 x1){
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+    } else if (!same(x0,x1)) {
+      (void) new (home) EqBnd<View0,View1>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, bool share, EqBnd<View0,View1>& p)
+    : InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,share,p) {}
+
+  template <class View0, class View1>
+  forceinline
+  EqBnd<View0,View1>::EqBnd(Space* home, bool share, Propagator& p,
+			    View0 x0, View1 x1)
+    : InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>(home,share,p,
+							       x0,x1) {}
+
+  template <class View0, class View1>
+  Actor*
+  EqBnd<View0,View1>::copy(Space* home, bool share) {
+    return new (home) EqBnd<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  EqBnd<View0,View1>::propagate(Space* home) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+      return ES_SUBSUMED;
+    }
+    if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+      return ES_SUBSUMED;
+    }
+    do {
+      GECODE_ME_CHECK(x0.gq(home,x1.min()));
+      GECODE_ME_CHECK(x1.gq(home,x0.min()));
+    } while (x0.min() != x1.min());
+    do {
+      GECODE_ME_CHECK(x0.lq(home,x1.max()));
+      GECODE_ME_CHECK(x1.lq(home,x0.max()));
+    } while (x0.max() != x1.max());
+    return x0.assigned() ? ES_SUBSUMED : ES_FIX;
+  }
+
+
+
+
+
+  /*
+   * Binary domain consistent equality
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  EqDom<View0,View1>::EqDom(Space* home, View0 x0, View1 x1)
+    : InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,x0,x1) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  EqDom<View0,View1>::post(Space* home, View0 x0, View1 x1){
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+    } else if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+    } else if (!same(x0,x1)) {
+      (void) new (home) EqDom<View0,View1>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+
+  template <class View0, class View1>
+  forceinline
+  EqDom<View0,View1>::EqDom(Space* home, bool share, EqDom<View0,View1>& p)
+    : InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>(home,share,p) {}
+
+  template <class View0, class View1>
+  Actor*
+  EqDom<View0,View1>::copy(Space* home, bool share) {
+    return new (home) EqDom<View0,View1>(home,share,*this);
+  }
+
+
+  template <class View0, class View1>
+  PropCost
+  EqDom<View0,View1>::cost(void) const {
+    if (View0::pme(this) == ME_INT_VAL || View1::pme(this) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    if (View0::pme(this) == ME_INT_DOM || View1::pme(this) == ME_INT_DOM)
+      return PC_BINARY_HI;
+    return PC_BINARY_LO;
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  EqDom<View0,View1>::propagate(Space* home) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,x0.val()));
+      return ES_SUBSUMED;
+    }
+    if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.eq(home,x1.val()));
+      return ES_SUBSUMED;
+    }
+    if (View0::pme(this) != ME_INT_DOM && View1::pme(this) != ME_INT_DOM) {
+      do {
+	GECODE_ME_CHECK(x0.gq(home,x1.min()));
+	GECODE_ME_CHECK(x1.gq(home,x0.min()));
+      } while (x0.min() != x1.min());
+      do {
+	GECODE_ME_CHECK(x0.lq(home,x1.max()));
+	GECODE_ME_CHECK(x1.lq(home,x0.max()));
+      } while (x0.max() != x1.max());
+      if (x0.assigned())
+	return ES_SUBSUMED;
+      if (x0.range() && x1.range())
+	return ES_FIX;
+      return this->ES_FIX_PARTIAL(View0::pme(ME_INT_DOM));
+    }
+    ViewRanges<View0> r0(x0);
+    GECODE_ME_CHECK(x1.inter(home,r0));
+    ViewRanges<View1> r1(x1);
+    GECODE_ME_CHECK(x0.narrow(home,r1));
+    return x0.assigned() ? ES_SUBSUMED : ES_FIX;
+  }
+
+
+
+  /*
+   * Nary domain consistent equality
+   *
+   */
+
+  template <class View>
+  forceinline
+  NaryEqDom<View>::NaryEqDom(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_DOM>(home,x) {}
+
+  template <class View>
+  ExecStatus
+  NaryEqDom<View>::post(Space* home, ViewArray<View>& x) {
+    x.unique();
+    if (x.size() == 2)
+      return EqDom<View,View>::post(home,x[0],x[1]);
+    else if (x.size() > 2)
+      (void) new (home) NaryEqDom<View>(home,x);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  NaryEqDom<View>::NaryEqDom(Space* home, bool share, NaryEqDom<View>& p)
+    : NaryPropagator<View,PC_INT_DOM>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  NaryEqDom<View>::copy(Space* home, bool share) {
+    return new (home) NaryEqDom<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  NaryEqDom<View>::cost(void) const {
+    if (View::pme(this) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    if (View::pme(this) == ME_INT_DOM)
+      return cost_hi(x.size(),PC_LINEAR_HI);
+    return cost_lo(x.size(),PC_LINEAR_LO);
+  }
+
+  template <class View>
+  ExecStatus
+  NaryEqDom<View>::propagate(Space* home) {
+    assert(x.size() > 2);
+
+    ModEvent me = View::pme(this);
+    if (me == ME_INT_VAL) {
+      // One of the variables is assigned
+      for (int i = 0; ; i++)
+	if (x[i].assigned()) {
+	  int n = x[i].val();
+	  x.move_lst(i);
+	  for (int i = x.size(); i--; )
+	    GECODE_ME_CHECK(x[i].eq(home,n));
+	  return ES_SUBSUMED;
+	}
+      GECODE_NEVER;
+      return ES_SUBSUMED;
+    }
+
+    if (me == ME_INT_BND) {
+      {
+	// One of the mins has changed
+	int mn = x[0].min();
+      restart_min:
+	for (int i = x.size(); i--; ) {
+	  GECODE_ME_CHECK(x[i].gq(home,mn));
+	  if (mn < x[i].min()) {
+	    mn = x[i].min();
+	    goto restart_min;
+	  }
+	}
+      }
+      {
+	// One of the maxs has changed
+	int mx = x[0].max();
+      restart_max:
+	for (int i = x.size(); i--; ) {
+	  GECODE_ME_CHECK(x[i].lq(home,mx));
+	  if (mx > x[i].max()) {
+	    mx = x[i].max();
+	    goto restart_max;
+	  }
+	}
+      }
+      if (x[0].assigned())
+	return ES_SUBSUMED;
+      return this->ES_FIX_PARTIAL(View::pme(ME_INT_DOM));
+    }
+
+    int n = x.size();
+
+    GECODE_AUTOARRAY(ViewRanges<View>, i_x, n);
+    for (int i = n; i--; ) {
+      ViewRanges<View> i_xi(x[i]);
+      i_x[i] = i_xi;
+    }
+    Iter::Ranges::NaryInter<ViewRanges<View> > r(i_x,n);
+    Iter::Ranges::Cache<Iter::Ranges::NaryInter<ViewRanges<View> > > rc(r);
+
+    if (!rc())
+      return ES_FAILED;
+    ++rc;
+    if (!rc()) {
+      rc.reset();
+      for (int i = n; i--; ) {
+	GECODE_ME_CHECK(x[i].gq(home,rc.min()));
+	GECODE_ME_CHECK(x[i].lq(home,rc.max()));
+      }
+    } else {
+      for (int i = n; i--; ) {
+	rc.reset();
+	GECODE_ME_CHECK(x[i].narrow(home,rc));
+      }
+    }
+    return ES_FIX;
+  }
+
+
+
+  /*
+   * Nary bound consistent equality
+   *
+   */
+
+  template <class View>
+  forceinline
+  NaryEqBnd<View>::NaryEqBnd(Space* home, ViewArray<View>& x)
+    : NaryPropagator<View,PC_INT_BND>(home,x) {}
+
+  template <class View>
+  ExecStatus
+  NaryEqBnd<View>::post(Space* home, ViewArray<View>& x) {
+    if (x.size() == 2)
+      return EqBnd<View,View>::post(home,x[0],x[1]);
+    else if (x.size() > 2)
+      (void) new (home) NaryEqBnd<View>(home,x);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  NaryEqBnd<View>::NaryEqBnd(Space* home, bool share, NaryEqBnd<View>& p)
+    : NaryPropagator<View,PC_INT_BND>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  NaryEqBnd<View>::copy(Space* home, bool share) {
+    return new (home) NaryEqBnd<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  NaryEqBnd<View>::cost(void) const {
+    if (View::pme(this) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    return cost_lo(x.size(),PC_LINEAR_LO);
+  }
+
+  template <class View>
+  ExecStatus
+  NaryEqBnd<View>::propagate(Space* home) {
+    assert(x.size() > 2);
+
+    if (View::pme(this) == ME_INT_VAL) {
+      // One of the variables is assigned
+      for (int i = 0; ; i++)
+	if (x[i].assigned()) {
+	  int n = x[i].val();
+	  x.move_lst(i);
+	  for (int i = x.size(); i--; )
+	    GECODE_ME_CHECK(x[i].eq(home,n));
+	  return ES_SUBSUMED;
+	}
+      GECODE_NEVER;
+      return ES_SUBSUMED;
+    }
+
+    int mn = x[0].min();
+  restart_min:
+    for (int i = x.size(); i--; ) {
+      GECODE_ME_CHECK(x[i].gq(home,mn));
+      if (mn < x[i].min()) {
+	mn = x[i].min();
+	goto restart_min;
+      }
+    }
+    int mx = x[0].max();
+  restart_max:
+    for (int i = x.size(); i--; ) {
+      GECODE_ME_CHECK(x[i].lq(home,mx));
+      if (mx > x[i].max()) {
+	mx = x[i].max();
+	goto restart_max;
+      }
+    }
+    return x[0].assigned() ? ES_SUBSUMED : ES_FIX;
+  }
+
+
+
+  /*
+   * Refied domain-consistent equality
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDom<View,CtrlView>::ReEqDom(Space* home, View x0, View x1, CtrlView b)
+    : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,x0,x1,b) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDom<View,CtrlView>::post(Space* home, View x0, View x1, CtrlView b) {
+    if (b.one())
+      return EqDom<View,View>::post(home,x0,x1);
+    if (b.zero())
+      return Nq<View>::post(home,x0,x1);
+    if (!same(x0,x1)) {
+      (void) new (home) ReEqDom(home,x0,x1,b);
+    } else {
+      GECODE_ME_CHECK(b.t_one(home));
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDom<View,CtrlView>::ReEqDom(Space* home, bool share, ReEqDom& p)
+    : ReBinaryPropagator<View,PC_INT_DOM,CtrlView>(home,share,p) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqDom<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqDom<View,CtrlView>(home,share,*this);
+  }
+
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDom<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      if (EqDom<View,View>::post(home,x0,x1) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      if (Nq<View>::post(home,x0,x1) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    switch (rtest_eq_dom(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;
+  }
+
+
+
+  /*
+   * Refied bounds-consistent equality
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBnd<View,CtrlView>::ReEqBnd(Space* home, View x0, View x1, CtrlView b)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,x0,x1,b) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBnd<View,CtrlView>::post(Space* home, View x0, View x1, CtrlView b){
+    if (b.one())
+      return EqBnd<View,View>::post(home,x0,x1);
+    if (b.zero())
+      return Nq<View>::post(home,x0,x1);
+    if (!same(x0,x1)) {
+      (void) new (home) ReEqBnd(home,x0,x1,b);
+    } else {
+      GECODE_ME_CHECK(b.t_one(home));
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBnd<View,CtrlView>::ReEqBnd(Space* home, bool share, ReEqBnd& p)
+    : ReBinaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqBnd<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqBnd<View,CtrlView>(home,share,*this);
+  }
+
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBnd<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      if (EqBnd<View,View>::post(home,x0,x1) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      if (Nq<View>::post(home,x0,x1) == ES_FAILED)
+	return ES_FAILED;
+      return ES_SUBSUMED;
+    }
+    switch (rtest_eq_bnd(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;
+  }
+
+
+
+
+  /*
+   * Refied domain-consistent equality (one variable)
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDomInt<View,CtrlView>::ReEqDomInt
+  (Space* home, View x, int c0, CtrlView b)
+    : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,x,b), c(c0) {}
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDomInt<View,CtrlView>::post(Space* home, View x, int c, CtrlView b) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x.eq(home,c));
+    } else if (b.zero()) {
+      GECODE_ME_CHECK(x.nq(home,c));
+    } else if (x.assigned()) {
+      assert(b.none());
+      if (x.val() == c) {
+	b.t_one_none(home);
+      } else {
+	b.t_zero_none(home);
+      }
+    } else {
+      (void) new (home) ReEqDomInt(home,x,c,b);	
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqDomInt<View,CtrlView>::ReEqDomInt(Space* home, bool share, ReEqDomInt& p)
+    : ReUnaryPropagator<View,PC_INT_DOM,CtrlView>(home,share,p), c(p.c) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqDomInt<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqDomInt<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqDomInt<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.eq(home,c)); return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.nq(home,c)); return ES_SUBSUMED;
+    }
+    switch (rtest_eq_dom(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;
+  }
+
+
+
+
+  /*
+   * Refied bounds-consistent equality (one variable)
+   *
+   */
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBndInt<View,CtrlView>::ReEqBndInt
+  (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
+  ReEqBndInt<View,CtrlView>::post(Space* home, View x, int c, CtrlView b) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x.eq(home,c));
+    } else if (b.zero()) {
+      GECODE_ME_CHECK(x.nq(home,c));
+    } else if (x.assigned()) {
+      assert(b.none());
+      if (x.val() == c) {
+	b.t_one_none(home);
+      } else {
+	b.t_zero_none(home);
+      }
+    } else {
+      (void) new (home) ReEqBndInt(home,x,c,b);	
+    }
+    return ES_OK;
+  }
+
+
+  template <class View, class CtrlView>
+  forceinline
+  ReEqBndInt<View,CtrlView>::ReEqBndInt(Space* home, bool share, ReEqBndInt& p)
+    : ReUnaryPropagator<View,PC_INT_BND,CtrlView>(home,share,p), c(p.c) {}
+
+  template <class View, class CtrlView>
+  Actor*
+  ReEqBndInt<View,CtrlView>::copy(Space* home, bool share) {
+    return new (home) ReEqBndInt<View,CtrlView>(home,share,*this);
+  }
+
+  template <class View, class CtrlView>
+  ExecStatus
+  ReEqBndInt<View,CtrlView>::propagate(Space* home) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.eq(home,c)); return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.nq(home,c)); return ES_SUBSUMED;
+    }
+    switch (rtest_eq_bnd(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
+