dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel/nq.hpp

@@ -0,0 +1,160 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  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: 2010-06-07 22:18:14 +1000 (Mon, 07 Jun 2010) $ by $Author: tack $
+ *     $Revision: 11048 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  template<class View0, class View1>
+  forceinline
+  Distinct<View0,View1>::Distinct(Home home, View0 x, View1 y)
+    : MixBinaryPropagator<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)
+    : MixBinaryPropagator<View0, PC_SET_VAL, View1, PC_SET_VAL>
+        (home,share,p) {}
+
+  template<class View0, class View1>
+  ExecStatus
+  Distinct<View0,View1>::post(Home home, View0 x, View1 y) {
+    if (x.assigned()) {
+      GlbRanges<View0> xr(x);
+      IntSet xs(xr);
+      ConstSetView cv(home, xs);
+      GECODE_ES_CHECK((DistinctDoit<View1>::post(home,y,cv)));
+    }
+    if (y.assigned()) {
+      GlbRanges<View1> yr(y);
+      IntSet ys(yr);
+      ConstSetView cv(home, ys);
+      GECODE_ES_CHECK((DistinctDoit<View0>::post(home,x,cv)));
+    }
+    (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, const ModEventDelta&) {
+    assert(x0.assigned()||x1.assigned());
+    if (x0.assigned()) {
+      GlbRanges<View0> xr(x0);
+      IntSet xs(xr);
+      ConstSetView cv(home, xs);
+      GECODE_REWRITE(*this,(DistinctDoit<View1>::post(home(*this),x1,cv)));
+    } else {
+      GlbRanges<View1> yr(x1);
+      IntSet ys(yr);
+      ConstSetView cv(home, ys);
+      GECODE_REWRITE(*this,(DistinctDoit<View0>::post(home(*this),x0,cv)));
+    }
+  }
+
+  template<class View0>
+  ExecStatus
+  DistinctDoit<View0>::post(Home home, View0 x, ConstSetView y) {
+    (void) new (home) DistinctDoit<View0>(home,x,y);
+    return ES_OK;
+  }
+
+  template<class View0>
+  Actor*
+  DistinctDoit<View0>::copy(Space& home, bool share) {
+    return new (home) DistinctDoit<View0>(home,share,*this);
+  }
+
+  template<class View0>
+  ExecStatus
+  DistinctDoit<View0>::propagate(Space& home, const ModEventDelta&) {
+    if (x0.assigned()) {
+      GlbRanges<View0> xi(x0);
+      GlbRanges<ConstSetView> yi(y);
+      if (Iter::Ranges::equal(xi,yi)) { return ES_FAILED; }
+      else { return home.ES_SUBSUMED(*this); }
+    }
+    assert(x0.lubSize()-x0.glbSize() >0);
+    if (x0.cardMin()>y.cardMax()) { return home.ES_SUBSUMED(*this); }
+    if (x0.cardMax()<y.cardMin()) { return home.ES_SUBSUMED(*this); }
+    //These tests are too expensive, we should only do them
+    //in the 1 unknown left case.
+    GlbRanges<View0> xi1(x0);
+    LubRanges<ConstSetView> yi1(y);
+    if (!Iter::Ranges::subset(xi1,yi1)){ return home.ES_SUBSUMED(*this); }
+    LubRanges<View0> xi2(x0);
+    GlbRanges<ConstSetView> yi2(y);
+    if (!Iter::Ranges::subset(yi2,xi2)){ return home.ES_SUBSUMED(*this); }
+    // 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 home.ES_SUBSUMED(*this);
+    }
+    if (x0.glbSize() == y.cardMin()) {
+      GECODE_ME_CHECK(x0.cardMin(home, x0.glbSize() + 1));
+      return home.ES_SUBSUMED(*this);
+    }
+    return ES_FIX;
+  }
+
+  template<class View0>
+  forceinline
+  DistinctDoit<View0>::DistinctDoit(Home home, View0 _x, ConstSetView _y)
+    : UnaryPropagator<View0, PC_SET_ANY>(home,_x), y(_y)  {}
+
+  template<class View0>
+  forceinline
+  DistinctDoit<View0>::DistinctDoit(Space& home, bool share,
+                                    DistinctDoit<View0>& p)
+    : UnaryPropagator<View0, PC_SET_ANY>(home,share,p) {
+    y.update(home,share,p.y);
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel/re-eq.hpp

@@ -0,0 +1,152 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  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: 2010-03-04 03:32:21 +1100 (Thu, 04 Mar 2010) $ by $Author: schulte $
+ *     $Revision: 10364 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  template<class View0, class View1>
+  forceinline
+  ReEq<View0,View1>::ReEq(Home 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(const Space&, const ModEventDelta&) const {
+    return PropCost::ternary(PropCost::LO);
+  }
+
+  template<class View0, class View1>
+  forceinline size_t
+  ReEq<View0,View1>::dispose(Space& home) {
+    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(Home 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, const ModEventDelta&) {
+    if (b.one())
+      GECODE_REWRITE(*this,(Eq<View0,View1>::post(home(*this),x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(*this,(Distinct<View0,View1>::post(home(*this),x0,x1)));
+
+    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()) {
+          GECODE_ME_CHECK(b.zero_none(home));
+          return home.ES_SUBSUMED(*this);
+        }
+      }
+      if (!x0lb() && !x1lb()) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return home.ES_SUBSUMED(*this);
+      } else {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return home.ES_SUBSUMED(*this);
+      }
+    }
+
+    // check whether cardinalities still allow equality
+    if (x0.cardMin() > x1.cardMax() ||
+        x1.cardMin() > x0.cardMax()) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return home.ES_SUBSUMED(*this);
+    }
+
+    // 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() ) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return home.ES_SUBSUMED(*this);
+    }
+
+    // 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() ) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return home.ES_SUBSUMED(*this);
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel/re-lq.hpp

@@ -0,0 +1,182 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 00:34:16 +1000 (Thu, 25 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12346 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  template<class View0, class View1, bool strict>
+  forceinline
+  ReLq<View0,View1,strict>::ReLq(Home 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, bool strict>
+  forceinline
+  ReLq<View0,View1,strict>::ReLq(Space& home, bool share, ReLq& 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, bool strict>
+  PropCost
+  ReLq<View0,View1,strict>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::ternary(PropCost::LO);
+  }
+
+  template<class View0, class View1, bool strict>
+  forceinline size_t
+  ReLq<View0,View1,strict>::dispose(Space& home) {
+    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, bool strict>
+  ExecStatus
+  ReLq<View0,View1,strict>::post(Home home, View0 x0, View1 x1,
+                            Gecode::Int::BoolView b) {
+    (void) new (home) ReLq<View0,View1,strict>(home,x0,x1,b);
+    return ES_OK;
+  }
+
+  template<class View0, class View1, bool strict>
+  Actor*
+  ReLq<View0,View1,strict>::copy(Space& home, bool share) {
+    return new (home) ReLq<View0,View1,strict>(home,share,*this);
+  }
+
+  template<class View0, class View1, bool strict>
+  ExecStatus
+  ReLq<View0,View1,strict>::propagate(Space& home, const ModEventDelta&) {
+    if (b.one())
+      GECODE_REWRITE(*this,(Lq<View0,View1,strict>::post(home(*this),x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(*this,(Lq<View1,View0,!strict>::post(home(*this),x1,x0)));
+
+    if (x0.cardMax() == 0) {
+      if ( (!strict) || x1.cardMin() > 0) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return home.ES_SUBSUMED(*this);
+      }
+      if (strict && x1.cardMax() == 0) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return home.ES_SUBSUMED(*this);
+      }
+    }
+
+    if (x0.assigned() && x1.assigned()) {
+      // directly test x0<=x1
+      int min01;
+      {
+        GlbRanges<View0> x0l(x0);
+        GlbRanges<View1> x1l(x1);
+        Iter::Ranges::Diff<GlbRanges<View1>,GlbRanges<View0> > d(x1l,x0l);
+        if (!d()) {
+          if ((!strict) && x0.cardMax() == x1.cardMax()) {
+            // equal
+            GECODE_ME_CHECK(b.one_none(home));
+          } else {
+            // subset
+            GECODE_ME_CHECK(b.zero_none(home));
+          }
+          return home.ES_SUBSUMED(*this);
+        }
+        min01 = d.min();
+      }
+      int min10;
+      {
+        GlbRanges<View0> x0l(x0);
+        GlbRanges<View1> x1l(x1);
+        Iter::Ranges::Diff<GlbRanges<View0>,GlbRanges<View1> > d(x0l,x1l);
+        if (!d()) {
+          if (strict && x0.cardMax() == x1.cardMax()) {
+            // equal
+            GECODE_ME_CHECK(b.zero_none(home));
+          } else {
+            // subset
+            GECODE_ME_CHECK(b.one_none(home));
+          }
+          return home.ES_SUBSUMED(*this);
+        }
+        min10 = d.min();
+      }
+
+      assert(min01 != min10);
+      if (min01<min10) {
+        GECODE_ME_CHECK(b.one_none(home));
+      } else {
+        GECODE_ME_CHECK(b.zero_none(home));
+      }
+      return home.ES_SUBSUMED(*this);
+    }
+
+    // min(x0lb - x1ub) < min(x1ub) -> b=0
+    if (x1.cardMax() > 0) {
+      GlbRanges<View0> x0l(x0);
+      LubRanges<View1> x1u(x1);
+      int x1umin=x1u.min();
+      Iter::Ranges::Diff<GlbRanges<View0>,LubRanges<View1> > d(x0l,x1u);
+      if (d() && d.min() < x1umin) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return home.ES_SUBSUMED(*this);
+      }
+    }
+    // min(x1lb - x0ub) < min(x0ub) -> b=1
+    if (x0.cardMax() > 0) {
+      LubRanges<View0> x0u(x0);
+      GlbRanges<View1> x1l(x1);
+      int x0umin=x0u.min();
+      Iter::Ranges::Diff<GlbRanges<View1>,LubRanges<View0> > d(x1l,x0u);
+      if (d() && d.min() < x0umin) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return home.ES_SUBSUMED(*this);
+      }
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop