gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/rel-op/subofunion.icc

@@ -0,0 +1,150 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:31:32 +0200 (Fri, 25 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3573 $
+ *
+ *  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 Set { namespace RelOp {
+
+  template <class View0, class View1, class View2>
+  Actor*
+  SubOfUnion<View0,View1,View2>::copy(Space* home, bool share) {
+    return new (home) SubOfUnion(home,share,*this);
+  }
+
+  template <class View0, class View1, class View2>
+  ExecStatus
+  SubOfUnion<View0,View1,View2>::propagate(Space* home) {
+
+    bool allassigned = x0.assigned() && x1.assigned() && x2.assigned();
+
+    ModEvent me0 = View0::pme(this);
+    ModEvent me1 = View1::pme(this);
+    ModEvent me2 = View2::pme(this);
+
+    bool modified=false;
+
+    do {
+      // lub(x2) <= lub(x0) u lub(x1)
+      if (modified || Rel::testSetEventUB(me0,me1))
+	{
+	  LubRanges<View0> ub0(x0);
+	  LubRanges<View1> ub1(x1);
+	  Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u(ub0,ub1);
+	  GECODE_ME_CHECK(x2.intersectI(home,u));
+	}
+
+      // x1 <= glb(x2)-lub(x0)
+      // x0 <= glb(x2)-lub(x1)
+      if (modified || Rel::testSetEventAnyB(me0,me1,me2)) {
+	{
+	  modified = false;
+	  GlbRanges<View2> lb2(x2);
+	  LubRanges<View0> ub0(x0);
+	  Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View0> >
+	    diff(lb2,ub0);
+	  GECODE_ME_CHECK_MODIFIED(modified, x1.includeI(home,diff));
+	}
+	{
+	  GlbRanges<View2> lb2(x2);
+	  LubRanges<View1> ub1(x1);
+	  Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View1> >
+	    diff(lb2,ub1);
+	  GECODE_ME_CHECK_MODIFIED(modified, x0.includeI(home,diff));
+	}
+      } else {
+        modified = false;
+      }
+
+      // cardinality propagation
+      if (modified ||
+	  Rel::testSetEventCard(me0,me1,me2) ||
+	  Rel::testSetEventLB(me0,me1)
+	  ) {
+	GlbRanges<View0> lb0c(x0);
+	GlbRanges<View1> lb1c(x1);
+	Iter::Ranges::Inter<GlbRanges<View0>, GlbRanges<View1> >
+	  inter(lb0c,lb1c);
+
+	unsigned int m = Iter::Ranges::size(inter);
+
+	if (m < x0.cardMax()+x1.cardMax()) {
+	  GECODE_ME_CHECK_MODIFIED(modified,
+			    x2.cardMax( home,
+					x0.cardMax()+x1.cardMax() - m ) );
+	}
+	if (m + x2.cardMin() > x1.cardMax()) {
+	  GECODE_ME_CHECK_MODIFIED(modified,
+			    x0.cardMin( home,
+					m+x2.cardMin()-x1.cardMax() )  );
+	}
+	if (m + x2.cardMin() > x0.cardMax()) {
+	  GECODE_ME_CHECK_MODIFIED(modified,
+			    x1.cardMin( home,
+					m+x2.cardMin()-x0.cardMax() )  );
+	}
+      }
+
+    } while (modified);
+
+    if (shared(x0,x1,x2)) {
+      if (allassigned) {
+	return ES_SUBSUMED;
+      } else {
+	return ES_NOFIX;
+      }
+    } else {
+      if (x0.assigned() + x1.assigned() + x2.assigned() >= 2) {
+ 	return ES_SUBSUMED;
+      } else {
+	return ES_FIX;
+      }
+    }
+
+  }
+
+  template <class View0, class View1, class View2>
+  forceinline
+  SubOfUnion<View0,View1,View2>::SubOfUnion(Space* home, View0 y0,
+					 View1 y1, View2 y2)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_ANY>(home,y0,y1,y2) {}
+
+  template <class View0, class View1, class View2>
+  forceinline
+  SubOfUnion<View0,View1,View2>::SubOfUnion
+  (Space* home, bool share, SubOfUnion<View0,View1,View2>& p)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_ANY>(home,share,p) {}
+
+  template <class View0, class View1, class View2>
+  ExecStatus SubOfUnion<View0,View1,View2>::post
+  (Space* home, View0 x0, View1 x1, View2 x2) {
+    (void) new (home) SubOfUnion<View0,View1,View2>(home,x0, x1, x2);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/rel-op/superofinter.icc

@@ -0,0 +1,151 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:31:32 +0200 (Fri, 25 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3573 $
+ *
+ *  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 Set { namespace RelOp {
+
+  template <class View0, class View1, class View2>
+  forceinline
+  SuperOfInter<View0,View1,View2>::SuperOfInter
+  (Space* home, View0 y0, View1 y1, View2 y2)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_CLUB>(home,y0,y1,y2) {}
+
+  template <class View0, class View1, class View2>
+  forceinline
+  SuperOfInter<View0,View1,View2>::SuperOfInter
+  (Space* home, bool share, SuperOfInter<View0,View1,View2>& p)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_CLUB>(home,share,p) {}
+
+  template <class View0, class View1, class View2>
+  ExecStatus
+  SuperOfInter<View0,View1,View2>::post(Space* home,
+					View0 x0, View1 x1, View2 x2) {
+    (void) new (home) SuperOfInter<View0,View1,View2>(home, x0, x1, x2);
+    return ES_OK;
+  }
+
+  template <class View0, class View1, class View2>
+  Actor*
+  SuperOfInter<View0,View1,View2>::copy(Space* home, bool share) {
+    return new (home) SuperOfInter(home,share,*this);
+  }
+
+  template <class View0, class View1, class View2>
+  ExecStatus
+  SuperOfInter<View0,View1,View2>::propagate(Space* home) {
+
+    bool allassigned = x0.assigned() && x1.assigned() && x2.assigned();
+
+    ModEvent me0 = View0::pme(this);
+    ModEvent me1 = View1::pme(this);
+    ModEvent me2 = View2::pme(this);
+
+    bool modified = false;
+
+    do {
+      // glb(x2) >= glb(x0) ^ glb(x1)
+      if ( modified || Rel::testSetEventLB(me0,me1)) {
+	GlbRanges<View0> lb0(x0);
+	GlbRanges<View1> lb1(x1);
+	Iter::Ranges::Inter<GlbRanges<View0>,GlbRanges<View1> >
+	  is(lb0, lb1);
+
+	GECODE_ME_CHECK_MODIFIED(modified,x2.includeI(home,is));
+      }
+
+      // lub(x0) -= glb(x1)-lub(x2)
+      // lub(x1) -= glb(x0)-lub(x2)
+      if ( modified || Rel::testSetEventAnyB(me0,me1,me2)) {
+ 	modified = false;
+	GlbRanges<View1> lb12(x1);
+	LubRanges<View2> ub22(x2);
+	Iter::Ranges::Diff<GlbRanges<View1>, LubRanges<View2> >
+	  diff1(lb12, ub22);
+
+	GECODE_ME_CHECK_MODIFIED(modified, x0.excludeI(home,diff1));
+
+	GlbRanges<View0> lb01(x0);
+	LubRanges<View2> ub23(x2);
+	Iter::Ranges::Diff<GlbRanges<View0>, LubRanges<View2> >
+	  diff2(lb01, ub23);
+
+	GECODE_ME_CHECK_MODIFIED(modified, x1.excludeI(home,diff2));
+      } else {
+ 	modified = false;
+      }
+
+      // Cardinality propagation
+      if ( modified ||
+ 	   Rel::testSetEventCard(me0,me1,me2) ||
+	   Rel::testSetEventUB(me0,me1)
+	   ) {
+
+	LubRanges<View0> ub0(x0);
+	LubRanges<View1> ub1(x1);
+	Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u(ub0,ub1);
+
+	unsigned int m = Iter::Ranges::size(u);
+
+	if (m < x0.cardMin() + x1.cardMin()) {
+	  GECODE_ME_CHECK_MODIFIED(modified,
+			    x2.cardMin( home,
+					x0.cardMin()+x1.cardMin() - m ) );
+	}
+	if (m + x2.cardMax() > x1.cardMin()) {
+	  GECODE_ME_CHECK_MODIFIED(modified,
+			    x0.cardMax( home,
+					m+x2.cardMax()-x1.cardMin() )  );
+	}
+	if (m + x2.cardMax() > x0.cardMin()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x1.cardMax( home,
+                                        m+x2.cardMax()-x0.cardMin() )  );
+	}
+      }
+    } while (modified);
+
+
+    if (shared(x0,x1,x2)) {
+      if (allassigned) {
+	return ES_SUBSUMED;
+      } else {
+	return ES_NOFIX;
+      }
+    } else {
+      if (x0.assigned() + x1.assigned() + x2.assigned() >= 2) {
+ 	return ES_SUBSUMED;
+      } else {
+	return ES_FIX;
+      }
+    }
+
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/rel-op/union.icc

@@ -0,0 +1,292 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:31:32 +0200 (Fri, 25 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3573 $
+ *
+ *  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 Set { namespace RelOp {
+
+  /*
+   * "Ternary union" propagator
+   *
+   */
+
+  template <class View0, class View1, class View2>
+  forceinline
+  Union<View0,View1,View2>::Union(Space* home, View0 y0,View1 y1,View2 y2)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_ANY>(home,y0,y1,y2) {}
+
+  template <class View0, class View1, class View2>
+  forceinline
+  Union<View0,View1,View2>::Union(Space* home, bool share,
+			       Union<View0,View1,View2>& p)
+    : InhomTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+			     View2,PC_SET_ANY>(home,share,p) {}
+
+  template <class View0, class View1, class View2>
+  ExecStatus Union<View0,View1,View2>::post(Space* home, View0 x0,
+					 View1 x1, View2 x2) {
+    (void) new (home) Union<View0,View1,View2>(home,x0,x1,x2);
+    return ES_OK;
+  }
+
+  template <class View0, class View1, class View2>
+  Actor*
+  Union<View0,View1,View2>::copy(Space* home, bool share) {
+    return new (home) Union(home,share,*this);
+  }
+
+
+  template <class View0, class View1, class View2>
+  ExecStatus
+  Union<View0,View1,View2>::propagate(Space* home) {
+    // This propagator implements the constraint
+    // x2 = x0 u x1
+
+    bool x0ass = x0.assigned();
+    bool x1ass = x1.assigned();
+    bool x2ass = x2.assigned();
+
+    ModEvent me0 = View0::pme(this);
+    ModEvent me1 = View1::pme(this);
+    ModEvent me2 = View2::pme(this);
+
+    bool x0ubmod = false;
+    bool x1ubmod = false;
+    bool modified = false;
+
+    do {
+
+      modified = false;
+      do {
+	// 4) lub(x2) <= lub(x0) u lub(x1)
+	{
+	  LubRanges<View0> x0ub(x0);
+	  LubRanges<View1> x1ub(x1);
+	  Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u2(x0ub,x1ub);
+	  GECODE_ME_CHECK_MODIFIED(modified, x2.intersectI(home,u2) );
+	}
+
+	if (modified || Rel::testSetEventUB(me2) )
+	  {
+	    modified = false;
+	    // 5) x0 <= x2
+	    LubRanges<View2> x2ub1(x2);
+	    GECODE_ME_CHECK_MODIFIED(modified, x0.intersectI(home,x2ub1) );
+	    x0ubmod |= modified;
+
+	    // 6) x1 <= x2
+	    bool modified2=false;
+	    LubRanges<View2> x2ub2(x2);
+	    GECODE_ME_CHECK_MODIFIED(modified2, x1.intersectI(home,x2ub2) );
+	    x1ubmod |= modified2;
+	    modified |= modified2;
+	  }
+
+      } while (modified);
+
+      modified = false;
+      do {
+	bool modifiedOld = modified;
+	modified = false;
+
+	if (Rel::testSetEventLB(me2) || Rel::testSetEventUB(me0)
+ 	    || x0ubmod || modifiedOld)
+	  {
+	    // 1) glb(x0) \ lub(x1) <= glb(x2)
+	    GlbRanges<View2> x2lb(x2);
+	    LubRanges<View0> x0ub(x0);
+	    Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View0> >
+	      diff(x2lb, x0ub);
+	    GECODE_ME_CHECK_MODIFIED(modified, x1.includeI(home,diff) );
+	  }
+
+	if (Rel::testSetEventLB(me2) || Rel::testSetEventUB(me1)
+	    || x1ubmod || modifiedOld)
+	  {
+	    // 2) glb(x0) \ lub(x2) <= glb(x1)
+	    GlbRanges<View2> x2lb(x2);
+	    LubRanges<View1> x1ub(x1);
+	    Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View1> >
+	      diff(x2lb, x1ub);
+	    GECODE_ME_CHECK_MODIFIED(modified, x0.includeI(home,diff) );
+	  }
+
+ 	if (Rel::testSetEventLB(me0,me1) || modified)
+	  {
+	    //	    modified = false;
+	    // 3) glb(x1) u glb(x2) <= glb(x0)
+	    GlbRanges<View0> x0lb(x0);
+	    GlbRanges<View1> x1lb(x1);
+	    Iter::Ranges::Union<GlbRanges<View0>, GlbRanges<View1> >
+	      u1(x0lb,x1lb);
+	    GECODE_ME_CHECK_MODIFIED(modified, x2.includeI(home,u1) );
+	  }
+
+      } while(modified);
+
+      modified = false;
+      {
+	// cardinality
+	ExecStatus ret = unionCard(home,modified, x0, x1, x2);
+	GECODE_ES_CHECK(ret);
+      }
+
+      if (x2.cardMax() == 0) {
+	GECODE_ME_CHECK( x0.exclude(home,Limits::Set::int_min,
+				    Limits::Set::int_max) );
+	GECODE_ME_CHECK( x1.exclude(home,Limits::Set::int_min,
+				    Limits::Set::int_max) );
+	return ES_SUBSUMED;
+      }
+
+      if (x0.cardMax() == 0) {
+	GECODE_ES_CHECK( (Rel::Eq<View2,View1>::post(home,x2,x1)) );
+	return ES_SUBSUMED;
+      }
+
+      if (x1.cardMax() == 0) {
+	GECODE_ES_CHECK( (Rel::Eq<View2,View0>::post(home,x2,x0)) );
+	return ES_SUBSUMED;
+      }
+
+    } while(modified);
+
+    if (shared(x0,x1,x2)) {
+      return (x0ass && x1ass && x2ass) ? ES_SUBSUMED : ES_NOFIX;
+    } else {
+      if (x0ass && x1ass && x2ass)
+	return ES_SUBSUMED;
+      if (x0ass != x0.assigned() ||
+	  x1ass != x1.assigned() ||
+	  x2ass != x2.assigned()) {
+	return ES_NOFIX;
+      } else {
+ 	return ES_FIX;
+      }
+    }
+  }
+
+
+  /*
+   * "Nary union" propagator
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  UnionN<View0,View1>::UnionN(Space* home, ViewArray<View0>& x, View1 y)
+    : InhomNaryOnePropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,x,y) {
+    shared = x.shared() || viewarrayshared(x,y);
+  }
+
+  template <class View0, class View1>
+  forceinline
+  UnionN<View0,View1>::UnionN(Space* home, bool share, UnionN& p)
+    : InhomNaryOnePropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,share,p),
+      shared(p.shared) {
+    unionOfDets.update(home,p.unionOfDets);
+  }
+
+  template <class View0, class View1>
+  Actor*
+  UnionN<View0,View1>::copy(Space* home, bool share) {
+    return new (home) UnionN<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus UnionN<View0,View1>::post(Space* home,
+				      ViewArray<View0>& x, View1 y) {
+    switch (x.size()) {
+    case 0:
+      GECODE_ME_CHECK(y.cardMax(home, 0));
+      return ES_OK;
+    case 1:
+      return Rel::Eq<View0,View1>::post(home, x[0], y);
+    case 2:
+      return Union<View0,View0,View1>::post(home, x[0], x[1], y);
+    default:
+      (void) new (home) UnionN<View0,View1>(home,x,y);
+      return ES_OK;
+    }
+  }
+
+  template <class View0, class View1>
+  PropCost UnionN<View0,View1>::cost(void) const {
+    return PC_QUADRATIC_LO;
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  UnionN<View0,View1>::propagate(Space* home) {
+    ModEvent me0 = View0::pme(this);
+    ModEvent me1 = View1::pme(this);
+    bool ubevent = Rel::testSetEventUB(me0, me1);
+    bool lbevent = Rel::testSetEventLB(me0, me1);
+    bool anybevent = Rel::testSetEventAnyB(me0, me1);
+    bool cardevent = Rel::testSetEventCard(me0, me1);
+
+    bool modified = false;
+    bool oldModified = false;
+
+    do {
+      oldModified = modified;
+      modified = false;
+      if (modified || oldModified || ubevent)
+	GECODE_ME_CHECK(unionNXiUB(home, modified, x, y,unionOfDets));
+      if (modified || oldModified || ubevent)
+	GECODE_ME_CHECK(partitionNYUB(home, modified, x, y,unionOfDets));
+      if (modified || oldModified || anybevent)
+	GECODE_ME_CHECK(partitionNXiLB(home, modified, x, y,unionOfDets));
+      if (modified || oldModified || lbevent)
+	GECODE_ME_CHECK(partitionNYLB(home, modified, x, y,unionOfDets));
+      if (modified || oldModified || cardevent || ubevent)
+	GECODE_ME_CHECK(unionNCard(home, modified, x, y, unionOfDets));
+    } while (modified);
+
+    for(int i=0;i<x.size();i++){
+      //Do not reverse! Eats away the end of the array!
+      while (i<x.size() && x[i].assigned()) {
+        GlbRanges<View0> det(x[i]);
+        unionOfDets.includeI(home,det);
+        x.move_lst(i);
+      }
+    }
+    // When we run out of variables, make a final check and disolve:
+    if (x.size()==0) {
+      BndSetRanges all1(unionOfDets);
+      GECODE_ME_CHECK( y.intersectI(home,all1) );
+      BndSetRanges all2(unionOfDets);
+      GECODE_ME_CHECK( y.includeI(home,all2) );
+      unionOfDets.dispose(home);
+      return ES_SUBSUMED;
+    }
+
+    return shared ? ES_NOFIX : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop