dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/no-overlap/base.hpp

@@ -0,0 +1,88 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-09 00:08:27 +1000 (Sat, 09 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12168 $
+ *
+ *  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 Int { namespace NoOverlap {
+
+  template<class Box>
+  forceinline
+  Base<Box>::Base(Home home, Box* b0, int n0)
+    : Propagator(home), b(b0), n(n0) {
+    for (int i=n; i--; )
+      b[i].subscribe(home,*this);
+  }
+
+  template<class Box>
+  forceinline int
+  Base<Box>::partition(Box* b, int i, int n) {
+    int j = n-1;
+    while (true) {
+      while (!b[j].mandatory() && (--j >= 0)) {}
+      while (b[i].mandatory() && (++i < n)) {}
+      if (j <= i) break;
+      std::swap(b[i],b[j]);
+    }
+    return i;
+  }
+
+  template<class Box>
+  forceinline size_t 
+  Base<Box>::dispose(Space& home) {
+    for (int i=n; i--; )
+      b[i].cancel(home,*this);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+
+  template<class Box>
+  forceinline
+  Base<Box>::Base(Space& home, bool shared, Base<Box>& p, int m) 
+    : Propagator(home,shared,p), b(home.alloc<Box>(m)), n(p.n) {
+    for (int i=m; i--; )
+      b[i].update(home,shared,p.b[i]);
+  }
+
+  template<class Box>
+  PropCost 
+  Base<Box>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::quadratic(PropCost::HI,Box::dim()*n);
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/no-overlap/box.hpp

@@ -0,0 +1,198 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-14 02:16:57 +1000 (Thu, 14 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12192 $
+ *
+ *  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 Int { namespace NoOverlap {
+
+  /*
+   * Mandatory boxes
+   *
+   */
+  template<class Dim, int n>
+  forceinline const Dim&
+  ManBox<Dim,n>::operator [](int i) const {
+    assert((i >= 0) && (i < n));
+    return d[i];
+  }
+  template<class Dim, int n>
+  forceinline Dim&
+  ManBox<Dim,n>::operator [](int i) {
+    assert((i >= 0) && (i < n));
+    return d[i];
+  }
+  template<class Dim, int n>
+  forceinline int
+  ManBox<Dim,n>::dim(void) {
+    return n;
+  }
+
+  template<class Dim, int n>
+  forceinline bool
+  ManBox<Dim,n>::mandatory(void) const {
+    return true;
+  }
+  template<class Dim, int n>
+  forceinline bool
+  ManBox<Dim,n>::excluded(void) const {
+    return false;
+  }
+  template<class Dim, int n>
+  forceinline bool
+  ManBox<Dim,n>::optional(void) const {
+    return false;
+  }
+
+  template<class Dim, int n>
+  forceinline ExecStatus
+  ManBox<Dim,n>::exclude(Space&) {
+    return ES_FAILED;
+  }
+
+  template<class Dim, int n>
+  forceinline bool
+  ManBox<Dim,n>::nooverlap(const ManBox<Dim,n>& box) const {
+    for (int i=0; i<n; i++)
+      if ((d[i].lec() <= box.d[i].ssc()) || (box.d[i].lec() <= d[i].ssc()))
+        return true;
+    return false;
+  }
+
+  template<class Dim, int n>
+  forceinline bool
+  ManBox<Dim,n>::overlap(const ManBox<Dim,n>& box) const {
+    for (int i=0; i<n; i++)
+      if ((d[i].sec() <= box.d[i].lsc()) || (box.d[i].sec() <= d[i].lsc()))
+        return false;
+    return true;
+  }
+
+  template<class Dim, int n>
+  forceinline ExecStatus
+  ManBox<Dim,n>::nooverlap(Space& home, ManBox<Dim,n>& box) {
+    for (int i=0; i<n; i++)
+      if ((d[i].sec() <= box.d[i].lsc()) || 
+          (box.d[i].sec() <= d[i].lsc())) {
+        // Does not overlap for dimension i
+        for (int j=i+1; j<n; j++)
+          if ((d[j].sec() <= box.d[j].lsc()) || 
+              (box.d[j].sec() <= d[j].lsc()))
+            return ES_OK;
+        // Does not overlap for only dimension i, hence propagate
+        d[i].nooverlap(home, box.d[i]);
+        box.d[i].nooverlap(home, d[i]);
+        return ES_OK;
+      }
+    // Overlaps in all dimensions
+    return ES_FAILED;
+  }
+
+  template<class Dim, int n>
+  forceinline void
+  ManBox<Dim,n>::update(Space& home, bool share, ManBox<Dim,n>& b) {
+    for (int i=0; i<n; i++)
+      d[i].update(home,share,b.d[i]);
+  }
+
+  template<class Dim, int n>
+  forceinline void
+  ManBox<Dim,n>::subscribe(Space& home, Propagator& p) {
+    for (int i=0; i<n; i++)
+      d[i].subscribe(home,p);
+  }
+  template<class Dim, int n>
+  forceinline void
+  ManBox<Dim,n>::cancel(Space& home, Propagator& p) {
+    for (int i=0; i<n; i++)
+      d[i].cancel(home,p);
+  }
+
+
+  /*
+   * Optional boxes
+   *
+   */
+  template<class Dim, int n>
+  forceinline void
+  OptBox<Dim,n>::optional(BoolView o0) {
+    o = o0;
+  }
+  template<class Dim, int n>
+  forceinline bool
+  OptBox<Dim,n>::mandatory(void) const {
+    return o.one();
+  }
+  template<class Dim, int n>
+  forceinline bool
+  OptBox<Dim,n>::excluded(void) const {
+    return o.zero();
+  }
+  template<class Dim, int n>
+  forceinline bool
+  OptBox<Dim,n>::optional(void) const {
+    return o.none();
+  }
+
+  template<class Dim, int n>
+  forceinline ExecStatus
+  OptBox<Dim,n>::exclude(Space& home) {
+    GECODE_ME_CHECK(o.zero(home));
+    return ES_OK;
+  }
+
+  template<class Dim, int n>
+  forceinline void
+  OptBox<Dim,n>::update(Space& home, bool share, OptBox<Dim,n>& b) {
+    ManBox<Dim,n>::update(home, share, b);
+    o.update(home, share, b.o);
+  }
+
+  template<class Dim, int n>
+  forceinline void
+  OptBox<Dim,n>::subscribe(Space& home, Propagator& p) {
+    ManBox<Dim,n>::subscribe(home,p);
+    o.subscribe(home, p, PC_BOOL_VAL);
+  }
+  template<class Dim, int n>
+  forceinline void
+  OptBox<Dim,n>::cancel(Space& home, Propagator& p) {
+    ManBox<Dim,n>::cancel(home,p);
+    o.cancel(home, p, PC_BOOL_VAL);
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/no-overlap/dim.hpp

@@ -0,0 +1,197 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-14 02:55:08 +1000 (Thu, 14 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12194 $
+ *
+ *  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 Int { namespace NoOverlap {
+
+  /*
+   * Dimension with integer size
+   *
+   */
+  forceinline
+  FixDim::FixDim(void) 
+    : s(0) {}
+  forceinline
+  FixDim::FixDim(IntView c0, int s0)
+    : c(c0), s(s0) {}
+
+  forceinline int 
+  FixDim::ssc(void) const {
+    return c.min();
+  }
+  forceinline int 
+  FixDim::lsc(void) const {
+    return c.max();
+  }
+  forceinline int 
+  FixDim::sec(void) const {
+    return c.min() + s;
+  }
+  forceinline int 
+  FixDim::lec(void) const {
+    return c.max() + s;
+  }
+
+  forceinline ExecStatus
+  FixDim::ssc(Space& home, int n) {
+    GECODE_ME_CHECK(c.gq(home, n));
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FixDim::lec(Space& home, int n) {
+    GECODE_ME_CHECK(c.lq(home, n - s));
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FixDim::nooverlap(Space& home, int n, int m) {
+    if (n <= m) {
+      Iter::Ranges::Singleton r(n-s+1,m);
+      GECODE_ME_CHECK(c.minus_r(home,r,false));
+    }
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FixDim::nooverlap(Space& home, FixDim& d) {
+    if (d.sec() > lsc()) {
+      // Propagate that d must be after this
+      GECODE_ES_CHECK(lec(home,d.lsc()));
+      GECODE_ES_CHECK(d.ssc(home,sec()));
+    } else {
+      nooverlap(home, d.lsc(), d.sec()-1);
+    }
+    return ES_OK;
+  }
+
+  forceinline void
+  FixDim::update(Space& home, bool share, FixDim& d) {
+    c.update(home,share,d.c);
+    s = d.s;
+  }
+
+  forceinline void
+  FixDim::subscribe(Space& home, Propagator& p) {
+    c.subscribe(home,p,PC_INT_DOM);
+  }
+  forceinline void
+  FixDim::cancel(Space& home, Propagator& p) {
+    c.cancel(home,p,PC_INT_DOM);
+  }
+
+
+  /*
+   * Dimension with integer view size
+   *
+   */
+  forceinline
+  FlexDim::FlexDim(void) {}
+  forceinline
+  FlexDim::FlexDim(IntView c00, IntView s0, IntView c10)
+    : c0(c00), s(s0), c1(c10) {}
+
+  forceinline int 
+  FlexDim::ssc(void) const {
+    return c0.min();
+  }
+  forceinline int 
+  FlexDim::lsc(void) const {
+    return c0.max();
+  }
+  forceinline int 
+  FlexDim::sec(void) const {
+    return c1.min();
+  }
+  forceinline int 
+  FlexDim::lec(void) const {
+    return c1.max();
+  }
+
+  forceinline ExecStatus
+  FlexDim::ssc(Space& home, int n) {
+    GECODE_ME_CHECK(c0.gq(home, n));
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FlexDim::lec(Space& home, int n) {
+    GECODE_ME_CHECK(c1.lq(home, n));
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FlexDim::nooverlap(Space& home, int n, int m) {
+    if (n <= m) {
+      Iter::Ranges::Singleton r0(n-s.min()+1,m);
+      GECODE_ME_CHECK(c0.minus_r(home,r0,false));
+      Iter::Ranges::Singleton r1(n+1,s.min()+m);
+      GECODE_ME_CHECK(c1.minus_r(home,r1,false));
+    }
+    return ES_OK;
+  }
+  forceinline ExecStatus
+  FlexDim::nooverlap(Space& home, FlexDim& d) {
+    if (d.sec() > lsc()) {
+      // Propagate that d must be after this
+      GECODE_ES_CHECK(lec(home,d.lsc()));
+      GECODE_ES_CHECK(d.ssc(home,sec()));
+    } else {
+      nooverlap(home, d.lsc(), d.sec()-1);
+    }
+    return ES_OK;
+  }
+
+
+  forceinline void
+  FlexDim::update(Space& home, bool share, FlexDim& d) {
+    c0.update(home,share,d.c0);
+    s.update(home,share,d.s);
+    c1.update(home,share,d.c1);
+  }
+
+  forceinline void
+  FlexDim::subscribe(Space& home, Propagator& p) {
+    c0.subscribe(home,p,PC_INT_DOM);
+    s.subscribe(home,p,PC_INT_BND);
+    c1.subscribe(home,p,PC_INT_DOM);
+  }
+  forceinline void
+  FlexDim::cancel(Space& home, Propagator& p) {
+    c0.cancel(home,p,PC_INT_DOM);
+    s.cancel(home,p,PC_INT_BND);
+    c1.cancel(home,p,PC_INT_DOM);
+  }
+
+}}}
+
+// STATISTICS: int-prop
+