gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,128 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  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: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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 {
+
+  /*
+   * "No Subset" propagator
+   *
+   */
+
+  template <class View0, class View1>
+  forceinline
+  NoSubSet<View0,View1>::NoSubSet(Space* home, View0 y0, View1 y1)
+    : MixBinaryPropagator<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)
+    : MixBinaryPropagator<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>
+  Support::Symbol
+  NoSubSet<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::NoSubSet");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  NoSubSet<View0,View1>::spec(const Space* home,
+                              Reflection::VarMap& m) const {
+    return MixBinaryPropagator<View0,PC_SET_CLUB,View1,PC_SET_CGLB>
+      ::spec(home, m, ati());
+  }
+
+  template <class View0, class View1>
+  void
+  NoSubSet<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                              const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    (void) new (home) NoSubSet(home,x0,x1);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  NoSubSet<View0,View1>::propagate(Space* home, ModEventDelta) {
+    GlbRanges<View0> x0lb(x0);
+    LubRanges<View1> x1ub(x1);
+    if (!Iter::Ranges::subset(x0lb, x1ub))
+      return ES_SUBSUMED(this,home);
+    if (x0.cardMin()>x1.cardMax()) { return ES_SUBSUMED(this,home); }
+    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(this,home);
+    }
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,208 @@
+/* -*- 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: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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(Space* 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(Space* home, View0 x, View1 y) {
+    if (x.assigned()) {
+      GlbRanges<View0> xr(x);
+      IntSet xs(xr);
+      ConstantView cv(home, xs);
+      GECODE_ES_CHECK((DistinctDoit<View1>::post(home,y,cv)));
+    }
+    if (y.assigned()) {
+      GlbRanges<View1> yr(y);
+      IntSet ys(yr);
+      ConstantView 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>
+  Support::Symbol
+  Distinct<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::Distinct");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  Distinct<View0,View1>::spec(const Space* home,
+                              Reflection::VarMap& m) const {
+    return MixBinaryPropagator<View0, PC_SET_VAL, View1, PC_SET_VAL>
+      ::spec(home, m, ati());
+  }
+
+  template <class View0, class View1>
+  void
+  Distinct<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                              const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    (void) new (home) Distinct(home,x0,x1);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  Distinct<View0,View1>::propagate(Space* home, ModEventDelta) {
+    assert(x0.assigned()||x1.assigned());
+    if (x0.assigned()) {
+      GlbRanges<View0> xr(x0);
+      IntSet xs(xr);
+      ConstantView cv(home, xs);
+      GECODE_REWRITE(this,(DistinctDoit<View1>::post(home,x1,cv)));
+    } else {
+      GlbRanges<View1> yr(x1);
+      IntSet ys(yr);
+      ConstantView cv(home, ys);
+      GECODE_REWRITE(this,(DistinctDoit<View0>::post(home,x0,cv)));
+    }
+  }
+
+  template <class View0>
+  ExecStatus
+  DistinctDoit<View0>::post(Space* home, View0 x, ConstantView 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>
+  Support::Symbol
+  DistinctDoit<View0>::ati(void) {
+    return Reflection::mangle<View0>("Gecode::Set::Rel::DistinctDoit");
+  }
+
+  template <class View0>
+  Reflection::ActorSpec
+  DistinctDoit<View0>::spec(const Space* home, Reflection::VarMap& m) const {
+    Reflection::ActorSpec s =
+      UnaryPropagator<View0,PC_SET_ANY>::spec(home, m, ati());
+    return s << y.spec(home, m);
+  }
+
+  template <class View0>
+  void
+  DistinctDoit<View0>::post(Space* home, Reflection::VarMap& vars,
+                            const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    View0 x0(home, vars, spec[0]);
+    ConstantView x1(home, vars, spec[1]);
+    (void) new (home) DistinctDoit(home,x0,x1);
+  }
+
+  template <class View0>
+  ExecStatus
+  DistinctDoit<View0>::propagate(Space* home, ModEventDelta) {
+    if (x0.assigned()) {
+      GlbRanges<View0> xi(x0);
+      GlbRanges<ConstantView> yi(y);
+      if (Iter::Ranges::equal(xi,yi)) { return ES_FAILED; }
+      else { return ES_SUBSUMED(this,home); }
+    }
+    assert(x0.lubSize()-x0.glbSize() >0);
+    if (x0.cardMin()>y.cardMax()) { return ES_SUBSUMED(this,home); }
+    if (x0.cardMax()<y.cardMin()) { return ES_SUBSUMED(this,home); }
+    //These tests are too expensive, we should only do them
+    //in the 1 unknown left case.
+    GlbRanges<View0> xi1(x0);
+    LubRanges<ConstantView> yi1(y);
+    if (!Iter::Ranges::subset(xi1,yi1)){ return ES_SUBSUMED(this,home); }
+    LubRanges<View0> xi2(x0);
+    GlbRanges<ConstantView> yi2(y);
+    if (!Iter::Ranges::subset(yi2,xi2)){ return ES_SUBSUMED(this,home); }
+    // 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(this,home);
+    }
+    if (x0.glbSize() == y.cardMin()) {
+      GECODE_ME_CHECK(x0.cardMin(home, x0.glbSize() + 1));
+      return ES_SUBSUMED(this,home);
+    }
+    return ES_FIX;
+  }
+
+  template <class View0>
+  forceinline
+  DistinctDoit<View0>::DistinctDoit(Space* home, View0 _x, ConstantView _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/gecode-2.1.1/gecode/set/rel/re-eq.icc

@@ -0,0 +1,179 @@
+/* -*- 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: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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(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(ModEventDelta) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View0, class View1>
+  Support::Symbol
+  ReEq<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::ReEq");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  ReEq<View0,View1>::spec(const Space* home, Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x0.spec(home, m)
+             << x1.spec(home, m)
+             << b.spec(home, m);
+  }
+
+  template <class View0, class View1>
+  void
+  ReEq<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                          const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    Gecode::Int::BoolView b(home, vars, spec[2]);
+    (void) new (home) ReEq(home,x0,x1,b);
+  }
+
+  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, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(Eq<View0,View1>::post(home,x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(this,(Distinct<View0,View1>::post(home,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 ES_SUBSUMED(this,home);
+        }
+      }
+      if (!x0lb() && !x1lb()) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return ES_SUBSUMED(this,home);
+      } else {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+
+    // check whether cardinalities still allow equality
+    if (x0.cardMin() > x1.cardMax() ||
+        x1.cardMin() > x0.cardMax()) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return ES_SUBSUMED(this,home);
+    }
+
+    // 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 ES_SUBSUMED(this,home);
+    }
+
+    // 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 ES_SUBSUMED(this,home);
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop