gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/int/minmax.cc

@@ -0,0 +1,109 @@
+/*
+ *  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: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+
+#include "gecode/set/int.hh"
+
+#include "gecode/iter.hh"
+
+#include "gecode/set/rel.hh"
+
+namespace Gecode { namespace Set { namespace Int {
+
+  Actor*
+  MinElement::copy(Space* home, bool share) {
+    return new (home) MinElement(home,share,*this);
+  }
+
+  ExecStatus
+  MinElement::propagate(Space* home) {
+    //x1 is an element of x0.ub
+    //x1 =< smallest element of x0.lb
+    //x1 =< x0.cardinialityMin-est largest element of x0.ub
+    //(these 2 take care of determined x0)
+    //No element in x0 is smaller than x1
+    //if x1 is determined, it is part of the ub.
+
+    //Consequently:
+    //The domain of x1 is a subset of x0.ub up to the first element in x0.lb.
+    //x0 lacks everything smaller than smallest possible x1.
+
+    LubRanges<SetView> ub(x0);
+    GECODE_ME_CHECK(x1.inter(home,ub));
+    GECODE_ME_CHECK(x1.lq(home,x0.glbMin()));
+    //if cardMin>lbSize?
+    assert(x0.cardMin()>=1);
+    GECODE_ME_CHECK(x1.lq(home,x0.lubMaxN(x0.cardMin()-1)));
+    GECODE_ME_CHECK( x0.exclude(home,
+				Limits::Set::int_min, x1.min()-1) );
+
+    if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.include(home,x1.val()));
+      GECODE_ME_CHECK(x0.exclude(home,
+				 Limits::Set::int_min, x1.val()-1));
+      return ES_SUBSUMED;
+    }
+
+    return ES_FIX;
+  }
+
+  ExecStatus MaxElement::post(Space* home, SetView x0,
+			      Gecode::Int::IntView x1) {
+    GECODE_ME_CHECK(x0.cardMin(home,1));
+    (void) new (home) MaxElement(home,x0,x1);
+    return ES_OK;
+  }
+
+  Actor*
+  MaxElement::copy(Space* home, bool share) {
+    return new (home) MaxElement(home,share,*this);
+  }
+
+  ExecStatus
+  MaxElement::propagate(Space* home) {
+    LubRanges<SetView> ub(x0);
+    GECODE_ME_CHECK(x1.inter(home,ub));
+    GECODE_ME_CHECK(x1.gq(home,x0.glbMax()));
+    assert(x0.cardMin()>=1);
+    GECODE_ME_CHECK(x1.gq(home,x0.lubMinN(x0.cardMin()-1)));
+    GECODE_ME_CHECK(x0.exclude(home,
+			       x1.max()+1,Limits::Set::int_max) );
+
+    if (x1.assigned()) {
+      GECODE_ME_CHECK(x0.include(home,x1.val()));
+      GECODE_ME_CHECK( x0.exclude(home,
+				  x1.val()+1,Limits::Set::int_max) );
+      return ES_SUBSUMED;
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/int/minmax.icc

@@ -0,0 +1,63 @@
+/*
+ *  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: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+
+#include "gecode/set.hh"
+#include "gecode/int.hh"
+
+namespace Gecode { namespace Set { namespace Int {
+
+  forceinline
+  MinElement::MinElement(Space* home, SetView y0, Gecode::Int::IntView y1)
+    : IntSetPropagator<SetView,PC_SET_ANY,
+		       Gecode::Int::PC_INT_BND> (home, y0, y1) {}
+
+  forceinline ExecStatus
+  MinElement::post(Space* home, SetView x0,
+		   Gecode::Int::IntView x1) {
+    GECODE_ME_CHECK(x0.cardMin(home,1));
+    (void) new (home) MinElement(home,x0,x1);
+    return ES_OK;
+  }
+
+  forceinline
+  MinElement::MinElement(Space* home, bool share, MinElement& p)
+    : IntSetPropagator<SetView,PC_SET_ANY,
+		       Gecode::Int::PC_INT_BND> (home, share, p) {}
+
+  forceinline
+  MaxElement::MaxElement(Space* home, SetView y0, Gecode::Int::IntView y1)
+    : IntSetPropagator<SetView,PC_SET_ANY,
+		       Gecode::Int::PC_INT_BND> (home, y0, y1) {}
+
+  forceinline
+  MaxElement::MaxElement(Space* home, bool share, MaxElement& p)
+    : IntSetPropagator<SetView,PC_SET_ANY,
+		       Gecode::Int::PC_INT_BND> (home, share, p) {}
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/int/weights.cc

@@ -0,0 +1,182 @@
+/*
+ *  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: 2006-07-19 14:57:38 +0200 (Wed, 19 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3413 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+
+#include "gecode/set/int.hh"
+
+#include "gecode/iter.hh"
+
+using namespace Gecode::Int;
+
+namespace Gecode { namespace Set { namespace Int {
+
+  PropCost
+  Weights::cost(void) const {
+    return PC_LINEAR_LO;
+  }
+
+  size_t
+  Weights::dispose(Space* home) {
+    assert(!home->failed());
+    x.cancel(home,this, PC_SET_ANY);
+    y.cancel(home,this, Gecode::Int::PC_INT_BND);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  Actor*
+  Weights::copy(Space* home, bool share) {
+    return new (home) Weights(home,share,*this);
+  }
+
+  enum CostType { POS_COST, NEG_COST, ALL_COST };
+
+  template <class I, CostType c>
+  forceinline
+  int weightI(Support::SharedArray<int>& elements,
+	      Support::SharedArray<int>& weights,
+	      I& iter) {
+    int sum = 0;
+    int i = 0;
+    for (Iter::Ranges::ToValues<I> v(iter); v(); ++v) {
+      // Skip all elements below the current
+      while (elements[i]<v.val()) i++;
+      assert(elements[i] == v.val());
+      switch (c) {
+      case ALL_COST:
+	sum += weights[i];
+	break;
+      case POS_COST:
+	if (weights[i] > 0) sum += weights[i];
+	break;
+      case NEG_COST:
+	if (weights[i] < 0) sum += weights[i];
+	break;
+      default: GECODE_NEVER;
+      }
+    }
+    return sum;
+  }
+
+
+  /// Sort order for integers
+  class IntLt {
+  public:
+    bool operator()(int x, int y);
+  };
+
+  forceinline bool 
+  IntLt::operator()(int x, int y) {
+    return x < y;
+  }
+
+  ExecStatus
+  Weights::propagate(Space* home) {
+
+    if (x.assigned()) {
+      GlbRanges<SetView> glb(x);
+      int w = 
+	weightI<GlbRanges<SetView>,ALL_COST>(elements, weights, glb);
+      GECODE_ME_CHECK(y.eq(home, w));
+      return ES_SUBSUMED;
+    }
+
+    int lowCost;
+    int lowestCost;
+    int highestCost;
+    int size = elements.size();
+    {
+      UnknownRanges<SetView> ur(x);
+      Iter::Ranges::ToValues<UnknownRanges<SetView> > urv(ur);
+      GECODE_AUTOARRAY(int, currentWeights, size);
+      for (int i=0; i<size; i++) {
+	if (!urv() || elements[i]<urv.val()) {
+	  currentWeights[i] = 0;
+	} else {
+	  assert(elements[i] == urv.val());
+	  currentWeights[i] = weights[i];
+	  ++urv;
+	}
+      }
+
+      IntLt ilt;
+      Support::quicksort<int>(currentWeights, size, ilt);
+
+      GlbRanges<SetView> glb(x);
+      lowCost = weightI<GlbRanges<SetView>,ALL_COST>(elements, weights, glb);
+      highestCost =
+	weightI<GlbRanges<SetView>,ALL_COST>(elements, weights, glb);
+
+      int delta = std::min(x.unknownSize(), x.cardMax() - x.glbSize());
+
+      for (int i=0; i<delta-1; i++) {
+	if (currentWeights[i] >= 0)
+	  break;
+	lowCost+=currentWeights[i];
+      }
+      lowestCost = lowCost;
+      if (delta>0 && currentWeights[delta-1]<0)
+	lowestCost+=currentWeights[delta-1];
+
+      for (int i=0; i<delta; i++) {
+	if (currentWeights[size-i-1]<=0)
+	  break;
+	highestCost += currentWeights[size-i-1];
+      }
+
+    }
+
+    GECODE_ME_CHECK(y.gq(home, lowestCost));
+    GECODE_ME_CHECK(y.lq(home, highestCost));
+
+    ModEvent me;
+    {
+      UnknownRanges<SetView> ur2(x);
+      Iter::Ranges::ToValues<UnknownRanges<SetView> > urv(ur2);
+      OverweightValues<Iter::Ranges::ToValues<UnknownRanges<SetView> > >
+	ov(y.max()-lowCost, elements, weights, urv);
+      Iter::Values::ToRanges<OverweightValues<
+        Iter::Ranges::ToValues<UnknownRanges<SetView> > > > ovr(ov);
+      me = x.excludeI(home, ovr);
+      GECODE_ME_CHECK(me);
+    }
+
+    if (x.assigned()) {
+      GlbRanges<SetView> glb(x);
+      int w = 
+	weightI<GlbRanges<SetView>,ALL_COST>(elements, weights, glb);
+      GECODE_ME_CHECK(y.eq(home, w));
+      return ES_SUBSUMED;
+    }
+    return me_modified(me) ? ES_NOFIX : ES_FIX;
+  }
+
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/int/weights.icc

@@ -0,0 +1,174 @@
+/*
+ *  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: 2006-08-04 15:23:45 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3509 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+
+#include "gecode/set.hh"
+#include "gecode/int.hh"
+
+namespace Gecode { namespace Set { namespace Int {
+
+  /// Value Iterator for values above a certain weight
+  template <class I>
+  class OverweightValues {
+  private:
+    /// The threshold above which values should be iterated
+    int threshold;
+    /// The value iterator
+    I iter;
+    /// A superset of the elements found in the iterator
+    const Support::SharedArray<int> elements;
+    /// Weights for all the possible elements
+    const Support::SharedArray<int> weights;
+    /// The current index into the elements and weights
+    int index;
+    /// Move to the next element
+    void next(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    OverweightValues(void);
+    /// Initialize with elements/weights pairs, threshold \a t and iterator \a i
+    OverweightValues(int t,
+		     Support::SharedArray<int>& elements0,
+		     Support::SharedArray<int>& weights0,
+		     I& i);
+    /// Initialize with elements/weights pairs, threshold \a t and iterator \a i
+    void init(int t,
+	      Support::SharedArray<int>& elements0,
+	      Support::SharedArray<int>& weights0,
+	      I& i);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+    /// \name Value access
+    //@{
+    /// Return current value
+    int  val(void) const;
+    //@}
+  };
+
+  template <class I>
+  forceinline void
+  OverweightValues<I>::next(void) {
+    while (iter()) {
+      while (elements[index]<iter.val()) index++;
+      assert(elements[index]==iter.val());
+      if (weights[index] > threshold) {
+	return;
+      }
+      ++iter;
+    }
+  }
+
+  template <class I>
+  forceinline
+  OverweightValues<I>::OverweightValues(void) {}
+
+  template <class I>
+  forceinline
+  OverweightValues<I>::OverweightValues(int t,
+					Support::SharedArray<int>& elements0,
+					Support::SharedArray<int>& weights0,
+					I& i) : threshold(t),
+						iter(i),
+						elements(elements0),
+						weights(weights0),
+						index(0) {
+    next();
+  }
+
+  template <class I>
+  forceinline void
+  OverweightValues<I>::init(int t,
+			    Support::SharedArray<int>& elements0,
+			    Support::SharedArray<int>& weights0,
+			    I& i) {
+    threshold = t; iter = i;
+    elements = elements0; weights = weights0;
+    index = 0;
+    next();
+  }
+
+  template <class I>
+  forceinline bool
+  OverweightValues<I>::operator()(void) const { return iter(); }
+
+  template <class I>
+  forceinline void
+  OverweightValues<I>::operator++(void) { ++iter; next(); }
+
+  template <class I>
+  forceinline int
+  OverweightValues<I>::val(void) const { return elements[index]; }
+
+  forceinline
+  Weights::Weights(Space* home,
+		   const IntArgs& elements0, const IntArgs& weights0,
+		   SetView x0, Gecode::Int::IntView y0)
+    : Propagator(home), elements(elements0.size()), weights(weights0.size()),
+      x(x0), y(y0) {
+    x.subscribe(home,this, PC_SET_ANY);
+    y.subscribe(home,this, Gecode::Int::PC_INT_BND);
+    for (int i=elements0.size(); i--;) {
+      elements[i] = elements0[i];
+      weights[i] = weights0[i];
+    }
+  }
+
+  forceinline
+  Weights::Weights(Space* home, bool share, Weights& p)
+    : Propagator(home,share,p) {
+    x.update(home,share,p.x);
+    y.update(home,share,p.y);
+    elements.update(share,p.elements);
+    weights.update(share,p.weights);
+  }
+
+  inline ExecStatus
+  Weights::post(Space* home, const IntArgs& elements, const IntArgs& weights,
+		SetView x, Gecode::Int::IntView y) {
+    if (elements.size() != weights.size())
+      throw ArgumentSizeMismatch("Weights");
+    GECODE_AUTOARRAY(int, els_arr, elements.size());
+    for (int i=elements.size(); i--;)
+      els_arr[i] = elements[i];
+    IntSet els(els_arr, elements.size());
+    IntSetRanges er(els);
+    GECODE_ME_CHECK(x.intersectI(home, er));
+    (void) new (home) Weights(home,elements,weights,x,y);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop