gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/var/imp.icc

@@ -0,0 +1,356 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 10:43:21 +0200 (Fri, 25 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3568 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Set {
+
+  /*
+   * Creation of new variable implementations
+   *
+   */
+
+  forceinline
+  SetVarImp::SetVarImp(Space* home)
+    : SetVarImpBase(home), lub(home), glb(home) {
+    _cardMin = 0;
+    _cardMax = Limits::Set::card_max;
+    assert(_cardMax==lub.size());
+  }
+
+  forceinline
+  SetVarImp::SetVarImp(Space* home,int lbMin,int lbMax,int ubMin,int ubMax,
+		       unsigned int cardMin, unsigned int cardMax)
+    : SetVarImpBase(home),
+      lub(home,ubMin,ubMax), glb(home,lbMin,lbMax) {
+    _cardMin = std::max(cardMin, glb.size() );
+    _cardMax = std::min(cardMax, lub.size() );
+  }
+
+  forceinline
+  SetVarImp::SetVarImp(Space* home,
+		       const IntSet& theGlb,int ubMin,int ubMax,
+		       unsigned int cardMin, unsigned int cardMax)
+    : SetVarImpBase(home),
+      lub(home,ubMin,ubMax), glb(home,theGlb) {
+    _cardMin = std::max(cardMin, glb.size() );
+    _cardMax = std::min(cardMax, lub.size() );
+  }
+
+  forceinline
+  SetVarImp::SetVarImp(Space* home,
+		       int lbMin,int lbMax,const IntSet& theLub,
+		       unsigned int cardMin, unsigned int cardMax)
+    : SetVarImpBase(home),
+      lub(home,theLub), glb(home,lbMin,lbMax) {
+    _cardMin = std::max(cardMin, glb.size() );
+    _cardMax = std::min(cardMax, lub.size() );
+  }
+  
+  forceinline
+  SetVarImp::SetVarImp(Space* home,
+		       const IntSet& theGlb,const IntSet& theLub,
+		       unsigned int cardMin, unsigned int cardMax)
+    : SetVarImpBase(home), lub(home,theLub), glb(home,theGlb) {
+    _cardMin = std::max(cardMin, glb.size() );
+    _cardMax = std::min(cardMax, lub.size() );
+  }
+
+
+#define GECODE_SET_CHECK_LUB(home,changed) {        \
+    if (changed)				\
+      return processLubChange(home);		\
+    return ME_SET_NONE;				\
+  }
+
+#define GECODE_SET_CHECK_GLB(home,changed) {        \
+    if (changed)				\
+      return processGlbChange(home);		\
+    return ME_SET_NONE;				\
+  }
+
+  forceinline  bool
+  SetVarImp::assigned(void) const {
+    return ( glb.size() == lub.size() );
+  }
+
+  forceinline unsigned int
+  SetVarImp::cardMin(void) const { return _cardMin; }
+
+  forceinline unsigned int
+  SetVarImp::cardMax(void) const { return _cardMax; }
+
+  forceinline bool
+  SetVarImp::knownIn(int i) const { return (glb.in(i)); }
+
+  forceinline bool
+  SetVarImp::knownOut(int i) const { return !(lub.in(i)); }
+
+  forceinline int
+  SetVarImp::lubMin(void) const { return lub.min(); }
+
+  forceinline int
+  SetVarImp::lubMax(void) const { return lub.max(); }
+
+  forceinline int
+  SetVarImp::lubMinN(int n) const { return lub.minN(n); }
+
+  forceinline int
+  SetVarImp::lubMaxN(int n) const { return lub.maxN(n); }
+
+  forceinline int
+  SetVarImp::glbMin(void) const { return glb.min(); }
+
+  forceinline int
+  SetVarImp::glbMax(void) const { return glb.max(); }
+
+  forceinline unsigned int
+  SetVarImp::glbSize() const { return glb.size(); }
+
+  forceinline unsigned int
+  SetVarImp::lubSize() const { return lub.size(); }
+
+  //Determines consistency of lower and upper bounds, signals fail
+  forceinline bool
+  SetVarImp::boundsConsistent() const {
+    //Don't optimise fail at a cost to the common case!
+    //  if (lubSize()<glbSize()){ return false; }
+    BndSetRanges ub(lub);
+    BndSetRanges lb(glb);
+    return (Iter::Ranges::subset(lb,ub)) ;
+  }
+
+  forceinline ModEvent
+  SetVarImp::cardMin(Space* home,unsigned int newMin) {
+    if (_cardMin >= newMin)
+      return ME_SET_NONE;
+    _cardMin=newMin;
+    if (_cardMin > _cardMax)
+      return ME_SET_FAILED;
+    return cardMin_full(home, newMin);
+  }
+
+  forceinline ModEvent
+  SetVarImp::cardMax(Space* home,unsigned int newMax) {
+    if (_cardMax <= newMax)
+      return ME_SET_NONE;
+    _cardMax=newMax;
+    if (_cardMin > _cardMax)
+      return ME_SET_FAILED;
+    return cardMax_full(home, newMax);
+  }
+
+  template <class I> ModEvent
+  SetVarImp::excludeI(Space* home, I& iterator) {
+    if (assigned()) {
+      BndSetRanges ubi(lub);
+      Iter::Ranges::Inter<BndSetRanges,I> probe(ubi,iterator);
+      return probe() ? ME_SET_FAILED : ME_SET_NONE;
+    }
+    GECODE_SET_CHECK_LUB(home, lub.excludeI(home, iterator));
+  }
+
+  template <class I> forceinline ModEvent
+  SetVarImp::intersectI(Space* home, I& iterator) {
+    if (assigned()) {
+      BndSetRanges ubi(lub);
+      Iter::Ranges::Diff<BndSetRanges,I> probe(ubi,iterator);
+      return probe() ? ME_SET_FAILED : ME_SET_NONE;
+    }
+    GECODE_SET_CHECK_LUB(home, lub.intersectI(home, iterator));
+  }
+
+  forceinline ModEvent
+  SetVarImp::intersect(Space* home,int i, int j) {
+    bool changed =
+      lub.exclude(home, Limits::Set::int_min, i-1);
+    changed |=
+      lub.exclude(home, j+1, Limits::Set::int_max);      
+    if (changed)
+      return processLubChange(home);
+    return ME_SET_NONE;
+  }
+
+  forceinline ModEvent
+  SetVarImp::intersect(Space* home,int i) {
+    return intersect(home, i, i);
+  }
+
+  template <class I> forceinline ModEvent
+  SetVarImp::includeI(Space* home, I& iterator) {
+    if (assigned()) {
+      BndSetRanges lbi(glb);
+      Iter::Ranges::Diff<I,BndSetRanges>
+	probe(iterator,lbi);
+      return probe() ? ME_SET_FAILED : ME_SET_NONE;
+    }
+    GECODE_SET_CHECK_GLB(home, glb.includeI(home, iterator));
+  }
+
+  forceinline ModEvent
+  SetVarImp::include(Space* home, int i) {
+    GECODE_SET_CHECK_GLB(home,glb.include(home, i, i)) ;
+  }
+
+  forceinline ModEvent
+  SetVarImp::include(Space* home, int i, int j) {
+    GECODE_SET_CHECK_GLB(home,glb.include(home,i,j)) ;
+  }
+
+  forceinline ModEvent
+  SetVarImp::exclude(Space* home,int i) {
+    GECODE_SET_CHECK_LUB(home,lub.exclude(home,i,i));
+  }
+
+  forceinline ModEvent
+  SetVarImp::exclude(Space* home,int i, int j) {
+    GECODE_SET_CHECK_LUB(home,lub.exclude(home,i,j)) ;
+  }
+
+  forceinline ModEvent
+  SetVarImp::checkGlbCardAssigned(Space* home,ModEvent me){
+    if (_cardMax > glb.size())
+      return me;
+    if (_cardMax == glb.size()) {
+      lub.linkTo(home,glb);
+      _cardMin=_cardMax;
+      return ME_SET_VAL;
+    }
+    return ME_SET_FAILED;
+  }
+
+  forceinline ModEvent
+  SetVarImp::checkLubCardAssigned(Space* home,ModEvent me){
+    if (_cardMin < lub.size())
+      return me;
+    if (_cardMin == lub.size()) {
+      glb.linkTo(home,lub);
+      _cardMax=_cardMin;
+      return ME_SET_VAL;
+    }
+    return ME_SET_FAILED;
+  }
+
+  /*
+   * Copying a variable
+   *
+   */
+
+  forceinline SetVarImp*
+  SetVarImp::copy(Space* home, bool share) {
+    return copied() ?
+      static_cast<SetVarImp*>(forward()) :
+      perform_copy(home,share);
+  }
+
+  /*
+   * Iterator specializations
+   *
+   */
+
+  /**
+   * \brief Range iterator for the least upper bound of a set variable implementation
+   *
+   * This class provides (by specialization) a range iterator 
+   * for the least upper bounds of set variable implementations.
+   *
+   * \ingroup TaskActorSet
+   */  
+  template <>
+  class LubRanges<SetVarImp*> : public BndSetRanges {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    LubRanges(void);
+    /// Initialize with ranges for variable implementation \a x
+    LubRanges(const SetVarImp*);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const SetVarImp*);
+    //@}
+  };
+
+  forceinline
+  LubRanges<SetVarImp*>::LubRanges(void) {}
+
+  forceinline
+  LubRanges<SetVarImp*>::LubRanges(const SetVarImp* x)
+    : BndSetRanges(x->lub) {}
+
+  forceinline void
+  LubRanges<SetVarImp*>::init(const SetVarImp* x) {
+    BndSetRanges::init(x->lub);
+  }
+
+  /**
+   * \brief Range iterator for the greatest lower bound of a set variable implementation
+   *
+   * This class provides (by specialization) a range iterator 
+   * for the greatest lower bounds of set variable implementations.
+   *
+   * \ingroup TaskActorSet
+   */  
+  template <>
+  class GlbRanges<SetVarImp*> : public BndSetRanges {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GlbRanges(void);
+    /// Initialize with ranges for variable implementation \a x
+    GlbRanges(const SetVarImp* x);
+    /// Initialize with ranges for variable implementation \a x
+    void init(const SetVarImp*);
+    //@}
+  };
+
+  forceinline
+  GlbRanges<SetVarImp*>::GlbRanges(void) {}
+
+  forceinline
+  GlbRanges<SetVarImp*>::GlbRanges(const SetVarImp* x)
+    : BndSetRanges(x->glb) {}
+
+  forceinline void
+  GlbRanges<SetVarImp*>::init(const SetVarImp* x) {
+    BndSetRanges::init(x->glb);
+  }
+
+
+  /*
+   * Subscribing to variables
+   *
+   */
+
+  forceinline void
+  SetVarImp::subscribe(Space* home, Propagator* p, PropCond pc, bool process) {
+    SetVarImpBase::subscribe(home,p,pc,assigned(),process);
+  }
+
+}}
+
+// STATISTICS: set-var
+
+

data/ext/gecode-1.3.1/gecode/set/var/integerset.cc

@@ -0,0 +1,256 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 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"
+
+namespace Gecode { namespace Set {
+
+  BndSet::BndSet(Space* home, const IntSet& is)  {
+    if (is.size()==0) {
+      fst(NULL); lst(NULL); _size = 0;
+    } else {
+      int n = is.size();
+      RangeList* r = reinterpret_cast<RangeList*>
+	(home->alloc(sizeof(RangeList)*n));
+      fst(r); lst(r+n-1);
+      unsigned int s = 0;
+      for (int i = n; i--; ) {
+	s += is.width(i);
+	r[i].min(is.min(i)); r[i].max(is.max(i));
+	r[i].prevnext(&r[i-1],&r[i+1]);
+      }
+      r[0].prev(&r[-1],NULL); 
+      r[n-1].next(&r[n],NULL);
+      _size = s;
+    }
+    assert(isConsistent());
+  }
+
+  bool
+  GLBndSet::include_full(Space* home, int mi, int ma) {
+    assert(ma >= mi);
+    assert(fst() != NULL);
+    
+    RangeList* p = NULL;
+    RangeList* c = fst();
+    while (c != NULL) {
+      if (c->max() >= mi-1){
+	if (c->min() > ma+1) {  //in a hole before c
+	  _size+=(ma-mi+1);
+	  RangeList* q=new (home) RangeList(mi,ma,NULL,c);
+	  if (p==NULL){ //the new range is the first
+	    assert(c==fst());
+	    c->prev(NULL,q);
+	    fst(q);
+	    return true;
+	  }
+	  q->prev(NULL, p);
+	  p->next(c, q);
+	  c->prev(p, q);
+	  return true;
+	}
+	//if the range starts before c, update c->min and size
+	bool result = false;
+	if (c->min()>mi) {
+	  _size+=(c->min()-mi);
+	  c->min(mi);
+	  result = true;
+	}
+	assert(c->min()<=mi);
+	assert(c->max()+1>=mi);
+	if (c->max() >= ma) { 
+	  return result; }
+
+	RangeList* qp = p;
+	RangeList* q = c;
+	//sum up the size of holes eaten
+	int prevMax = c->max();
+	int growth =0;
+	// invariant: q->min()<=ma+1
+	while (q->next(qp)!=NULL && q->next(qp)->min()<=ma+1){
+	  RangeList* nq = q->next(qp);
+	  qp = q; q = nq;
+	  growth+=q->min()-prevMax-1;
+	  prevMax=q->max();
+	}
+	assert(growth>=0);
+	_size+=growth;
+	if (q->max() < ma) {_size+=ma-q->max(); }
+	c->max(std::max(ma,q->max()));
+	if (c==q) {
+	  return true; }
+	RangeList* oldCNext = c->next(p);
+	assert(oldCNext!=NULL); //q would have stayed c if c was last.
+	c->next(oldCNext, q->next(qp));
+	if (q->next(qp)==NULL){
+	  assert(q==lst());
+	  lst(c);
+	} else {
+	  q->next(qp)->prev(q,c);
+	}
+	oldCNext->dispose(home,c,q);
+	return true;
+      }
+      RangeList* nc = c->next(p);
+      p=c; c=nc;
+    }
+    //the new range is disjoint from the old domain and we add it as last:
+    assert(mi>max()+1);
+    RangeList* q = new (home) RangeList(mi, ma, lst(), NULL);
+    lst()->next(NULL, q);
+    lst(q);
+    _size+= q->width();
+    return true;
+  }
+
+  bool
+  LUBndSet::exclude_full(Space* home, int mi, int ma) {
+    assert(ma >= mi);
+    assert(mi <= max() && ma >= min() &&
+	   (mi > min() || ma < max()));
+    bool result=false;
+
+    RangeList* p = NULL;
+    RangeList* c = fst();
+    while (c != NULL) {
+      if (c->max() >= mi){
+	if (c->min() > ma) { return result; } //in a hole
+
+	if (c->min()<mi && c->max() > ma) {  //Range split:
+	  RangeList* q =
+	    new (home) RangeList(ma+1,c->max(),c,c->next(p));
+	  c->max(mi-1);
+	  if (c != lst()) {c->next(p)->prev(c,q); }
+	  else { lst(q); }
+	  c->next(c->next(p),q);
+	  _size -= (ma-mi+1);
+	  return true;
+	}
+
+	if (c->max() > ma) { //start of range clipped, end remains
+	  _size-=(ma-c->min()+1);
+	  c->min(ma+1);
+	  return true;
+	}
+
+	if (c->min() < mi) { //end of range clipped, start remains
+	  _size-=(c->max()-mi+1);
+	  c->max(mi-1);
+	  result=true;
+	} else { //range *c destroyed
+	  _size-=c->width();
+	  RangeList *cendp = p;
+	  RangeList *cend = c;
+	  while ((cend->next(cendp)!=NULL) && (cend->next(cendp)->max()<=ma)){
+	    RangeList *ncend = cend->next(cendp);
+	    cendp=cend; cend=ncend;
+	    _size-=cend->width();
+	  }
+	  if (fst()==c) { fst(cend->next(cendp)); }
+	  else { p->next(c, cend->next(cendp)); }
+	  if (lst()==cend) { lst(p); }
+	  else { cend->next(cendp)->prev(cend,p); }
+	  RangeList* nc=cend->next(cendp); //performs loop step!
+	  c->dispose(home,p,cend);
+	  p=cend;
+	  c=nc;
+	  if (c!=NULL && c->min() <= ma ) { //start of range clipped, end remains
+	    _size-=(ma-c->min()+1);
+	    c->min(ma+1);
+	  }
+	  return true;
+	}
+      }
+      RangeList *nc = c->next(p);
+      p=c; c=nc;
+    }
+    return result;
+  }
+
+#ifndef NDEBUG
+  using namespace Gecode::Int;
+#endif
+
+  bool
+  BndSet::isConsistent(void) const {
+#ifndef NDEBUG
+    if (fst()==NULL) {
+      if (lst()!=NULL || size()!=0) {
+        std::cout<<"Strange empty set.\n";
+        return false;
+      } else return true;
+    }
+
+    if (fst()!=NULL && lst()==NULL) {
+      std::cout<<"First is not null, last is.\n";
+      return false;
+    }
+
+    RangeList *p=NULL;
+    RangeList *c=fst();
+
+    int min = c->min();
+    int max = c->max();
+
+    if (max<min) {
+      std::cout << "Single range list twisted: ("<<min<<","<<max<<")" ;
+      return false;
+    }
+
+    RangeList *nc=c->next(p);
+    p=c; c=nc;
+    while (c) {
+      if (max<min) {
+        std::cout << "1";
+        return false;
+      }
+      if ((max+1)>=c->min()) {
+        std::cout << "2";
+        return false;
+      }
+      if (c->next(p)==NULL && c!=lst()) {
+        std::cout << "3";
+        return false;
+      }
+
+      if (c->next(p)!=NULL && c->next(p)->prev(c->next(p)->next(c))!=c) {
+        std::cout<<"Prev of next not self.\n";
+        ((RangeList *)NULL)->min();
+        return false;
+      }
+
+      min = c->min();
+      max = c->max();
+      
+      nc=c->next(p);
+      p=c; c=nc;
+    }
+#endif
+    return true;
+  }
+
+
+}}
+
+// STATISTICS: set-var
+