gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,121 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  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
+  ReSubset<View0,View1>::ReSubset(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
+  ReSubset<View0,View1>::ReSubset(Space* home, bool share, ReSubset& 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
+  ReSubset<View0,View1>::cost(void) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View0, class View1>
+  size_t
+  ReSubset<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
+  ReSubset<View0,View1>::post(Space* home, View0 x0, View1 x1,
+			      Gecode::Int::BoolView b) {
+    (void) new (home) ReSubset<View0,View1>(home,x0,x1,b);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  ReSubset<View0,View1>::copy(Space* home, bool share) {
+    return new (home) ReSubset<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReSubset<View0,View1>::propagate(Space* home) {
+
+    if (b.one()) {
+      GECODE_ES_CHECK((SubSet<View0,View1>::post(home,x0,x1)));
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ES_CHECK((NoSubSet<View0,View1>::post(home,x0,x1)));
+      return ES_SUBSUMED;
+    }
+
+    // check whether cardinalities still allow subset
+    if (x0.cardMin() > x1.cardMax()) {
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    }
+
+    // check lub(x0) subset glb(x1)
+    LubRanges<View0> x0ub(x0);
+    GlbRanges<View1> x1lb(x1);
+    Iter::Ranges::Diff<LubRanges<View0>,GlbRanges<View1> > diff1(x0ub, x1lb);
+    if ( !(diff1()) ) {
+      b.t_one_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> > diff2(x0lb, x1ub);
+    if ( diff2() ) {
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    } else if (x0.assigned() && x1.assigned()) {
+      b.t_one_none(home);
+      return ES_SUBSUMED;
+    } else {
+      return ES_FIX;
+    }
+  }
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,80 @@
+/*
+ *  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
+  SubSet<View0,View1>::SubSet(Space* home, View0 y0, View1 y1)
+    : InhomBinaryPropagator<View0,PC_SET_CGLB,
+			    View1,PC_SET_CLUB>(home,y0,y1) {}
+
+  template <class View0, class View1>
+  forceinline
+  SubSet<View0,View1>::SubSet(Space* home, bool share, SubSet& p)
+    : InhomBinaryPropagator<View0,PC_SET_CGLB,
+			    View1,PC_SET_CLUB>(home,share,p) {}
+
+  template <class View0, class View1>
+  ExecStatus SubSet<View0,View1>::post(Space* home, View0 x, View1 y) {
+    (void) new (home) SubSet(home,x,y);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  SubSet<View0,View1>::copy(Space* home, bool share) {
+    return new (home) SubSet(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  SubSet<View0,View1>::propagate(Space* home) {
+    bool oneassigned = x0.assigned() || x1.assigned();
+    unsigned int x0glbsize;
+    do {
+      GlbRanges<View0> x0lb(x0);
+      GECODE_ME_CHECK ( x1.includeI(home,x0lb) );
+      GECODE_ME_CHECK ( x1.cardMin(home,x0.cardMin()) );
+      LubRanges<View1> x1ub(x1);
+      x0glbsize = x0.glbSize();
+      GECODE_ME_CHECK ( x0.intersectI(home,x1ub) );
+      GECODE_ME_CHECK ( x0.cardMax(home,x1.cardMax()) );
+    } while (x0.glbSize() > x0glbsize);
+    if (x0.cardMin()==x1.cardMax()) {
+      GECODE_ES_CHECK((Eq<View0,View1>::post(home,x0,x1)));
+      return ES_SUBSUMED;
+    }
+    if (shared(x0,x1)) {
+      return oneassigned ? ES_SUBSUMED : ES_NOFIX;
+    }
+    return (x0.assigned() || x1.assigned()) ? ES_SUBSUMED : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/select.cc

@@ -0,0 +1,88 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-25 17:01:15 +0200 (Tue, 25 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3215 $
+ *
+ *  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.
+ *
+ */
+
+#include "gecode/set/select.hh"
+
+using namespace Gecode::Set;
+
+namespace Gecode {
+
+  void
+  selectUnion(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<ComplementView<SetView> > iv(home, x);
+    IntSet universe(Limits::Set::int_min,
+		    Limits::Set::int_max);
+    SetView zv(z);
+    ComplementView<SetView> cz(zv);
+    GECODE_ES_FAIL(home,(Select::SelectIntersection<ComplementView<SetView>,
+			 SetView>::post(home,cz,iv,y,universe)));
+  }
+
+  void
+  selectInter(Space* home, const SetVarArgs& x, SetVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    IntSet universe(Limits::Set::int_min,
+		    Limits::Set::int_max);
+    GECODE_ES_FAIL(home,
+                   (Select::SelectIntersection<SetView,SetView>::
+		    post(home,z,iv,y,universe)));
+  }
+
+  void
+  selectInterIn(Space* home, const SetVarArgs& x, SetVar y, SetVar z,
+                const IntSet& universe) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,
+                   (Select::SelectIntersection<SetView,SetView>::
+		    post(home,z,iv,y,universe)));
+  }
+
+  void
+  selectSet(Space* home, const SetVarArgs& x, IntVar y, SetVar z) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<ComplementView<SetView> > iv(home, x);
+    Int::IntView yv(y);
+    SingletonView single(yv);
+    SetView zv(z);
+    ComplementView<SetView> cz(zv);
+    IntSet universe(Limits::Set::int_min,
+		    Limits::Set::int_max);
+    GECODE_ES_FAIL(home,(Select::SelectIntersection<ComplementView<SetView>,
+			 SingletonView>::post(home, cz, iv,
+					      single, universe)));
+  }
+
+  void
+  selectDisjoint(Space* home, const SetVarArgs& x, SetVar y) {
+    if (home->failed()) return;
+    Set::Select::IdxViewArray<SetView> iv(home, x);
+    GECODE_ES_FAIL(home,Select::SelectDisjoint::post(home,iv,y));
+  }
+  
+}
+
+// STATISTICS: set-post
+

data/ext/gecode-1.3.1/gecode/set/select.hh

@@ -0,0 +1,113 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_SET_SELECT_HH__
+#define __GECODE_SET_SELECT_HH__
+
+#include "gecode/set.hh"
+
+#include "gecode/set/select/idxarray.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode { namespace Set { namespace Select {
+
+  /**
+   * \namespace Gecode::Set::Select
+   * \brief %Set selection propagators
+   */
+
+  /**
+   * \brief %Propagator for selected intersection
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  template <class SView, class RView>
+  class SelectIntersection :
+    public Propagator {
+  protected:
+    IntSet universe;
+    SView x0;
+    IdxViewArray<SView> iv;
+    RView x1;
+
+    /// Constructor for cloning \a p
+    SelectIntersection(Space* home, bool share,SelectIntersection& p);
+    /// Constructor for posting
+    SelectIntersection(Space* home,SView,IdxViewArray<SView>&,RView,
+                       const IntSet& universe);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    virtual PropCost    cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home);
+    /** Post propagator for \f$ z=\bigcap\langle x_0,\dots,x_{n-1}\rangle[y] \f$ using \a u as universe
+     *
+     * If \a y is empty, \a z will be constrained to be the given universe
+     * \a u (as an empty intersection is the universe).
+     */
+    static  ExecStatus  post(Space* home,SView z,IdxViewArray<SView>& x,
+			     RView y, const IntSet& u);
+  };
+
+  /**
+   * \brief %Propagator for selected disjointness
+   *
+   * Requires \code #include "gecode/set/select.hh" \endcode
+   * \ingroup FuncSetProp
+   */
+  class SelectDisjoint :
+    public Propagator {
+  protected:
+    IdxViewArray<SetView> iv;
+    SetView x1;
+
+    /// Constructor for cloning \a p
+    SelectDisjoint(Space* home, bool share,SelectDisjoint& p);
+    /// Constructor for posting
+    SelectDisjoint(Space* home,IdxViewArray<SetView>&,SetView);
+  public:
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor*      copy(Space* home,bool);
+    GECODE_SET_EXPORT virtual PropCost    cost(void) const;
+    /// Delete propagator and return its size
+    GECODE_SET_EXPORT virtual size_t dispose(Space* home);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus  propagate(Space* home);
+    /// Post propagator for \f$ \parallel\langle x_0,\dots,x_{n-1}\rangle[y] \f$ 
+    static  ExecStatus  post(Space* home,IdxViewArray<SetView>& x,SetView y);
+  };
+
+}}}
+
+#include "gecode/set/select/inter.icc"
+#include "gecode/set/select/disjoint.icc"
+
+#endif
+
+// STATISTICS: set-prop
+

data/ext/gecode-1.3.1/gecode/set/select/disjoint.cc

@@ -0,0 +1,267 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  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.
+ *
+ */
+
+
+
+#include "gecode/set/select.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+#include "gecode/set.hh"
+
+#include "gecode/iter.hh"
+
+namespace Gecode { namespace Set { namespace Select {
+
+  PropCost
+  SelectDisjoint::cost(void) const {
+    return PC_QUADRATIC_LO;
+  }
+
+  size_t
+  SelectDisjoint::dispose(Space* home) {
+    assert(!home->failed());
+    x1.cancel(home,this, PC_SET_ANY);
+    iv.cancel(home,this,PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  Actor*
+  SelectDisjoint::copy(Space* home, bool share) {
+    return new (home) SelectDisjoint(home,share,*this);
+  }
+
+  ExecStatus
+  SelectDisjoint::propagate(Space* home) {
+    int n = iv.size();
+
+    bool fix_flag;
+    do {
+      fix_flag=false;
+
+      // Compute union of all selected elements' lower bounds
+      GlbRanges<SetView> x1lb(x1);
+      Iter::Ranges::ToValues<GlbRanges<SetView> > vx1lb(x1lb);
+      GLBndSet unionOfSelected(home);
+      for(int i=0; vx1lb(); ++vx1lb) {
+        while (iv[i].idx < vx1lb.val()) i++;
+        GlbRanges<SetView> clb(iv[i].var);
+        unionOfSelected.includeI(home,clb);
+      }
+
+      {
+        LubRanges<SetView> x1ub(x1);
+        Iter::Ranges::ToValues<LubRanges<SetView> > 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].var.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].var.cancel(home,this, PC_SET_ANY);
+        }
+        n = j;
+	iv.size(n);
+      }
+
+      {
+      UnknownRanges<SetView> x1u(x1);
+      Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+        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());
+
+        SetView candidate = iv[i].var;
+        int candidateInd = iv[i].idx;
+
+        GlbRanges<SetView> clb(candidate);
+        BndSetRanges uos(unionOfSelected);
+        Iter::Ranges::Inter<GlbRanges<SetView>, 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 ES_SUBSUMED;
+      }
+
+      {
+        // remove all elements in a selected variable from
+        // all other selected variables
+        GlbRanges<SetView> x1lb(x1);
+        Iter::Ranges::ToValues<GlbRanges<SetView> > vx1lb(x1lb);
+        int i=0;
+        for (; vx1lb(); ++vx1lb) {
+          while (iv[i].idx < vx1lb.val()) i++;
+          assert(iv[i].idx==vx1lb.val());
+          GlbRanges<SetView> x1lb2(x1);
+          Iter::Ranges::ToValues<GlbRanges<SetView> > 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<SetView> xilb(iv[i].var);
+              ModEvent me = iv[j].var.excludeI(home,xilb);
+              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<SetView> x1u(x1);
+        Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+        Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+          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<SetView> x1u2(x1);
+          Iter::Ranges::ToValues<UnknownRanges<SetView> > 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<SetView> xjlb(iv[j].var);
+              GlbRanges<SetView> xilb(iv[i].var);
+              Iter::Ranges::Inter<GlbRanges<SetView>, GlbRanges<SetView> >
+                inter(xjlb, xilb);
+              if (!inter()) {
+                flag = false;
+                goto here;
+              }
+            }
+          }
+        here:
+          if (flag) {
+            ModEvent me = x1.exclude(home,iv[i].idx);
+            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<SetView> x1u(x1);
+      Iter::Ranges::Cache<UnknownRanges<SetView> > x1uc(x1u);
+      Iter::Ranges::ToValues<Iter::Ranges::Cache<UnknownRanges<SetView> > >
+        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<SetView> x1u2(x1);
+        Iter::Ranges::ToValues<UnknownRanges<SetView> > 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<SetView> x1u3(x1);
+            Iter::Ranges::ToValues<UnknownRanges<SetView> > 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<SetView> xjlb(iv[j].var);
+                GlbRanges<SetView> xilb(iv[k].var);
+                Iter::Ranges::Inter<GlbRanges<SetView>, GlbRanges<SetView> >
+                  inter(xjlb, xilb);
+                if (!inter()) {
+                  flag = false;
+                  goto here2;
+                }
+              }
+            }
+          }
+        }
+      here2:
+        if (flag) {
+          ModEvent me = x1.include(home,iv[i].idx);
+          GECODE_ME_CHECK(me);
+          fix_flag=true;
+        }
+      }
+    } while(fix_flag);
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop