dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/element/disjoint.hpp

@@ -0,0 +1,324 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-08-09 02:04:53 +1000 (Tue, 09 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12253 $
+ *
+ *  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 Element {
+
+  template<class SView, class RView>
+  forceinline
+  ElementDisjoint<SView,RView>::ElementDisjoint(Home home,
+                                                IdxViewArray& iv0,
+                                                RView y1)
+    : Propagator(home), iv(iv0), x1(y1) {
+
+    x1.subscribe(home,*this, PC_SET_ANY);
+    iv.subscribe(home,*this, PC_SET_ANY);
+  }
+
+  template<class SView, class RView>
+  forceinline
+  ElementDisjoint<SView,RView>::ElementDisjoint(Space& home, bool share,  
+                                                ElementDisjoint& p)
+    : Propagator(home,share,p) {
+    x1.update(home,share,p.x1);
+    iv.update(home,share,p.iv);
+  }
+
+  template<class SView, class RView>
+  forceinline ExecStatus
+  ElementDisjoint<SView,RView>::post(Home home, IdxViewArray& xs,
+                                     RView x1) {
+    int n = xs.size();
+
+    // s2 \subseteq {0,...,n-1}
+    Iter::Ranges::Singleton s(0, n-1);
+    GECODE_ME_CHECK(x1.intersectI(home,s));
+    (void) new (home)
+      ElementDisjoint(home,xs,x1);
+    return ES_OK;
+  }
+
+  template<class SView, class RView>
+  PropCost
+  ElementDisjoint<SView,RView>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::quadratic(PropCost::LO, iv.size()+2);
+  }
+
+  template<class SView, class RView>
+  forceinline size_t
+  ElementDisjoint<SView,RView>::dispose(Space& home) {
+    x1.cancel(home,*this, PC_SET_ANY);
+    iv.cancel(home,*this,PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template<class SView, class RView>
+  Actor*
+  ElementDisjoint<SView,RView>::copy(Space& home, bool share) {
+    return new (home) ElementDisjoint(home,share,*this);
+  }
+
+  template<class SView, class RView>
+  ExecStatus
+  ElementDisjoint<SView,RView>::propagate(Space& home, const ModEventDelta&) {
+    int n = iv.size();
+
+    Region r(home);
+
+    bool fix_flag = false;
+    do {
+      fix_flag = false;
+      // Compute union of all selected elements' lower bounds
+      GlbRanges<RView> x1lb(x1);
+      Iter::Ranges::ToValues<GlbRanges<RView> > vx1lb(x1lb);
+      GLBndSet unionOfSelected(home);
+      for(int i=0; vx1lb(); ++vx1lb) {
+        while (iv[i].idx < vx1lb.val()) i++;
+        GlbRanges<SView> clb(iv[i].view);
+        unionOfSelected.includeI(home,clb);
+      }
+
+      {
+        LubRanges<RView> x1ub(x1);
+        Iter::Ranges::ToValues<LubRanges<RView> > vx1ub(x1ub);
+        int i=0;
+        int j=0;
+        // Cancel all elements that are no longer in the upper bound
+        while (vx1ub()) {
+          if (iv[i].idx < vx1ub.val()) {
+            iv[i].view.cancel(home,*this, PC_SET_ANY);
+            i++;
+            continue;
+          }
+          iv[j] = iv[i];
+          ++vx1ub;
+          ++i; ++j;
+        }
+
+        // cancel the variables with index greater than
+        // max of lub(x1)
+        for (int k=i; k<n; k++) {
+          iv[k].view.cancel(home,*this, PC_SET_ANY);
+        }
+        n = j;
+        iv.size(n);
+      }
+
+      {
+      UnknownRanges<RView> x1u(x1);
+      Iter::Ranges::Cache x1uc(r,x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache>
+        vx1u(x1uc);
+      int i=0;
+      int j=0;
+      while (vx1u()) {
+        while (iv[i].idx < vx1u.val()) {
+          iv[j] = iv[i];
+          i++; j++;
+        }
+        assert(iv[i].idx == vx1u.val());
+
+        SView candidate = iv[i].view;
+        int candidateInd = iv[i].idx;
+
+        GlbRanges<SView> clb(candidate);
+        BndSetRanges uos(unionOfSelected);
+        Iter::Ranges::Inter<GlbRanges<SView>, BndSetRanges>
+          inter(clb, uos);
+        if (inter()) {
+          ModEvent me = x1.exclude(home,candidateInd);
+          fix_flag |= me_modified(me);
+          GECODE_ME_CHECK(me);
+
+          candidate.cancel(home,*this, PC_SET_ANY);
+          ++i;
+          ++vx1u;
+          continue;
+        }
+        iv[j] = iv[i];
+        ++vx1u;
+        ++i; ++j;
+      }
+
+      unionOfSelected.dispose(home);
+
+      // copy remaining variables
+      for (int k=i; k<n; k++) {
+        iv[j] = iv[k];
+        j++;
+      }
+      n = j;
+      iv.size(n);
+      }
+
+      if (x1.cardMax()==0) {
+        // Selector is empty, we're done
+        return home.ES_SUBSUMED(*this);
+      }
+
+      {
+        // remove all elements in a selected variable from
+        // all other selected variables
+        GlbRanges<RView> x1lb(x1);
+        Iter::Ranges::ToValues<GlbRanges<RView> > vx1lb(x1lb);
+        int i=0;
+        for (; vx1lb(); ++vx1lb) {
+          while (iv[i].idx < vx1lb.val()) i++;
+          assert(iv[i].idx==vx1lb.val());
+          GlbRanges<RView> x1lb2(x1);
+          Iter::Ranges::ToValues<GlbRanges<RView> > vx1lb2(x1lb2);
+          for (int j=0; vx1lb2(); ++vx1lb2) {
+            while (iv[j].idx < vx1lb2.val()) j++;
+            assert(iv[j].idx==vx1lb2.val());
+            if (iv[i].idx!=iv[j].idx) {
+              GlbRanges<SView> xilb(iv[i].view);
+              ModEvent me = iv[j].view.excludeI(home,xilb);
+              fix_flag |= me_modified(me);
+              GECODE_ME_CHECK(me);
+            }
+          }
+        }
+      }
+
+      // remove all elements from the selector that overlap
+      // with all other possibly selected elements, if
+      // at least two more elements need to be selected
+      if (x1.cardMin()-x1.glbSize() > 1) {
+        UnknownRanges<RView> x1u(x1);
+        Iter::Ranges::Cache x1uc(r,x1u);
+        Iter::Ranges::ToValues<Iter::Ranges::Cache>
+          vx1u(x1uc);
+
+        for (; vx1u() && x1.cardMin()-x1.glbSize() > 1; ++vx1u) {
+          int i = 0;
+          while (iv[i].idx < vx1u.val()) i++;
+          assert(iv[i].idx == vx1u.val());
+          bool flag=true;
+
+          UnknownRanges<RView> x1u2(x1);
+          Iter::Ranges::ToValues<UnknownRanges<RView> > vx1u2(x1u2);
+          for (; vx1u2(); ++vx1u2) {
+            int j = 0;
+            while (iv[j].idx < vx1u2.val()) j++;
+            assert(iv[j].idx == vx1u2.val());
+            if (iv[i].idx!=iv[j].idx) {
+              GlbRanges<SView> xjlb(iv[j].view);
+              GlbRanges<SView> xilb(iv[i].view);
+              Iter::Ranges::Inter<GlbRanges<SView>, GlbRanges<SView> >
+                inter(xjlb, xilb);
+              if (!inter()) {
+                flag = false;
+                goto here;
+              }
+            }
+          }
+        here:
+          if (flag) {
+            ModEvent me = x1.exclude(home,iv[i].idx);
+            fix_flag |= me_modified(me);
+            GECODE_ME_CHECK(me);
+          }
+        }
+      }
+
+      // if exactly two more elements need to be selected
+      // and there is a possible element i such that all other pairs of
+      // elements overlap, select i
+      UnknownRanges<RView> x1u(x1);
+      Iter::Ranges::Cache x1uc(r,x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache>
+        vx1u(x1uc);
+
+      for (; x1.cardMin()-x1.glbSize() == 2 && vx1u(); ++vx1u) {
+        int i = 0;
+        while (iv[i].idx < vx1u.val()) i++;
+        assert (iv[i].idx == vx1u.val());
+        bool flag=true;
+
+        UnknownRanges<RView> x1u2(x1);
+        Iter::Ranges::ToValues<UnknownRanges<RView> > vx1u2(x1u2);
+        for (; vx1u2(); ++vx1u2) {
+          int j = 0;
+          while (iv[j].idx < vx1u2.val()) j++;
+          assert (iv[j].idx == vx1u2.val());
+          if (iv[i].idx!=iv[j].idx) {
+            UnknownRanges<RView> x1u3(x1);
+            Iter::Ranges::ToValues<UnknownRanges<RView> > vx1u3(x1u3);
+            for (; vx1u3(); ++vx1u3) {
+              int k = 0;
+              while (iv[k].idx < vx1u3.val()) k++;
+              assert (iv[k].idx == vx1u3.val());
+              if (iv[j].idx!=iv[k].idx && iv[i].idx!=iv[k].idx) {
+                GlbRanges<SView> xjlb(iv[j].view);
+                GlbRanges<SView> xilb(iv[k].view);
+                Iter::Ranges::Inter<GlbRanges<SView>, GlbRanges<SView> >
+                  inter(xjlb, xilb);
+                if (!inter()) {
+                  flag = false;
+                  goto here2;
+                }
+              }
+            }
+          }
+        }
+      here2:
+        if (flag) {
+          ModEvent me = x1.include(home,iv[i].idx);
+          fix_flag |= me_modified(me);
+          GECODE_ME_CHECK(me);
+        }
+      }
+    } while (fix_flag);
+
+    bool allAssigned = true;
+    for (int i=iv.size(); i--;)
+      if (!iv[i].view.assigned()) {
+        allAssigned = false;
+        break;
+      }
+    if (!x1.assigned())
+      allAssigned = false;
+
+    return allAssigned ? home.ES_SUBSUMED(*this) : ES_FIX;
+  }
+
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/element/inter.hpp

@@ -0,0 +1,308 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-08-20 00:47:28 +1000 (Sat, 20 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12318 $
+ *
+ *  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 Element {
+
+  template<class View, class View0, class View1>
+  forceinline
+  ElementIntersection<View,View0,View1>::
+  ElementIntersection(Home home, IdxViewArray& iv0, View0 y0, View1 y1,
+                      const IntSet& theUniverse)
+    : Propagator(home), universe(theUniverse), iv(iv0), x0(y0), x1(y1) {
+    home.notice(*this,AP_DISPOSE);
+    x0.subscribe(home,*this, PC_SET_ANY);
+    x1.subscribe(home,*this, PC_SET_ANY);
+    iv.subscribe(home,*this, PC_SET_ANY);
+  }
+
+  template<class View, class View0, class View1>
+  forceinline
+  ElementIntersection<View,View0,View1>::
+  ElementIntersection(Space& home, bool share,
+                      ElementIntersection<View,View0,View1>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    iv.update(home,share,p.iv);
+    universe.update(home,share,p.universe);
+  }
+
+  template<class View, class View0, class View1>
+  PropCost
+  ElementIntersection<View,View0,View1>::cost(const Space&,
+                                              const ModEventDelta&) const {
+    return PropCost::linear(PropCost::HI, iv.size()+2);
+  }
+
+  template<class View, class View0, class View1>
+  forceinline size_t
+  ElementIntersection<View,View0,View1>::dispose(Space& home) {
+    home.ignore(*this,AP_DISPOSE);
+    if (!home.failed()) {
+      x0.cancel(home,*this, PC_SET_ANY);
+      x1.cancel(home,*this, PC_SET_ANY);
+      iv.cancel(home,*this,PC_SET_ANY);
+    }
+    universe.~IntSet();
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template<class View, class View0, class View1>
+  ExecStatus
+  ElementIntersection<View,View0,View1>::
+  post(Home home, IdxViewArray& xs, View0 x0, View1 x1,
+       const IntSet& universe) {
+    int n = xs.size();
+
+    // x0 \subseteq {1,...,n}
+    Iter::Ranges::Singleton s(0, n-1);
+    GECODE_ME_CHECK(x0.intersectI(home,s));
+    (void) new (home)
+      ElementIntersection<View,View0,View1>(home,xs,x0,x1,universe);
+    return ES_OK;
+  }
+
+  template<class View, class View0, class View1>
+  Actor*
+  ElementIntersection<View,View0,View1>::copy(Space& home, bool share) {
+    return new (home) ElementIntersection<View,View0,View1>(home,share,*this);
+  }
+
+  template<class View, class View0, class View1>
+  ExecStatus
+  ElementIntersection<View,View0,View1>::propagate(Space& home,
+                                                   const ModEventDelta&) {
+    Region r(home);
+    int n = iv.size();
+
+    bool loopVar;
+    do {
+      loopVar = false;
+
+      // Cache the upper bound iterator, as we have to
+      // modify the upper bound while iterating
+      LubRanges<View0> x0ub(x0);
+      Iter::Ranges::Cache x0ubc(r,x0ub);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache> vx0ub(x0ubc);
+
+      GlbRanges<View0> x0lb(x0);
+      Iter::Ranges::Cache x0lbc(r,x0lb);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache> vx0(x0lbc);
+
+      // In the first iteration, compute in before[i] the intersection
+      // of all the lower bounds of the x_i. At the same time,
+      // exclude inconsistent x_i from x0 and remove them from
+      // the list, cancel their dependencies.
+
+      LUBndSet sofarBefore(home,universe);
+      LUBndSet* before = r.alloc<LUBndSet>(n);
+
+      int j = 0;
+      int i = 0;
+      while ( vx0ub() ) {
+
+        // Remove vars at indices not in the upper bound
+        if (iv[i].idx < vx0ub.val()) {
+          iv[i].view.cancel(home,*this, PC_SET_ANY);
+          ++i;
+          continue;
+        }
+        assert(iv[i].idx == vx0ub.val());
+        iv[j] = iv[i];
+
+        View candidate = iv[j].view;
+        int candidateInd = iv[j].idx;
+
+        // inter = glb(x1) & complement(lub(candidate))
+        GlbRanges<View1> x1lb(x1);
+        LubRanges<View> candub(candidate);
+        Iter::Ranges::Diff<GlbRanges<View1>,LubRanges<View> >
+          inter(x1lb, candub);
+
+        // exclude inconsistent x_i
+        // an x_i is inconsistent if
+        //  * its max cardinality is less than minCard of x1
+        //  * inter is not empty (there are elements in x_0
+        //    that can't be in x_i)
+        if (candidate.cardMax() < x1.cardMin() ||
+            inter()) {
+          ModEvent me = (x0.exclude(home,candidateInd));
+          loopVar |= me_modified(me);
+          GECODE_ME_CHECK(me);
+
+          iv[j].view.cancel(home,*this, PC_SET_ANY);
+          ++i;
+          ++vx0ub;
+          continue;
+        } else {
+          // if x_i is consistent, check whether we know
+          // that its index is in x0
+          if (vx0() && vx0.val()==candidateInd) {
+            // x1 <= candidate, candidate >= x1
+            GlbRanges<View1> x1lb(x1);
+            ModEvent me = candidate.includeI(home,x1lb);
+            loopVar |= me_modified(me);
+            GECODE_ME_CHECK(me);
+
+            LubRanges<View> candub(candidate);
+            me = x1.intersectI(home,candub);
+            loopVar |= me_modified(me);
+            GECODE_ME_CHECK(me);
+            ++vx0;
+          }
+          new (&before[j]) LUBndSet(home);
+          before[j].update(home,sofarBefore);
+          GlbRanges<View> clb(candidate);
+          sofarBefore.intersectI(home,clb);
+        }
+
+        ++vx0ub;
+        ++i; ++j;
+      }
+
+      // cancel the variables with index greater than
+      // max of lub(x0)
+      for (int k=i; k<n; k++) {
+        iv[k].view.cancel(home,*this, PC_SET_ANY);
+      }
+      n = j;
+      iv.size(n);
+
+      if (x0.cardMax()==0) {
+        // Elementor is empty, hence the result must be universe
+        {
+          IntSetRanges uniI(universe);
+          GECODE_ME_CHECK(x1.includeI(home,uniI));
+        }
+        {
+          IntSetRanges uniI(universe);
+          GECODE_ME_CHECK(x1.intersectI(home,uniI));
+        }
+        for (int i=n; i--;)
+          before[i].dispose(home);
+        return home.ES_SUBSUMED(*this);
+      }
+
+      {
+        // x1 >= sofarBefore
+        BndSetRanges sfB(sofarBefore);
+        ModEvent me = x1.includeI(home,sfB);
+        loopVar |= me_modified(me);
+        GECODE_ME_CHECK(me);
+      }
+
+      sofarBefore.dispose(home);
+
+      LUBndSet sofarAfter(home, universe);
+
+      // In the second iteration, this time backwards, compute
+      // sofarAfter as the intersection of all glb(x_j) with j>i
+      for (int i=n; i--;) {
+        if (sofarAfter.size() == 0) break;
+
+        // extra = inter(before[i], sofarAfter) - lub(x1)
+        BndSetRanges b(before[i]);
+        BndSetRanges s(sofarAfter);
+        LubRanges<View1> x1ub(x1);
+        Iter::Ranges::Inter<BndSetRanges, BndSetRanges> inter(b,s);
+        Iter::Ranges::Diff<Iter::Ranges::Inter<BndSetRanges,
+          BndSetRanges>, LubRanges<View1> > diff(inter, x1ub);
+        if (diff()) {
+          ModEvent me = (x0.include(home,iv[i].idx));
+          loopVar |= me_modified(me);
+          GECODE_ME_CHECK(me);
+
+          // candidate != extra
+          me = iv[i].view.excludeI(home,diff);
+          loopVar |= me_modified(me);
+          GECODE_ME_CHECK(me);
+        }
+
+        GlbRanges<View> ivilb(iv[i].view);
+        sofarAfter.intersectI(home,ivilb);
+        before[i].dispose(home);
+      }
+      sofarAfter.dispose(home);
+
+    } while (loopVar);
+
+    // Test whether we determined x0 without determining x1
+    if (x0.assigned() && !x1.assigned()) {
+      int ubsize = static_cast<int>(x0.lubSize());
+      if (ubsize > 2) {
+        assert(ubsize==n);
+        ViewArray<View> is(home,ubsize);
+        for (int i=n; i--;)
+          is[i]=iv[i].view;
+        GECODE_REWRITE(*this,(RelOp::IntersectionN<View, View1>
+                        ::post(home(*this),is,x1)));
+      } else if (ubsize == 2) {
+        assert(n==2);
+        View a = iv[0].view;
+        View b = iv[1].view;
+        GECODE_REWRITE(*this,(RelOp::Intersection<View,View,View1>
+                       ::post(home(*this),a,b,x1)));
+      } else if (ubsize == 1) {
+        assert(n==1);
+        GECODE_REWRITE(*this,
+          (Rel::Eq<View1,View>::post(home(*this),x1,iv[0].view)));
+      } else {
+        GECODE_ME_CHECK(x1.cardMax(home, 0));
+        return home.ES_SUBSUMED(*this);
+      }
+    }
+
+    bool allAssigned = true;
+    for (int i=iv.size(); i--;) {
+      if (!iv[i].view.assigned()) {
+        allAssigned = false;
+        break;
+      }
+    }
+    if (x1.assigned() && x0.assigned() && allAssigned) {
+      return home.ES_SUBSUMED(*this);
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop