dep-selector-libgecode 1.0.0.alpha.0

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

@@ -0,0 +1,266 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  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.
+ *
+ */
+
+#include <gecode/set.hh>
+#include <gecode/set/rel.hh>
+#include <gecode/set/rel-op.hh>
+
+namespace Gecode { namespace Set { namespace RelOp {
+
+  template<class View0, class View1, class Res>
+  forceinline void
+  rel_eq(Home home, View0 x0, SetOpType op, View1 x1, Res x2) {
+    switch(op) {
+    case SOT_DUNION:
+      {
+        EmptyView emptyset;
+        GECODE_ES_FAIL((SuperOfInter<View0,View1,EmptyView>
+                             ::post(home, x0, x1, emptyset)));
+        // fall through to SOT_UNION
+      }
+    case SOT_UNION:
+      {
+        GECODE_ES_FAIL(
+                       (Union<View0,View1,Res>
+                        ::post(home, x0, x1, x2)));
+      }
+      break;
+    case SOT_INTER:
+      {
+        GECODE_ES_FAIL((Intersection<View0,View1,Res>
+                             ::post(home, x0,x1,x2)));
+      }
+      break;
+    case SOT_MINUS:
+      {
+        ComplementView<View1> cx1(x1);
+        GECODE_ES_FAIL(
+                       (Intersection<View0,
+                        ComplementView<View1>,Res>
+                        ::post(home,x0,cx1,x2)));
+      }
+      break;
+    }
+  }
+
+  template<class View0, class View1, class View2>
+  forceinline void
+  rel_sub(Home home, View0 x0, SetOpType op, View1 x1, View2 x2) {
+    switch(op) {
+    case SOT_DUNION:
+      {
+        EmptyView emptyset;
+        GECODE_ES_FAIL((SuperOfInter<View0,View1,EmptyView>
+                             ::post(home, x0, x1, emptyset)));
+        // fall through to SOT_UNION
+      }
+    case SOT_UNION:
+      {
+        SetVar tmp(home);
+        GECODE_ES_FAIL(
+                       (Rel::Subset<SetView,View2>::post(home,tmp,x2)));
+
+        GECODE_ES_FAIL(
+                       (Union<View0,View1,SetView>
+                        ::post(home, x0, x1, tmp)));
+      }
+      break;
+    case SOT_INTER:
+      {
+        GECODE_ES_FAIL((SuperOfInter<View0,View1,View2>
+                             ::post(home, x0,x1,x2)));
+      }
+      break;
+    case SOT_MINUS:
+      {
+        ComplementView<View1> cx1(x1);
+        GECODE_ES_FAIL(
+                       (SuperOfInter<View0,
+                        ComplementView<View1>,View2>
+                        ::post(home,x0,cx1,x2)));
+      }
+      break;
+    }
+
+  }
+
+  template<class View0, class View1, class View2>
+  forceinline void
+  rel_sup(Home home, View0 x0, SetOpType op, View1 x1, View2 x2) {
+    switch(op) {
+    case SOT_DUNION:
+      {
+        EmptyView emptyset;
+        GECODE_ES_FAIL((SuperOfInter<View0,View1,EmptyView>
+                             ::post(home, x0, x1, emptyset)));
+        // fall through to SOT_UNION
+      }
+    case SOT_UNION:
+      {
+        GECODE_ES_FAIL(
+                       (SubOfUnion<View0,View1,View2>
+                        ::post(home, x0, x1, x2)));
+      }
+      break;
+    case SOT_INTER:
+      {
+        SetVar tmp(home);
+        GECODE_ES_FAIL(
+                       (Rel::Subset<View2,SetView>::post(home,x2,tmp)));
+
+        GECODE_ES_FAIL((Intersection<View0,View1,SetView>
+                             ::post(home, x0,x1,tmp)));
+      }
+      break;
+    case SOT_MINUS:
+      {
+        SetVar tmp(home);
+        GECODE_ES_FAIL(
+                       (Rel::Subset<View2,SetView>::post(home,x2,tmp)));
+
+        ComplementView<View1> cx1(x1);
+        GECODE_ES_FAIL(
+                       (Intersection<View0,
+                        ComplementView<View1>,SetView>
+                        ::post(home,x0,cx1,tmp)));
+      }
+      break;
+    }
+
+  }
+
+  template<class View>
+  forceinline void
+  rel_op_post_lex(Home home, SetView x0, SetRelType r, View x1) {
+    switch (r) {
+    case SRT_LQ:
+      GECODE_ES_FAIL((Rel::Lq<SetView,View,false>::post(home,x0,x1)));
+      break;
+    case SRT_LE:
+      GECODE_ES_FAIL((Rel::Lq<SetView,View,true>::post(home,x0,x1)));
+      break;
+    case SRT_GQ:
+      GECODE_ES_FAIL((Rel::Lq<View,SetView,false>::post(home,x1,x0)));
+      break;
+    case SRT_GR:
+      GECODE_ES_FAIL((Rel::Lq<View,SetView,true>::post(home,x1,x0)));
+      break;
+    default:
+      throw UnknownRelation("Set::rel");
+    }
+  }
+
+  template<class View0, class View1, class View2>
+  forceinline void
+  rel_op_post_nocompl(Home home, View0 x, SetOpType op, View1 y,
+                      SetRelType r, View2 z) {
+    if (home.failed()) return;
+    switch(r) {
+    case SRT_EQ:
+      rel_eq<View0,View1,View2>(home, x, op, y, z);
+      break;
+    case SRT_LQ: case SRT_LE: case SRT_GQ: case SRT_GR:
+      {
+        SetVar tmp(home,IntSet::empty,Set::Limits::min,Set::Limits::max);
+        rel_eq<View0,View1,SetView>(home, x, op, y, tmp);
+        rel_op_post_lex<View2>(home,tmp,r,z);
+      }
+      break;
+    case SRT_NQ:
+      {
+        SetVar tmp(home);
+        GECODE_ES_FAIL(
+                       (Rel::Distinct<SetView,View2>
+                        ::post(home,tmp,z)));
+        rel_eq<View0,View1,SetView>(home, x, op, y, tmp);
+      }
+      break;
+    case SRT_SUB:
+      rel_sub<View0,View1,View2>(home, x, op, y, z);
+      break;
+    case SRT_SUP:
+      rel_sup<View0,View1,View2>(home, x, op, y, z);
+      break;
+    case SRT_DISJ:
+      {
+        SetVar tmp(home);
+        EmptyView emptyset;
+        GECODE_ES_FAIL((SuperOfInter<View2,SetView,EmptyView>
+                             ::post(home, z, tmp, emptyset)));
+        rel_eq<View0,View1,SetView>(home, x, op, y, tmp);
+      }
+      break;
+    default:
+      GECODE_NEVER;
+    }
+
+  }
+
+  GECODE_SET_EXPORT void
+  post_nocompl(Home home, SetView x, SetOpType op, SetView y,
+               SetRelType r, SetView z);
+  GECODE_SET_EXPORT void
+  post_nocompl(Home home, ConstSetView x, SetOpType op, SetView y,
+               SetRelType r, SetView z);
+
+  GECODE_SET_EXPORT void
+  post_nocompl(Home home, SetView x, SetOpType op, SetView y,
+               SetRelType r, ConstSetView z);
+
+  GECODE_SET_EXPORT void
+  post_nocompl(Home home, ConstSetView x, SetOpType op, SetView y,
+               SetRelType r, ConstSetView z);
+
+  GECODE_SET_EXPORT void
+  post_compl(Home home, SetView x, SetOpType op, SetView y, SetView z);
+
+  GECODE_SET_EXPORT void
+  post_compl(Home home, ConstSetView x, SetOpType op, SetView y, SetView z);
+
+  GECODE_SET_EXPORT void
+  post_compl(Home home, SetView x, SetOpType op, SetView y, ConstSetView z);
+
+  GECODE_SET_EXPORT void
+  post_compl(Home home, ConstSetView x, SetOpType op, SetView y,
+             ConstSetView z);
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,166 @@
+/* -*- 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-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 RelOp {
+
+  template<class View0, class View1, class View2>
+  Actor*
+  SubOfUnion<View0,View1,View2>::copy(Space& home, bool share) {
+    return new (home) SubOfUnion(home,share,*this);
+  }
+
+  template<class View0, class View1, class View2>
+  ExecStatus
+  SubOfUnion<View0,View1,View2>::propagate(Space& home, const ModEventDelta& med) {
+
+    bool allassigned = x0.assigned() && x1.assigned() && x2.assigned();
+
+    ModEvent me0 = View0::me(med);
+    ModEvent me1 = View1::me(med);
+    ModEvent me2 = View2::me(med);
+
+    bool modified=false;
+
+    do {
+      // lub(x2) <= lub(x0) u lub(x1)
+      if (modified || Rel::testSetEventUB(me0,me1))
+        {
+          LubRanges<View0> ub0(x0);
+          LubRanges<View1> ub1(x1);
+          Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u(ub0,ub1);
+          GECODE_ME_CHECK(x2.intersectI(home,u));
+        }
+
+      // x1 <= glb(x2)-lub(x0)
+      // x0 <= glb(x2)-lub(x1)
+      if (modified || Rel::testSetEventAnyB(me0,me1,me2)) {
+        {
+          modified = false;
+          GlbRanges<View2> lb2(x2);
+          LubRanges<View0> ub0(x0);
+          Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View0> >
+            diff(lb2,ub0);
+          GECODE_ME_CHECK_MODIFIED(modified, x1.includeI(home,diff));
+        }
+        {
+          GlbRanges<View2> lb2(x2);
+          LubRanges<View1> ub1(x1);
+          Iter::Ranges::Diff<GlbRanges<View2>, LubRanges<View1> >
+            diff(lb2,ub1);
+          GECODE_ME_CHECK_MODIFIED(modified, x0.includeI(home,diff));
+        }
+      } else {
+        modified = false;
+      }
+
+      // cardinality propagation
+      if (modified ||
+          Rel::testSetEventCard(me0,me1,me2) ||
+          Rel::testSetEventLB(me0,me1)
+          ) {
+        GlbRanges<View0> lb0c(x0);
+        GlbRanges<View1> lb1c(x1);
+        Iter::Ranges::Inter<GlbRanges<View0>, GlbRanges<View1> >
+          inter(lb0c,lb1c);
+
+        unsigned int m = Iter::Ranges::size(inter);
+
+        if (m < x0.cardMax()+x1.cardMax()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x2.cardMax( home,
+                                        x0.cardMax()+x1.cardMax() - m ) );
+        }
+        if (m + x2.cardMin() > x1.cardMax()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x0.cardMin( home,
+                                        m+x2.cardMin()-x1.cardMax() )  );
+        }
+        if (m + x2.cardMin() > x0.cardMax()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x1.cardMin( home,
+                                        m+x2.cardMin()-x0.cardMax() )  );
+        }
+      }
+
+    } while (modified);
+
+    if (shared(x0,x1,x2)) {
+      if (allassigned) {
+        return home.ES_SUBSUMED(*this);
+      } else {
+        return ES_NOFIX;
+      }
+    } else {
+      if (x0.assigned() + x1.assigned() + x2.assigned() >= 2) {
+         return home.ES_SUBSUMED(*this);
+      } else {
+        return ES_FIX;
+      }
+    }
+
+  }
+
+  template<class View0, class View1, class View2>
+  forceinline
+  SubOfUnion<View0,View1,View2>::SubOfUnion(Home home, View0 y0,
+                                         View1 y1, View2 y2)
+    : MixTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+                             View2,PC_SET_ANY>(home,y0,y1,y2) {}
+
+  template<class View0, class View1, class View2>
+  forceinline
+  SubOfUnion<View0,View1,View2>::SubOfUnion
+  (Space& home, bool share, SubOfUnion<View0,View1,View2>& p)
+    : MixTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+                             View2,PC_SET_ANY>(home,share,p) {}
+
+  template<class View0, class View1, class View2>
+  ExecStatus SubOfUnion<View0,View1,View2>::post
+  (Home home, View0 x0, View1 x1, View2 x2) {
+    (void) new (home) SubOfUnion<View0,View1,View2>(home,x0, x1, x2);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,167 @@
+/* -*- 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-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 RelOp {
+
+  template<class View0, class View1, class View2>
+  forceinline
+  SuperOfInter<View0,View1,View2>::SuperOfInter
+  (Home home, View0 y0, View1 y1, View2 y2)
+    : MixTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+                             View2,PC_SET_CLUB>(home,y0,y1,y2) {}
+
+  template<class View0, class View1, class View2>
+  forceinline
+  SuperOfInter<View0,View1,View2>::SuperOfInter
+  (Space& home, bool share, SuperOfInter<View0,View1,View2>& p)
+    : MixTernaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY,
+                             View2,PC_SET_CLUB>(home,share,p) {}
+
+  template<class View0, class View1, class View2>
+  ExecStatus
+  SuperOfInter<View0,View1,View2>::post(Home home,
+                                        View0 x0, View1 x1, View2 x2) {
+    (void) new (home) SuperOfInter<View0,View1,View2>(home, x0, x1, x2);
+    return ES_OK;
+  }
+
+  template<class View0, class View1, class View2>
+  Actor*
+  SuperOfInter<View0,View1,View2>::copy(Space& home, bool share) {
+    return new (home) SuperOfInter(home,share,*this);
+  }
+
+  template<class View0, class View1, class View2>
+  ExecStatus
+  SuperOfInter<View0,View1,View2>::propagate(Space& home, const ModEventDelta& med) {
+
+    bool allassigned = x0.assigned() && x1.assigned() && x2.assigned();
+
+    ModEvent me0 = View0::me(med);
+    ModEvent me1 = View1::me(med);
+    ModEvent me2 = View2::me(med);
+
+    bool modified = false;
+
+    do {
+      // glb(x2) >= glb(x0) ^ glb(x1)
+      if ( modified || Rel::testSetEventLB(me0,me1)) {
+        GlbRanges<View0> lb0(x0);
+        GlbRanges<View1> lb1(x1);
+        Iter::Ranges::Inter<GlbRanges<View0>,GlbRanges<View1> >
+          is(lb0, lb1);
+
+        GECODE_ME_CHECK_MODIFIED(modified,x2.includeI(home,is));
+      }
+
+      // lub(x0) -= glb(x1)-lub(x2)
+      // lub(x1) -= glb(x0)-lub(x2)
+      if ( modified || Rel::testSetEventAnyB(me0,me1,me2)) {
+         modified = false;
+        GlbRanges<View1> lb12(x1);
+        LubRanges<View2> ub22(x2);
+        Iter::Ranges::Diff<GlbRanges<View1>, LubRanges<View2> >
+          diff1(lb12, ub22);
+
+        GECODE_ME_CHECK_MODIFIED(modified, x0.excludeI(home,diff1));
+
+        GlbRanges<View0> lb01(x0);
+        LubRanges<View2> ub23(x2);
+        Iter::Ranges::Diff<GlbRanges<View0>, LubRanges<View2> >
+          diff2(lb01, ub23);
+
+        GECODE_ME_CHECK_MODIFIED(modified, x1.excludeI(home,diff2));
+      } else {
+         modified = false;
+      }
+
+      // Cardinality propagation
+      if ( modified ||
+            Rel::testSetEventCard(me0,me1,me2) ||
+           Rel::testSetEventUB(me0,me1)
+           ) {
+
+        LubRanges<View0> ub0(x0);
+        LubRanges<View1> ub1(x1);
+        Iter::Ranges::Union<LubRanges<View0>, LubRanges<View1> > u(ub0,ub1);
+
+        unsigned int m = Iter::Ranges::size(u);
+
+        if (m < x0.cardMin() + x1.cardMin()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x2.cardMin( home,
+                                        x0.cardMin()+x1.cardMin() - m ) );
+        }
+        if (m + x2.cardMax() > x1.cardMin()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x0.cardMax( home,
+                                        m+x2.cardMax()-x1.cardMin() )  );
+        }
+        if (m + x2.cardMax() > x0.cardMin()) {
+          GECODE_ME_CHECK_MODIFIED(modified,
+                            x1.cardMax( home,
+                                        m+x2.cardMax()-x0.cardMin() )  );
+        }
+      }
+    } while (modified);
+
+
+    if (shared(x0,x1,x2)) {
+      if (allassigned) {
+        return home.ES_SUBSUMED(*this);
+      } else {
+        return ES_NOFIX;
+      }
+    } else {
+      if (x0.assigned() + x1.assigned() + x2.assigned() >= 2) {
+         return home.ES_SUBSUMED(*this);
+      } else {
+        return ES_FIX;
+      }
+    }
+
+  }
+
+}}}
+
+// STATISTICS: set-prop