dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/gcc/val.hpp

@@ -0,0 +1,299 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2005
+ *     Christian Schulte, 2009
+ *     Guido Tack, 2009
+ *
+ *  Last modified:
+ *     $Date: 2010-07-15 01:46:18 +1000 (Thu, 15 Jul 2010) $ by $Author: schulte $
+ *     $Revision: 11192 $
+ *
+ *  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 GCC {
+
+  template<class Card>
+  forceinline
+  Val<Card>::Val(Home home, 
+                 ViewArray<IntView>& x0, ViewArray<Card>& k0)
+    : Propagator(home), x(x0), k(k0){
+    x.subscribe(home, *this, PC_INT_VAL);
+    k.subscribe(home, *this, PC_INT_VAL);
+  }
+
+  template<class Card>
+  forceinline
+  Val<Card>::Val(Space& home, bool share, Val<Card>& p)
+    : Propagator(home,share,p) {
+    x.update(home,share, p.x);
+    k.update(home,share, p.k);
+  }
+
+  template<class Card>
+  forceinline size_t
+  Val<Card>::dispose(Space& home) {
+    x.cancel(home,*this, PC_INT_VAL);
+    k.cancel(home,*this, PC_INT_VAL);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template<class Card>
+  Actor*
+  Val<Card>::copy(Space& home, bool share) {
+    return new (home) Val<Card>(home,share,*this);
+  }
+
+  template<class Card>
+  PropCost
+  Val<Card>::cost(const Space&, const ModEventDelta&) const {
+    /*
+     * Complexity depends on the time needed for value lookup in \a k
+     * which is O(n log n).
+     */
+    return PropCost::linear(PropCost::HI,x.size());
+  }
+
+  template<class Card>
+  ExecStatus
+  prop_val(Space& home, Propagator& p, 
+           ViewArray<IntView>& x, ViewArray<Card>& k) {
+    assert(x.size() > 0);
+    
+    Region r(home);
+    // count[i] denotes how often value k[i].card() occurs in x
+    int* count = r.alloc<int>(k.size());
+
+    // initialization
+    int sum_min = 0;
+    int removed = 0;
+    for (int i = k.size(); i--; ) {
+      removed += k[i].counter();
+      sum_min += k[i].min();
+      count[i] = 0;
+    }
+
+    // less than or equal than the total number of free variables
+    // to satisfy the required occurences
+    for (int i = k.size(); i--; )
+      GECODE_ME_CHECK(k[i].lq(home, x.size()+removed-(sum_min - k[i].min())));
+
+    // number of unassigned views
+    int non = x.size();
+
+    for (int i = x.size(); i--; )
+      if (x[i].assigned()) {
+        int idx;
+        if (!lookupValue(k,x[i].val(),idx)) {
+          return ES_FAILED;
+        }
+        count[idx]++;
+        non--;
+      }
+
+    // check for subsumption
+    if (non == 0) {
+      for (int i = k.size(); i--; )
+        GECODE_ME_CHECK((k[i].eq(home, count[i] + k[i].counter())));
+      return home.ES_SUBSUMED(p);
+    }
+
+    // total number of unsatisfied miminum occurences
+    int req = 0;
+    // number of values whose min requirements are not yet met
+    int n_r = 0;
+    // if only one value is unsatisified single holds the index of that value
+    int single = -1;
+    // total number of assigned views wrt. the original probem size
+    int t_noa = 0;
+
+    for (int i = k.size(); i--; ) {
+      int ci = count[i] + k[i].counter();
+      t_noa += ci;
+      if (ci == 0) { // this works
+        req += k[i].min();
+        n_r++;
+        single = i;
+      }
+
+      // number of unassigned views cannot satisfy
+      // the required minimum occurence
+      if (req > non) {
+        return ES_FAILED;
+      }
+    }
+
+    // if only one unsatisfied occurences is left
+    if ((req == non) && (n_r == 1)) {
+      // This works as the x are not shared!
+      for (int i = x.size(); i--; ) {
+        // try to assign it
+        if (!x[i].assigned()) {
+          GECODE_ME_CHECK(x[i].eq(home, k[single].card()));
+          assert((single >= 0) && (single < k.size()));
+          count[single]++;
+        }
+      }
+      assert((single >= 0) && (single < k.size()));
+
+      for (int i = k.size(); i--; )
+        GECODE_ME_CHECK(k[i].eq(home, count[i] + k[i].counter()));
+      return home.ES_SUBSUMED(p);
+    }
+
+    // Bitset for indexes that can be removed
+    Support::BitSet<Region> rem(r,static_cast<unsigned int>(k.size()));
+
+    for (int i = k.size(); i--; ) {
+      int ci = count[i] + k[i].counter();
+      if (ci == k[i].max()) {
+        assert(!rem.get(i));
+        rem.set(static_cast<unsigned int>(i));
+        k[i].counter(ci);
+        // the solution contains ci occurences of value k[i].card();
+        GECODE_ME_CHECK(k[i].eq(home, ci));
+      } else {
+        if (ci > k[i].max()) {
+          return ES_FAILED;
+        }
+        
+        // in case of variable cardinalities
+        if (Card::propagate) {
+          GECODE_ME_CHECK(k[i].gq(home, ci));
+          int occupied = t_noa - ci;
+          GECODE_ME_CHECK(k[i].lq(home, x.size() + removed - occupied));
+        }
+      }
+      // reset counter
+      count[i] = 0;
+    }
+
+    // reduce the problem size
+    {
+      int n_x = x.size();
+      for (int i = n_x; i--; ) {
+        if (x[i].assigned()) {
+          int idx;
+          if (!lookupValue(k,x[i].val(),idx)) {
+            return ES_FAILED;
+          }
+          if (rem.get(static_cast<unsigned int>(idx)))
+            x[i]=x[--n_x];
+        }
+      }
+      x.size(n_x);
+    }
+
+    // remove values
+    {
+      // Values to prune
+      int* p = r.alloc<int>(k.size());
+      // Number of values to prune
+      int n_p = 0;
+      for (Iter::Values::BitSet<Support::BitSet<Region> > i(rem); i(); ++i)
+        p[n_p++] = k[i.val()].card();
+      Support::quicksort(p,n_p);
+      for (int i = x.size(); i--;) {
+        Iter::Values::Array pi(p,n_p);
+        GECODE_ME_CHECK(x[i].minus_v(home, pi, false));
+      }
+    }
+
+    {
+      bool all_assigned = true;
+
+      for (int i = x.size(); i--; ) {
+        if (x[i].assigned()) {
+          int idx;
+          if (!lookupValue(k,x[i].val(),idx)) {
+            return ES_FAILED;
+          }
+          count[idx]++;
+        } else {
+          all_assigned = false;
+        }
+      }
+      
+      if (all_assigned) {
+        for (int i = k.size(); i--; )
+          GECODE_ME_CHECK((k[i].eq(home, count[i] + k[i].counter())));
+        return home.ES_SUBSUMED(p);
+      }
+    }
+
+    if (Card::propagate) {
+      // check again consistency of cardinalities
+      int reqmin = 0;
+      int allmax = 0;
+      for (int i = k.size(); i--; ) {
+        if (k[i].counter() > k[i].max()) {
+          return ES_FAILED;
+        }
+        allmax += k[i].max() - k[i].counter();
+        if (k[i].counter() < k[i].min())
+          reqmin += k[i].min() - k[i].counter();
+        GECODE_ME_CHECK((k[i].lq(home, x.size()+k[i].counter())));
+      }
+    
+      if ((x.size() < reqmin) || (allmax < x.size())) {
+        return ES_FAILED;
+      }
+    }
+
+    return ES_NOFIX;
+  }
+
+  template<class Card>
+  ExecStatus
+  Val<Card>::propagate(Space& home, const ModEventDelta&) {
+    return prop_val<Card>(home, *this, x, k);
+  }
+
+  template<class Card>
+  ExecStatus
+  Val<Card>::post(Home home,
+                  ViewArray<IntView>& x, ViewArray<Card>& k) {
+    GECODE_ES_CHECK((postSideConstraints<Card>(home,x,k)));
+
+    if (isDistinct<Card>(home,x,k))
+      return Distinct::Val<IntView>::post(home,x);
+   
+    (void) new (home) Val<Card>(home,x,k);
+    return ES_OK;
+  }
+
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/int/gcc/view.hpp

@@ -0,0 +1,410 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *     Christian Schulte, 2009
+ *     Guido Tack, 2009
+ *
+ *  Last modified: $Date: 2010-06-29 18:39:13 +1000 (Tue, 29 Jun 2010) $ by $Author: schulte $
+ *  $Revision: 11118 $
+ *
+ *  This file is part of Gecode, the generic constrain
+ *  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 GCC {
+
+  /// Return index of \a v in array \a a
+  template<class T>
+  forceinline bool
+  lookupValue(T& a, int v, int& i) {
+    int l = 0;
+    int r = a.size() - 1;
+
+    while (l <= r) {
+      int m = l + (r - l) / 2;
+      if (v == a[m].card()) {
+        i=m; return true;
+      } else if (l == r) {
+        return false;
+      } else if (v < a[m].card()) {
+        r=m-1;
+      } else {
+        l=m+1;
+      }
+    }
+    return false;
+  }
+
+  /// Constant view containing lower and upper cardinality bounds
+  class CardConst {
+  private:
+    /// Lower bound
+    int _min;
+    /// Upper bound
+    int _max;
+    /// Cardinality information
+    int _card;
+    /// Counting information
+    int _counter;
+  public:
+    /// This view does not require propagation
+    static const bool propagate = false;
+
+    /// \name Initialization
+    //@{
+    /// Default constructor
+    CardConst(void);
+    /// Initialize with \a min, \a max, and cardinality \a c
+    void init(Space& home, int min, int max, int c);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return minimum of domain
+    int min(void) const;
+    /// Return maximum of domain
+    int max(void) const;
+    /// Return cardinality
+    int card(void) const;
+    /// Return the number of times the value occurs
+    int counter(void) const;
+    //@}
+
+    /// \name Domain tests
+    ///@{
+    /// Test whether view is assigned
+    bool assigned(void) const;
+    ///@}
+
+    /// \name Domain update by value
+    ///@{
+    /// Set counter to \a n
+    void counter(int n);
+    /// Increment counter
+    ModEvent inc(void);
+    /// Restrict domain values to be less or equal than \a n
+    ModEvent lq(Space& home, int n);
+    /// Restrict domain values to be greater or equal than \a n
+    ModEvent gq(Space& home, int n);
+    /// Restrict domain values to be equal to \a n
+    ModEvent eq(Space& home, int n);
+    ///@}
+
+    /// \name Dependencies
+    ///@{
+    /// Subscribe propagator \a p with propagation condition \a pc to view
+    void subscribe(Space& home, Propagator& p, PropCond pc, bool process=true);
+    /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+    void cancel(Space& home, Propagator& p, PropCond pc);
+    ///@}
+
+    /// \name Cloning
+    ///@{
+    /// Update this view to be a clone of view \a x
+    void update(Space& home, bool share, CardConst& x);
+    ///@}
+
+    /// Return used IntView (cannot be used)
+    IntView base(void) const;
+  };
+
+  /// Cardinality integer view
+  class CardView : public DerivedView<IntView> {
+  protected:
+    using DerivedView<IntView>::x;
+    /// Cardinality
+    int _card;
+    /// Counter
+    int _counter;
+  public:
+    /// This view does require propagation
+    static const bool propagate = true;
+    /// \name Initialization
+    //@{
+    /// Default constructor
+    CardView(void);
+    /// Initialize with integer view \a y and value \a c
+    void init(const IntView& y, int c);
+    /// Initialize for set \a s and cardinality \a c
+    void init(Space& home, const IntSet& s, int c);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return minimum of domain
+    int min(void) const;
+    /// Return maximum of domain
+    int max(void) const;
+    /// Return size (cardinality) of domain
+    unsigned int size(void) const;
+    /// Return the number of times the value occurs
+    int counter(void) const;
+    /// Return cardinality
+    int card(void) const;
+    ///@}
+
+    /// \name Domain update by value
+    ///@{
+    /// Set the counter to the number of times value \a n occurs
+    void counter(int n);
+    /// Increment counter
+    ModEvent inc(void);
+    /// Restrict domain values to be less or equal than \a n
+    ModEvent lq(Space& home, int n);
+    /// Restrict domain values to be greater or equal than \a n
+    ModEvent gq(Space& home, int n);
+    /// Restrict domain values to be equal to \a n
+    ModEvent eq(Space& home, int n);
+    ///@}
+
+    /// \name Domain update by iterator
+    //@{
+    /// Replace domain by values described by \a i
+    template<class I>
+    ModEvent narrow_v(Space& home, I& i, bool depends=true);
+    /// Intersect domain with values described by \a i
+    template<class I>
+    ModEvent inter_v(Space& home, I& i, bool depends=true);
+    /// Remove from domain the values described by \a i
+    template<class I>
+    ModEvent minus_v(Space& home, I& i, bool depends=true);
+    //@}
+
+    /// \name Cloning
+    ///@{
+    /// Update this view to be a clone of view \a x
+    void update(Space& home, bool share, CardView& x);
+    ///@}
+  };
+
+
+
+  /*
+   * Constant cardinality view
+   *
+   */
+  forceinline
+  CardConst::CardConst(void) {}
+  forceinline void
+  CardConst::init(Space&, int min, int max, int c) {
+    _min = min; _max=max; _card = c; _counter = 0;
+  }
+
+  forceinline int
+  CardConst::min(void) const {
+    return _min;
+  }
+  forceinline int
+  CardConst::max(void) const {
+    return _max;
+  }
+  forceinline int
+  CardConst::card(void) const {
+    return _card;
+  }
+  forceinline int
+  CardConst::counter(void) const {
+    return _counter;
+  }
+  forceinline bool
+  CardConst::assigned(void) const {
+    return _min==_max;
+  }
+
+
+  forceinline void
+  CardConst::counter(int n) {
+    _counter = n;
+  }
+  forceinline ModEvent
+  CardConst::inc(void) {
+    if (++_counter > _max)
+      return ME_INT_FAILED;
+    return ME_INT_NONE;
+  }
+  forceinline ModEvent
+  CardConst::lq(Space&, int n) {
+    if (_min > n)
+      return ME_INT_FAILED;
+    return ME_INT_NONE;
+  }
+  forceinline ModEvent
+  CardConst::gq(Space&, int n) {
+    if (_max < n)
+      return ME_INT_FAILED;
+    return ME_INT_NONE;
+  }
+  forceinline ModEvent
+  CardConst::eq(Space&, int n) {
+    if ((_min > n) || (_max < n))
+      return ME_INT_FAILED;
+    return ME_INT_NONE;
+  }
+
+  forceinline void
+  CardConst::subscribe(Space&, Propagator&, PropCond, bool) {}
+  forceinline void
+  CardConst::cancel(Space&, Propagator&, PropCond) {}
+
+  forceinline void
+  CardConst::update(Space&, bool, CardConst& x) {
+    _min=x._min; _max=x._max; _card=x._card; _counter=x._counter;
+  }
+
+  forceinline IntView
+  CardConst::base(void) const {
+    GECODE_NEVER;
+    return IntView();
+  }
+
+
+
+  /*
+   * Cardinality integer view
+   *
+   */
+  forceinline
+  CardView::CardView(void) {}
+  forceinline void
+  CardView::init(const IntView& y, int c) {
+    x = y; _card = c; _counter = 0;
+  }
+  forceinline void
+  CardView::init(Space& home, const IntSet& s, int c) {
+    x = IntVar(home,s); _card = c; _counter = 0;
+  }
+
+  forceinline int
+  CardView::counter(void) const {
+    return _counter;
+  }
+  forceinline int
+  CardView::card(void) const {
+    return _card;
+  }
+  forceinline int
+  CardView::min(void) const {
+    return x.min();
+  }
+  forceinline int
+  CardView::max(void) const {
+    return x.max();
+  }
+  forceinline unsigned int
+  CardView::size(void) const {
+    return x.size();
+  }
+
+  forceinline void
+  CardView::counter(int n) {
+    _counter = n;
+  }
+  forceinline ModEvent
+  CardView::inc(void) {
+    if (++_counter > this->max())
+      return ME_INT_FAILED;
+    return ME_GEN_NONE;
+  }
+  forceinline ModEvent
+  CardView::lq(Space& home, int n) {
+    return x.lq(home,n);
+  }
+  forceinline ModEvent
+  CardView::gq(Space& home, int n) {
+    return x.gq(home,n);
+  }
+  forceinline ModEvent
+  CardView::eq(Space& home, int n) {
+    return x.eq(home,n);
+  }
+
+  template<class I>
+  forceinline ModEvent
+  CardView::narrow_v(Space& home, I& i, bool depends) {
+    return x.narrow_v(home,i,depends);
+  }
+  template<class I>
+  forceinline ModEvent
+  CardView::inter_v(Space& home, I& i, bool depends) {
+    return x.inter_v(home,i,depends);
+  }
+  template<class I>
+  forceinline ModEvent
+  CardView::minus_v(Space& home, I& i, bool depends) {
+    return x.minus_v(home,i,depends);
+  }
+
+  forceinline void
+  CardView::update(Space& home, bool share, CardView& y) {
+    x.update(home,share,y.x);
+    _card = y._card; _counter = y._counter;
+  }
+
+}
+
+
+  /**
+   * \brief %Range iterator for indexed problem variables
+   */
+  template<>
+  class ViewRanges<GCC::CardView>
+    : public Gecode::Int::ViewRanges<IntView> {
+  public:
+    /// \name Constructors and initialization
+    ///@{
+    /// Default constructor
+    ViewRanges(void);
+    /// Initialize with ranges for view \a x
+    ViewRanges(const GCC::CardView& x);
+    /// Initialize with ranges for view \a x
+    void init(const GCC::CardView& x);
+    ///@}
+  };
+
+  forceinline
+  ViewRanges<GCC::CardView>::ViewRanges(void) :
+    Gecode::Int::ViewRanges<IntView>()  {}
+
+  forceinline
+  ViewRanges<GCC::CardView>::ViewRanges (const GCC::CardView& x)
+    : Gecode::Int::ViewRanges<IntView>(x.base())  {}
+
+  forceinline void
+  ViewRanges<GCC::CardView>::init(const GCC::CardView& x) {
+    Gecode::Int::ViewRanges<IntView> xi(x.base());
+  }
+
+}}
+
+
+
+// STATISTICS: int-prop