gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/projectors/propagator/card.icc

@@ -0,0 +1,96 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-17 11:46:13 +0200 (Thu, 17 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3544 $
+ *
+ *  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 { namespace Projection {
+
+  forceinline
+  CardProjection::CardProjection
+  (Space* home, ViewArray<SetView>& x0, Gecode::Int::IntView i0, Projector& p0)
+    : Propagator(home,true), x(x0), i(i0), proj(p0) {
+    Support::DynamicArray<int> scope;
+    p0.scope(scope);
+    pc.ensure(x.size());
+    for (int i=x0.size(); i--;) {
+      pc[i] = scope[i];
+      x[i].subscribe(home, this, pc[i]);
+    }
+  }
+
+  forceinline
+  CardProjection::CardProjection
+  (Space* home, bool share, CardProjection& p)
+    : Propagator(home,share,p), proj(p.proj) {
+    x.update(home,share,p.x);
+    i.update(home,share,p.i);
+    pc.update(share, p.pc);
+  }
+
+  forceinline PropCost
+  CardProjection::cost(void) const {
+    switch (x.size()) {
+    case 1: return PC_UNARY_HI;
+    case 2: return PC_BINARY_HI;
+    case 3: return PC_TERNARY_HI;
+    default: return PC_LINEAR_HI;
+    }
+  }
+
+  inline size_t
+  CardProjection::dispose(Space* home) {
+    if (!home->failed()) {
+      for (int i=x.size(); i--;)
+	if (pc[i] != PC_SET_ANY + 1)
+	  x[i].cancel(home, this, pc[i]);
+    }
+    proj.~Projector();
+    pc.~SharedArray();
+    Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  inline ExecStatus
+  CardProjection::post(Space* home,
+		       ViewArray<SetView>& x, Gecode::Int::IntView i,
+		       Projector& p) {
+    (void) new (home) CardProjection(home,x,i,p);
+    return ES_OK;
+  }
+
+  inline Actor*
+  CardProjection::copy(Space* home, bool share) {
+    return new (home) CardProjection(home,share,*this);
+  }
+
+  inline ExecStatus
+  CardProjection::propagate(Space* home) {
+    bool done = true;
+    for (int j=x.size(); j--;)
+      if (pc[j] != PC_SET_ANY + 1)
+	done = done && x[j].assigned();
+    
+    {
+      GECODE_ME_CHECK(i.gq(home, static_cast<int>(proj.glbSize(x))));
+      GECODE_ME_CHECK(i.lq(home, static_cast<int>(proj.lubSize(x))));
+    }
+    return done ? ES_SUBSUMED : ES_FIX;
+  }
+
+}}}

data/ext/gecode-1.3.1/gecode/set/projectors/propagator/nary.icc

@@ -0,0 +1,106 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-17 11:46:13 +0200 (Thu, 17 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3544 $
+ *
+ *  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 { namespace Projection {
+
+  template <bool negated>
+  forceinline
+  NaryProjection<negated>::NaryProjection
+  (Space* home, ViewArray<SetView>& x0, ProjectorSet& ps0)
+    : Propagator(home,true), x(x0), ps(ps0) {
+    Support::DynamicArray<int> scope;
+    ps.scope(scope);
+    pc.ensure(x.size());
+    for (int i=x0.size(); i--;) {
+      pc[i] = scope[i];
+      if (negated)
+	pc[i] = ComplementView<SetView>::pc_negateset(pc[i]);
+      x[i].subscribe(home, this, pc[i]);
+    }
+  }
+
+  template <bool negated>
+  forceinline
+  NaryProjection<negated>::NaryProjection
+  (Space* home, bool share, NaryProjection& p)
+    : Propagator(home,share,p), ps(p.ps) {
+    x.update(home,share,p.x);
+    pc.update(share, p.pc);
+  }
+
+  template <bool negated>
+  forceinline PropCost
+  NaryProjection<negated>::cost(void) const {
+    switch (x.size()) {
+    case 1: return PC_UNARY_HI;
+    case 2: return PC_BINARY_HI;
+    case 3: return PC_TERNARY_HI;
+    default: return PC_LINEAR_HI;
+    }
+  }
+
+  template <bool negated>
+  size_t
+  NaryProjection<negated>::dispose(Space* home) {
+    if (!home->failed()) {
+      for (int i=x.size(); i--;)
+	if (pc[i] != PC_SET_ANY + 1)
+	  x[i].cancel(home, this, pc[i]);
+    }
+    ps.~ProjectorSet();
+    pc.~SharedArray();
+    Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <bool negated>
+  ExecStatus
+  NaryProjection<negated>::post(Space* home,
+				ViewArray<SetView>& x, ProjectorSet& ps) {
+    if (ps.arity() != x.size()-1) {
+      throw Set::InvalidProjector("");
+    }
+    (void) new (home) NaryProjection<negated>(home,x,ps);
+    return ES_OK;
+  }
+
+  template <bool negated>
+  Actor*
+  NaryProjection<negated>::copy(Space* home, bool share) {
+    return new (home) NaryProjection<negated>(home,share,*this);
+  }
+
+  template <bool negated>
+  ExecStatus
+  NaryProjection<negated>::propagate(Space* home) {
+    bool done = true;
+    for (int i=x.size(); i--;)
+      if (!x[i].assigned()) {
+	done = false; break;
+      }
+    ExecStatus es = ps.propagate<negated>(home, x);
+    GECODE_ES_CHECK(es);
+    return done ? ES_SUBSUMED : es;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/propagator/re-nary.cc

@@ -0,0 +1,76 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-07-12 15:53:12 +0200 (Wed, 12 Jul 2006) $ by $Author: tack $
+ *     $Revision: 3349 $
+ *
+ *  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/projectors/propagator.hh"
+
+namespace Gecode { namespace Set { namespace Projection {
+
+  size_t
+  ReNaryProjection::dispose(Space* home) {
+    if (!home->failed()) {
+      x.cancel(home,this,PC_SET_ANY);
+      b.cancel(home,this,Gecode::Int::PC_INT_VAL);
+    }
+    ps.~ProjectorSet();
+    Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  ExecStatus
+  ReNaryProjection::post(Space* home, ViewArray<SetView>& x,
+			 Gecode::Int::BoolView b, ProjectorSet& ps) {
+    if (ps.arity() != x.size() - 1)
+      throw Set::InvalidProjector("");
+    (void) new (home) ReNaryProjection(home,x,b,ps);
+    return ES_OK;
+  }
+
+  Actor*
+  ReNaryProjection::copy(Space* home, bool share) {
+    return new (home) ReNaryProjection(home,share,*this);
+  }
+
+  ExecStatus
+  ReNaryProjection::propagate(Space* home) {
+    if (b.one()) {
+      GECODE_ES_CHECK((NaryProjection<false>::post(home,x,ps)));
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ES_CHECK((NaryProjection<true>::post(home,x,ps)));
+      return ES_SUBSUMED;
+    }
+
+    switch (ps.check(home, x)) {
+    case ES_SUBSUMED:
+      b.t_one_none(home);
+      return ES_SUBSUMED;
+    case ES_FAILED:
+      b.t_zero_none(home);
+      return ES_SUBSUMED;
+    default:
+      return ES_FIX;
+    }
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/propagator/re-nary.icc

@@ -0,0 +1,53 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-07-12 15:53:12 +0200 (Wed, 12 Jul 2006) $ by $Author: tack $
+ *     $Revision: 3349 $
+ *
+ *  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 { namespace Projection {
+
+  forceinline
+  ReNaryProjection::ReNaryProjection
+  (Space* home, ViewArray<SetView>& x0, Gecode::Int::BoolView b0,
+   ProjectorSet& ps0)
+    : Propagator(home,true), x(x0), b(b0), ps(ps0) {
+    x.subscribe(home, this, PC_SET_ANY);
+    b.subscribe(home,this,Gecode::Int::PC_INT_VAL);
+  }
+
+  forceinline
+  ReNaryProjection::ReNaryProjection
+  (Space* home, bool share, ReNaryProjection& p)
+    : Propagator(home,share,p), ps(p.ps) {
+    x.update(home,share,p.x);
+    b.update(home,share,p.b);
+  }
+
+  forceinline PropCost
+  ReNaryProjection::cost(void) const {
+    switch (x.size()) {
+    case 1: return PC_UNARY_HI;
+    case 2: return PC_BINARY_HI;
+    case 3: return PC_TERNARY_HI;
+    default: return PC_LINEAR_HI;
+    }
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/set-expr.cc

@@ -0,0 +1,306 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-17 16:58:48 +0200 (Thu, 17 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3548 $
+ *
+ *  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/projectors.hh"
+#include "gecode/support/dynamic-stack.hh"
+
+using namespace Gecode::Set;
+
+namespace Gecode {
+
+  /**
+   * \brief Nodes used to construct set expressions
+   */
+  class SetExpr::Node {
+  private:
+    /// Nodes are reference counted
+    unsigned int use;
+    /// Left and right subtrees
+    Node *left, *right;
+    /// Left and right signs for entire subtress
+    int signLeft, signRight;
+    /// Variable
+    var_idx x;
+    /// Relation
+    RelType rel;
+  public:
+    /// Construct node for \a x
+    Node(const var_idx x);
+    /// Construct node from nodes \a n0 and \a n1 with signs \a s0 and \a s1
+    Node(Node* n0, int s0, RelType r, Node* n1, int s1);
+    
+    /// Increment reference count
+    void increment(void);
+    /// Decrement reference count and possibly free memory
+    GECODE_SET_EXPORT bool decrement(void);
+    
+    /// Adds code representation of the node to \a ret
+    void encode(SetExprCode& ret, bool monotone) const;
+    /// Returns the arity of the node
+    int arity(void) const;
+
+    /// Returns an iterator for this node
+    Iter::Ranges::Virt::Iterator* iter(void);
+    
+    /// Memory management
+    static void* operator new(size_t size);
+    /// Memory management
+    static void  operator delete(void* p,size_t size);
+  };
+
+  /*
+   * Operations for nodes
+   *
+   */
+
+  forceinline void*
+  SetExpr::Node::operator new(size_t size) {
+    return Memory::malloc(size);
+  }
+
+  forceinline void
+  SetExpr::Node::operator delete(void* p, size_t) {
+    Memory::free(p);
+  }
+
+
+  forceinline void
+  SetExpr::Node::increment(void) { 
+    ++use; 
+  }
+
+  forceinline
+  SetExpr::Node::Node(const var_idx x) :
+    use(1),
+    left(NULL), right(NULL), signLeft(0), signRight(0), x(x) {}
+
+  forceinline
+  SetExpr::Node::Node(Node* l, int sL, RelType _rel, Node* r, int sR) :
+    use(1),
+    left(l), right(r), signLeft(sL), signRight(sR), rel(_rel) {
+    if (left != NULL)
+      left->increment();
+    if (right != NULL)
+      right->increment();
+  }
+
+  bool
+  SetExpr::Node::decrement(void) {
+    if (--use == 0) {
+      if (left != NULL && left->decrement())
+	delete left;
+      if (right != NULL && right->decrement())
+	delete right;
+      return true;
+    }
+    return false;
+  }
+
+  int
+  SetExpr::Node::arity(void) const {
+    if (left==NULL && right==NULL)
+      return x;
+    return std::max( left==NULL ? 0 : left->arity(),
+		     right==NULL ? 0 : right->arity() );
+  }
+
+  void
+  SetExpr::Node::encode(SetExprCode& ret, bool monotone) const {
+    if (left==NULL && right==NULL) {
+      assert(x>=0);
+      ret.add(SetExprCode::LAST+x);
+      if (monotone)
+        ret.add(SetExprCode::LUB);
+      else
+        ret.add(SetExprCode::GLB);
+      return;
+    }
+    if (left==NULL) {
+      ret.add(SetExprCode::UNIVERSE);
+    } else {
+      left->encode(ret, (signLeft==1) ? monotone : !monotone);
+    }
+    if (signLeft==-1)
+      ret.add(SetExprCode::COMPLEMENT);
+    if (right==NULL) {
+      ret.add(SetExprCode::UNIVERSE);
+    } else {
+      right->encode(ret, (signRight==1) ? monotone : !monotone);
+    }
+    if (signRight==-1)
+      ret.add(SetExprCode::COMPLEMENT);
+    switch (rel) {
+    case REL_INTER: ret.add(SetExprCode::INTER); break;
+    case REL_UNION: ret.add(SetExprCode::UNION); break;
+    default:
+	GECODE_NEVER;
+    }
+  }
+
+
+  /*
+   * Operations for expressions
+   *
+   */
+  
+  SetExpr::SetExpr(var_idx v) : ax(new Node(v)), sign(1) {}
+
+  SetExpr::SetExpr(const SetExpr& s, int ssign,
+		   RelType r,
+		   const SetExpr& t, int tsign)
+    : ax(new Node(s.ax,s.sign*ssign,r,t.ax,t.sign*tsign)), sign(1) {}
+
+  SetExpr::SetExpr(const SetExpr& s, int sign)
+    : ax(s.ax), sign(s.sign*sign) {
+    if (ax != NULL)
+      ax->increment();
+  }
+
+  SetExpr::SetExpr(const SetExpr& s)
+    : ax(s.ax), sign(s.sign) {
+    if (ax != NULL)
+      ax->increment();
+  }
+
+  const SetExpr&
+  SetExpr::operator=(const SetExpr& s) {
+    if (this != &s) {
+      if ((ax != NULL) && ax->decrement())
+	delete ax;
+      ax = s.ax;
+      sign = s.sign;
+      if (ax != NULL)
+	ax->increment();
+    }
+    return *this;
+  }
+
+  SetExpr::~SetExpr(void) {
+    if ((ax != NULL) && ax->decrement())
+      delete ax;
+  }
+
+  int
+  SetExpr::arity(void) const {
+    return (ax==NULL) ? 0 : ax->arity();
+  }
+
+  SetExprCode
+  SetExpr::encode(void) const {
+    SetExprCode ret;
+    if (ax==NULL) {
+      ret.add((sign==1) ? SetExprCode::EMPTY : SetExprCode::UNIVERSE);
+    } else if (sign==-1) {
+      ax->encode(ret, false);
+      ret.add(SetExprCode::COMPLEMENT);
+    } else {
+      ax->encode(ret, true);
+    }
+    return ret;
+  }
+
+  Iter::Ranges::Virt::Iterator*
+  codeToIterator(const ViewArray<Set::SetView>& x,
+		 const SetExprCode& c, bool monotone) {
+
+    typedef Iter::Ranges::Virt::Iterator Iterator;
+
+    Support::DynamicStack<Iterator*> s;
+
+    int tmp = 0;
+    for (int i=0; i<c.size(); i++) {
+      switch (c[i]) {
+      case SetExprCode::COMPLEMENT:
+	{
+	  Iterator* it = s.pop();
+	  s.push(new Iter::Ranges::Virt::Compl<Limits::Set::int_min,
+		                               Limits::Set::int_max> (it));
+	}
+	break;
+      case SetExprCode::INTER:
+	{
+	  Iterator* ri = s.pop();
+	  Iterator* li = s.pop();
+	  s.push(new Iter::Ranges::Virt::Inter(li, ri));
+	}
+      	break;
+      case SetExprCode::UNION:
+	{
+	  Iterator* ri = s.pop();
+	  Iterator* li = s.pop();
+	  s.push(new Iter::Ranges::Virt::Union(li, ri));
+	}
+	break;
+      case SetExprCode::GLB:
+	if (monotone) {
+	  GlbRanges<SetView> r(x[tmp]);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<GlbRanges<SetView> >(r));
+	} else {
+	  LubRanges<SetView> r(x[tmp]);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<LubRanges<SetView> >(r));		
+	}
+	break;
+      case SetExprCode::LUB:
+	if (monotone) {
+	  LubRanges<SetView> r(x[tmp]);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<LubRanges<SetView> >(r));
+	} else {
+	  GlbRanges<SetView> r(x[tmp]);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<GlbRanges<SetView> >(r));		
+	}
+	break;
+      case SetExprCode::EMPTY:
+	{
+	  Iter::Ranges::Singleton it(1,0);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<Iter::Ranges::Singleton> (it));
+	}
+	break;
+      case SetExprCode::UNIVERSE:
+	{
+	  Iter::Ranges::Singleton it(Limits::Set::int_min,
+				     Limits::Set::int_max);
+	  s.push(new Iter::Ranges::Virt::RangesTemplate<Iter::Ranges::Singleton> (it));
+	}
+	break;
+      default:
+        tmp = c[i]-SetExprCode::LAST;
+        break;
+      }
+    }
+
+    return s.top();
+  }
+
+  SetExprRanges::SetExprRanges(const ViewArray<Set::SetView>& x,
+			       SetExpr& s,
+			       bool monotone) {
+    i = new Iter(codeToIterator(x, s.encode(), monotone));
+  }
+
+  SetExprRanges::SetExprRanges(const ViewArray<Set::SetView>& x,
+			       const SetExprCode& c,
+			       bool monotone) {
+    i = new Iter(codeToIterator(x, c, monotone));
+  }
+
+}
+
+// STATISTICS: set-prop