dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/nvalues/range-event.hpp

@@ -0,0 +1,51 @@
+/* -*- 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-08-12 21:48:55 +1000 (Fri, 12 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12283 $
+ *
+ *  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 NValues {
+
+  forceinline bool
+  RangeEvent::operator <(RangeEvent re) const {
+    if (val < re.val)
+      return true;
+    if (val == re.val)
+      return ret < re.ret;
+    return false;
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/nvalues/sym-bit-matrix.hpp

@@ -0,0 +1,69 @@
+/* -*- 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-08-18 17:41:50 +1000 (Thu, 18 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12311 $
+ *
+ *  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 <algorithm>
+
+namespace Gecode { namespace Int { namespace NValues {
+
+  forceinline int
+  SymBitMatrix::pos(int x, int y) const {
+    assert(x < y);
+    return (x*(2*n-x-1)) / 2 + y - x - 1;
+  }
+
+  forceinline
+  SymBitMatrix::SymBitMatrix(Region& r, int n0)
+    : Support::BitSet<Region>(r,static_cast<unsigned int>((n0*n0-n0)/2)),
+      n(n0) {}
+
+  forceinline bool 
+  SymBitMatrix::get(int x, int y) const {
+    assert(x != y);
+    if (x > y) std::swap(x,y);
+    return Support::BitSet<Region>::get(static_cast<unsigned int>(pos(x,y)));
+  }
+
+  forceinline void
+  SymBitMatrix::set(int x, int y) {
+    assert(x != y);
+    if (x > y) std::swap(x,y);
+    Support::BitSet<Region>::set(static_cast<unsigned int>(pos(x,y)));
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/precede.cpp

@@ -0,0 +1,73 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christopher Mears <Chris.Mears@monash.edu>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christopher Mears, 2011
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-01 00:20:54 +1000 (Fri, 01 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12138 $
+ *
+ *  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/int/precede.hh>
+
+namespace Gecode {
+
+  void
+  precede(Home home, const IntVarArgs& x, int s, int t, IntConLevel) {
+    using namespace Int;
+    Limits::check(s,"Int::precede");
+    Limits::check(t,"Int::precede");
+    if (home.failed()) return;
+
+    ViewArray<IntView> y(home, x);
+    GECODE_ES_FAIL(Precede::Single<IntView>::post(home, y, s, t));
+  }
+
+  void
+  precede(Home home, const IntVarArgs& x, const IntArgs& c, IntConLevel) {
+    using namespace Int;
+    for (int i=c.size(); i--; )
+      Limits::check(c[i],"Int::precede");
+    if (home.failed()) return;
+
+    for (int i=c.size()-1; i--; ) {
+      ViewArray<IntView> y(home, x);
+      GECODE_ES_FAIL(Precede::Single<IntView>::post(home, y, c[i], c[i+1]));
+    }
+  }
+
+}
+
+// STATISTICS: int-post
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/precede.hh

@@ -0,0 +1,113 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christopher Mears <Chris.Mears@monash.edu>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christopher Mears, 2011
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-01 00:20:54 +1000 (Fri, 01 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12138 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_PRECEDE_HH__
+#define __GECODE_INT_PRECEDE_HH__
+
+#include <gecode/int.hh>
+
+/**
+ * \namespace Gecode::Int::Precede
+ * \brief Value precedence propagators
+ */
+
+namespace Gecode { namespace Int { namespace Precede {
+    
+  /**
+   * \brief Single value precedence propagator
+   *
+   * The propagator is based on: Yat Chiu Law and Jimmy H.M. Lee,
+   * Global Constraints for Integer and Set Value Precedence,
+   * CP 2004, 362--376.
+   *
+   * Requires \code #include <gecode/int/precede.hh> \endcode
+   * \ingroup FuncIntProp
+   */
+  template<class View>
+  class Single : public NaryPropagator<View,PC_INT_NONE> {
+  protected:
+    using NaryPropagator<View,PC_INT_NONE>::x;
+    /// %Advisors for views (by position in array)
+    class Index : public Advisor {
+    public:
+      /// The position of the view in the view array
+      int i;
+      /// Create index advisor
+      Index(Space& home, Propagator& p, Council<Index>& c, int i);
+      /// Clone index advisor \a a
+      Index(Space& home, bool share, Index& a);
+    };
+    /// The advisor council
+    Council<Index> c;
+    /// The value \a s must precede \a t
+    int s, t;
+    /// Pointers updated during propagation
+    int alpha, beta, gamma;
+    /// Update the alpha pointer
+    ExecStatus updateAlpha(Space& home);
+    /// Update the beta pointer
+    ExecStatus updateBeta(Space& home);
+    /// Constructor for posting
+    Single(Home home, ViewArray<View>& x, int s, int t, int beta, int gamma);
+    /// Constructor for cloning \a p
+    Single(Space& home, bool share, Single<View>& p);
+  public:
+    /// Copy propagator during cloning
+    virtual Propagator* copy(Space& home, bool share);
+    /// Cost function
+    virtual PropCost cost(const Space&, const ModEventDelta&) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+    /// Give advice to propagator
+    virtual ExecStatus advise(Space& home, Advisor& a, const Delta& d);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator that \a s precedes \a t in \a x
+    static ExecStatus post(Home home, ViewArray<View>& x, int s, int t);
+  };
+
+}}}
+
+#include <gecode/int/precede/single.hpp>
+
+#endif
+
+// STATISTICS: int-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/precede/single.hpp

@@ -0,0 +1,232 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christopher Mears <Chris.Mears@monash.edu>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christopher Mears, 2011
+ *     Christian Schulte, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-07-01 00:20:54 +1000 (Fri, 01 Jul 2011) $ by $Author: schulte $
+ *     $Revision: 12138 $
+ *
+ *  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 Precede {
+
+  /// Whether \a x is assigned to value \a v
+  template<class View>
+  forceinline bool
+  assigned(View x, int v) {
+    return x.assigned() && (x.val() == v);
+  }
+    
+  template<class View>
+  forceinline
+  Single<View>::Index::Index(Space& home, Propagator& p,
+                             Council<Index>& c, int i0)
+    : Advisor(home,p,c), i(i0) {}
+
+  template<class View>
+  forceinline
+  Single<View>::Index::Index(Space& home, bool share, Index& a)
+    : Advisor(home,share,a), i(a.i) {}
+
+  
+  template<class View>
+  forceinline ExecStatus 
+  Single<View>::updateAlpha(Space& home) {
+    int n = x.size();
+    while ((alpha < n) && !x[alpha].in(s))
+      GECODE_ME_CHECK(x[alpha++].nq(home, t));
+    if (alpha < n)
+      GECODE_ME_CHECK(x[alpha].nq(home, t));
+    return ES_OK;
+  }
+
+  template<class View>
+  forceinline ExecStatus
+  Single<View>::updateBeta(Space& home) {
+    int n = x.size();
+    do {
+      beta++;
+    } while ((beta < n) && !x[beta].in(s));
+    if (beta > gamma)
+      GECODE_ME_CHECK(x[alpha].eq(home, s));
+    return ES_OK;
+  }
+  
+  template<class View>
+  forceinline
+  Single<View>::Single(Home home, ViewArray<View>& x0, 
+                       int s0, int t0, int b, int g)
+    : NaryPropagator<View, PC_INT_NONE>(home,x0), 
+      c(home), s(s0), t(t0), alpha(0), beta(b), gamma(g) {
+    for (int i=x.size(); i--; )
+      if (!x[i].assigned())
+        x[i].subscribe(home,*new (home) Index(home,*this,c,i));
+    View::schedule(home, *this, ME_INT_BND);
+  }
+
+  template<class View>
+  inline ExecStatus
+  Single<View>::post(Home home, ViewArray<View>& x, int s, int t) {
+    {
+      int alpha = 0;
+      while ((alpha < x.size()) && !x[alpha].in(s))
+        GECODE_ME_CHECK(x[alpha++].nq(home,t));
+      x.drop_fst(alpha);
+      if (x.size() == 0)
+        return ES_OK;
+    }
+    // alpha has been normalized to 0
+    int beta = 0, gamma = 0;
+    GECODE_ME_CHECK(x[0].nq(home,t));
+    do {
+      gamma++;
+    } while ((gamma < x.size()) && !assigned(x[gamma],t));
+    do {
+      beta++;
+    } while ((beta < x.size()) && !x[beta].in(s));
+    if (beta > gamma) {
+      GECODE_ME_CHECK(x[0].eq(home, s));
+      return ES_OK;
+    }
+    if (gamma < x.size())
+      x.drop_lst(gamma);
+    (void) new (home) Single<View>(home, x, s, t, beta, gamma);
+    return ES_OK;
+  }
+    
+
+
+  template<class View>
+  forceinline
+  Single<View>::Single(Space& home, bool share, Single& p)
+    : NaryPropagator<View,PC_INT_NONE>(home, share, p),
+      s(p.s), t(p.t),
+      alpha(p.alpha), beta(p.beta), gamma(p.gamma) {
+    c.update(home, share, p.c);
+  }
+  template<class View>
+  Propagator*
+  Single<View>::copy(Space& home, bool share) {
+    // Try to eliminate assigned views at the beginning
+    if (alpha > 0) {
+      int i = 0;
+      while ((i < alpha) && x[i].assigned())
+        i++;
+      x.drop_fst(i);
+      for (Advisors<Index> as(c); as(); ++as)
+        as.advisor().i -= i;
+      alpha -= i; beta -= i; gamma -= i;
+    }
+    // Try to eliminate assigned views at the end
+    if (gamma < x.size()) {
+      int i = x.size()-1;
+      while ((i > gamma) && x[i].assigned())
+        i--;
+      x.drop_lst(i);
+    }
+    return new (home) Single<View>(home, share, *this);
+  }
+
+
+  template<class View>
+  inline size_t
+  Single<View>::dispose(Space& home) {
+    // Cancel remaining advisors
+    for (Advisors<Index> as(c); as(); ++as)
+      x[as.advisor().i].cancel(home,as.advisor());
+    c.dispose(home);
+    (void) NaryPropagator<View,PC_INT_NONE>::dispose(home);
+    return sizeof(*this);
+  }
+
+  template<class View>
+  PropCost 
+  Single<View>::cost(const Space&, const ModEventDelta&) const {
+    return PropCost::linear(PropCost::LO, x.size());
+  }
+
+  template<class View>
+  ExecStatus
+  Single<View>::advise(Space& home, Advisor& a0, const Delta& d) {
+    Index& a(static_cast<Index&>(a0));
+    int i = a.i;
+    // Check for gamma
+    if ((beta <= gamma) && (i < gamma) && assigned(x[i],t))
+      gamma = i;
+    if (x[i].assigned()) {
+      a.dispose(home,c);
+      if (c.empty())
+        return ES_NOFIX;
+    } else if ((i < alpha) || (i > gamma)) {
+      x[i].cancel(home,a);
+      a.dispose(home,c);
+      return (c.empty()) ? ES_NOFIX : ES_FIX;
+    }
+    if (beta > gamma)
+      return ES_NOFIX;
+    if ((alpha == i) || (beta == i)) {
+      if (x[i].any(d) && !x[i].in(s))
+        return ES_NOFIX;
+      if ((x[i].min(d) <= s) && (s <= x[i].max(d)))
+        return ES_NOFIX;
+    }
+    return ES_FIX;
+  }
+  
+  template<class View>
+  ExecStatus
+  Single<View>::propagate(Space& home, const ModEventDelta&) {
+    int n = x.size();
+    if (beta > gamma) {
+      GECODE_ME_CHECK(x[alpha].eq(home, s));
+      return home.ES_SUBSUMED(*this);
+    }
+    if ((alpha < n) && !x[alpha].in(s)) {
+      alpha++;
+      while (alpha < beta)
+        GECODE_ME_CHECK(x[alpha++].nq(home, t));
+      GECODE_ES_CHECK(updateAlpha(home));
+      beta = alpha;
+      if (alpha < n)
+        GECODE_ES_CHECK(updateBeta(home));
+    } else if ((beta < n) && !x[beta].in(s)) {
+      GECODE_ES_CHECK(updateBeta(home));
+    }
+    
+    return (c.empty()) ? home.ES_SUBSUMED(*this) : ES_FIX;
+  }
+  
+}}}
+
+// STATISTICS: int-prop