gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/rel/common.icc

@@ -0,0 +1,109 @@
+/*
+ *  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.
+ *
+ */
+
+#define GECODE_SET_ME_CHECK_VAL(p,f) {				\
+    ModEvent __me__ ## __LINE__ = (p);				\
+    if (me_failed(__me__ ## __LINE__)) return ES_FAILED;	\
+    if (ME_GEN_ASSIGNED==(__me__ ## __LINE__))f=true; }
+
+#define GECODE_SET_ME_CHECK_VAL_B(modified, tell, f)        \
+  {							\
+    ModEvent me = (tell);				\
+    modified |= me_modified(me);			\
+    if (ME_GEN_ASSIGNED==(me))f=true;			\
+    GECODE_ME_CHECK(me);				\
+  }
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me1, ModEvent me2, ModEvent me) {
+    ModEvent cme = SetView::combine(me0,SetView::combine(me1, me2));
+    return SetView::combine(cme, me)==cme;
+  }
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me1, ModEvent me) {
+    ModEvent cme = SetView::combine(me0, me1);
+    return SetView::combine(cme, me)==cme;
+  }
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me) {
+    return SetView::combine(me0, me)==me0;
+  }
+
+  forceinline
+  bool testSetEventLB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return ( me0!=ME_SET_CARD || me1!=ME_SET_CARD || me2!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_CARD);
+  }
+  forceinline
+  bool testSetEventLB(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0, ModEvent me1) {
+    return ( me0!=ME_SET_CARD || me1!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_CARD);
+  }
+  forceinline
+  bool testSetEventLB(ModEvent me0) {
+    return subsumesME(me0, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0) {
+    return subsumesME(me0, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0) {
+    return ( me0!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0) {
+    return subsumesME(me0, ME_SET_CARD);
+  }
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,101 @@
+/*
+ *  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: 2005-11-15 17:40:47 +0100 (Tue, 15 Nov 2005) $ by $Author: tack $
+ *     $Revision: 2576 $
+ *
+ *  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 Rel {
+
+  template <class View0, class View1>
+  forceinline
+  Eq<View0,View1>::Eq(Space* home, View0 x, View1 y)
+    : InhomBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,x,y) {}
+
+  template <class View0, class View1>
+  forceinline
+  Eq<View0,View1>::Eq(Space* home, bool share, Eq& p)
+    : InhomBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,share,p) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  Eq<View0,View1>::post(Space* home, View0 x, View1 y) {
+    (void) new (home) Eq(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  Eq<View0,View1>::copy(Space* home, bool share) {
+    return new (home) Eq(home,share,*this);
+  }
+
+
+  template <class View0, class View1>
+  ExecStatus
+  Eq<View0,View1>::propagate(Space* home) {
+
+    ModEvent me0 = View0::pme(this);
+    ModEvent me1 = View1::pme(this);
+
+    if ( testSetEventLB(me0,me1) ) {
+      GlbRanges<View0> x0lb(x0);
+      GlbRanges<View1> x1lb(x1);
+      Iter::Ranges::Union<GlbRanges<View0>,GlbRanges<View1> > lbu(x0lb,x1lb);
+      Iter::Ranges::Cache<Iter::Ranges::Union
+	<GlbRanges<View0>, GlbRanges<View1> > > lbuc(lbu);
+      GECODE_ME_CHECK ( x0.includeI(home,lbuc) );
+      lbuc.reset();
+      GECODE_ME_CHECK ( x1.includeI(home,lbuc) );
+    }
+
+    if (testSetEventUB(me0,me1) ) {
+      LubRanges<View0> x0ub(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Inter<LubRanges<View0>,LubRanges<View1> > ubi(x0ub,x1ub);
+      Iter::Ranges::Cache<Iter::Ranges::Inter
+	<LubRanges<View0>,LubRanges<View1> > > ubic(ubi);
+      GECODE_ME_CHECK ( x0.intersectI(home,ubic) );
+      ubic.reset();
+      GECODE_ME_CHECK ( x1.intersectI(home,ubic) );
+    }
+
+    if (testSetEventCard(me0,me1) ) {
+      unsigned int max = std::min(x0.cardMax(),x1.cardMax());
+      unsigned int min = std::max(x0.cardMin(),x1.cardMin());
+      GECODE_ME_CHECK ( x0.cardMax(home,max) );
+      GECODE_ME_CHECK ( x1.cardMax(home,max) );
+      GECODE_ME_CHECK ( x0.cardMin(home,min) );
+      GECODE_ME_CHECK ( x1.cardMin(home,min) );
+    }
+
+    if (x0.assigned()) {
+      assert (x1.assigned());
+      return ES_SUBSUMED;
+    }
+    return shared(x0,x1) ? ES_NOFIX : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/rel/nosubset.icc

@@ -0,0 +1,88 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2005-08-01 08:20:10 +0200 (Mon, 01 Aug 2005) $ by $Author: tack $
+ *     $Revision: 2098 $
+ *
+ *  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 Rel {
+
+  /*
+   * "No Subset" propagator
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  NoSubSet<View0,View1>::NoSubSet(Space* home, View0 y0, View1 y1)
+    : InhomBinaryPropagator<View0,PC_SET_CLUB,
+			    View1,PC_SET_CGLB>(home,y0,y1) {}
+
+  template <class View0, class View1>
+  forceinline
+  NoSubSet<View0,View1>::NoSubSet(Space* home, bool share, 
+				  NoSubSet<View0,View1>& p)
+    : InhomBinaryPropagator<View0,PC_SET_CLUB,
+			    View1,PC_SET_CGLB>(home,share,p) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  NoSubSet<View0,View1>::post(Space* home, View0 x, View1 y) {
+    if (me_failed(x.cardMin(home,1)))
+      return ES_FAILED;
+    (void) new (home) NoSubSet<View0,View1>(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  NoSubSet<View0,View1>::copy(Space* home, bool share) {
+    return new (home) NoSubSet<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  NoSubSet<View0,View1>::propagate(Space* home) {
+    GlbRanges<View0> x0lb(x0);
+    LubRanges<View1> x1ub(x1);
+    if (!Iter::Ranges::subset(x0lb, x1ub))
+      return ES_SUBSUMED;
+    if (x0.cardMin()>x1.cardMax()) { return ES_SUBSUMED; }
+    LubRanges<View0> x0ub(x0);
+    GlbRanges<View1> x1lb(x1);
+    Iter::Ranges::Diff<LubRanges<View0>,GlbRanges<View1> >
+      breakers(x0ub,x1lb);
+    if (!breakers()) { return ES_FAILED; }
+    if (breakers.min() == breakers.max()) {
+      int b1 = breakers.min();
+      ++breakers;
+      if (breakers()) { return ES_FIX; }
+      //Only one subsetness-breaker element left:
+      GECODE_ME_CHECK( x0.include(home,b1) );
+      GECODE_ME_CHECK( x1.exclude(home,b1) );
+      return ES_SUBSUMED;
+    }
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,132 @@
+/*
+ *  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: 2005-07-31 16:45:18 +0200 (Sun, 31 Jul 2005) $ by $Author: schulte $
+ *     $Revision: 2096 $
+ *
+ *  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 Rel {
+
+  template <class View0, class View1>
+  forceinline
+  Distinct<View0,View1>::Distinct(Space* home, View0 x, View1 y)
+    : InhomBinaryPropagator<View0, PC_SET_VAL, View1, PC_SET_VAL>(home,x,y) {}
+
+  template <class View0, class View1>
+  forceinline
+  Distinct<View0,View1>::Distinct(Space* home, bool share, Distinct& p)
+    : InhomBinaryPropagator<View0, PC_SET_VAL, View1, PC_SET_VAL>
+        (home,share,p) {}
+
+  template <class View0, class View1>
+  ExecStatus
+  Distinct<View0,View1>::post(Space* home, View0 x, View1 y) {
+    if (x.assigned())
+      GECODE_ES_CHECK((DistinctDoit<View1,View0>::post(home,y,x)));
+    if (y.assigned())
+      GECODE_ES_CHECK((DistinctDoit<View0,View1>::post(home,x,y)));
+    (void) new (home) Distinct<View0,View1>(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  Distinct<View0,View1>::copy(Space* home, bool share) {
+    return new (home) Distinct<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  Distinct<View0,View1>::propagate(Space* home) {
+    assert(x0.assigned()||x1.assigned());
+    if (x0.assigned()) {
+      GECODE_ES_CHECK((DistinctDoit<View1,View0>::post(home,x1,x0)));
+    } else {
+      GECODE_ES_CHECK((DistinctDoit<View0,View1>::post(home,x0,x1)));
+    }
+    return ES_SUBSUMED;
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  DistinctDoit<View0,View1>::post(Space* home, View0 x, View1 y) {
+    (void) new (home) DistinctDoit<View0,View1>(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  DistinctDoit<View0,View1>::copy(Space* home, bool share) {
+    return new (home) DistinctDoit<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  DistinctDoit<View0,View1>::propagate(Space* home) {
+    assert(y.assigned());
+    if (x0.assigned()) {
+      GlbRanges<View0> xi(x0);
+      GlbRanges<View1> yi(y);
+      if (Iter::Ranges::equal(xi,yi)) { return ES_FAILED; }
+      else { return ES_SUBSUMED; }
+    }
+    assert(x0.lubSize()-x0.glbSize() >0);
+    if (x0.cardMin()>y.cardMax()) { return ES_SUBSUMED; }
+    if (x0.cardMax()<y.cardMin()) { return ES_SUBSUMED; }
+    //These tests are too expensive, we should only do them
+    //in the 1 unknown left case.
+    GlbRanges<View0> xi1(x0);
+    LubRanges<View1> yi1(y);
+    if (!Iter::Ranges::subset(xi1,yi1)){ return ES_SUBSUMED; }
+    LubRanges<View0> xi2(x0);
+    GlbRanges<View1> yi2(y);
+    if (!Iter::Ranges::subset(yi2,xi2)){ return ES_SUBSUMED; }
+    // from here, we know y\subseteq lub(x) and glb(x)\subseteq y
+
+    if (x0.lubSize() == y.cardMin() && x0.lubSize() > 0) {
+      GECODE_ME_CHECK(x0.cardMax(home, x0.lubSize() - 1));
+      return ES_SUBSUMED;
+    }
+    if (x0.glbSize() == y.cardMin()) {
+      GECODE_ME_CHECK(x0.cardMin(home, x0.glbSize() + 1));
+      return ES_SUBSUMED;
+    }
+    return ES_FIX;
+  }
+
+  template <class View0, class View1>
+  forceinline
+  DistinctDoit<View0,View1>::DistinctDoit(Space* home, View0 _x, View1 _y)
+    : UnaryPropagator<View0, PC_SET_ANY>(home,_x), y(_y)  {}
+
+  template <class View0, class View1>
+  forceinline
+  DistinctDoit<View0,View1>::DistinctDoit(Space* home, bool share,
+					  DistinctDoit<View0,View1>& p)
+    : UnaryPropagator<View0, PC_SET_ANY>(home,share,p) {
+    y.update(home,share,p.y);
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/rel/re-eq.icc

@@ -0,0 +1,142 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Bugfixes provided by:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-05-29 09:42:21 +0200 (Mon, 29 May 2006) $ by $Author: schulte $
+ *     $Revision: 3246 $
+ *
+ *  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 Rel {
+
+  template <class View0, class View1>
+  forceinline
+  ReEq<View0,View1>::ReEq(Space* home, View0 y0, View1 y1,
+			  Gecode::Int::BoolView y2)
+    : Propagator(home), x0(y0), x1(y1), b(y2) {
+    b.subscribe(home,this, Gecode::Int::PC_INT_VAL);
+    x0.subscribe(home,this, PC_SET_ANY);
+    x1.subscribe(home,this, PC_SET_ANY);
+  }
+
+  template <class View0, class View1>
+  forceinline
+  ReEq<View0,View1>::ReEq(Space* home, bool share, ReEq& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template <class View0, class View1>
+  PropCost
+  ReEq<View0,View1>::cost(void) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View0, class View1>
+  size_t
+  ReEq<View0,View1>::dispose(Space* home) {
+    assert(!home->failed());
+    b.cancel(home,this, Gecode::Int::PC_INT_VAL);
+    x0.cancel(home,this, PC_SET_ANY);
+    x1.cancel(home,this, PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReEq<View0,View1>::post(Space* home, View0 x0, View1 x1,
+			    Gecode::Int::BoolView b) {
+    (void) new (home) ReEq<View0,View1>(home,x0,x1,b);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  ReEq<View0,View1>::copy(Space* home, bool share) {
+    return new (home) ReEq<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReEq<View0,View1>::propagate(Space* home) {
+
+    if (b.one()) {
+      GECODE_ES_CHECK((Eq<View0,View1>::post(home,x0,x1)));
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ES_CHECK((Distinct<View0,View1>::post(home,x0,x1)));
+      return ES_SUBSUMED;
+    }
+
+    if (x0.assigned() && x1.assigned()) {
+      // directly test x0==x1
+      GlbRanges<View0> x0lb(x0);
+      GlbRanges<View1> x1lb(x1);
+      for (; x0lb() && x1lb(); ++x0lb, ++x1lb) {
+        if (x0lb.min() != x1lb.min() ||
+            x0lb.max() != x1lb.max()) {
+          b.t_zero_none(home);
+          return ES_SUBSUMED;
+        }
+      }
+      if (!x0lb() && !x1lb()) {
+	b.t_one_none(home);
+	return ES_SUBSUMED;
+      } else {
+	b.t_zero_none(home);
+	return ES_SUBSUMED;
+      }
+    }
+
+    // check whether cardinalities still allow equality
+    if (x0.cardMin() > x1.cardMax() ||
+        x1.cardMin() > x0.cardMax()) {
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    }
+
+    // check glb(x0) subset lub(x1)
+    GlbRanges<View0> x0lb(x0);
+    LubRanges<View1> x1ub(x1);
+    Iter::Ranges::Diff<GlbRanges<View0>, LubRanges<View1> > diff1(x0lb, x1ub);
+    if ( diff1() ) {
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    }
+
+    // check glb(x1) subset lub(x0)
+    GlbRanges<View1> x1lb(x1);
+    LubRanges<View0> x0ub(x0);
+    Iter::Ranges::Diff<GlbRanges<View1>, LubRanges<View0> > diff2(x1lb, x0ub);
+    if ( diff2() ) {
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop