gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,69 @@
+/*
+ *  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.
+ *
+ */
+
+#include "gecode/set/projectors.hh"
+
+namespace Gecode {
+
+  void
+  ProjectorSet::add(const Projector& p) {
+    _ps.ensure(_count+1);    
+    new (&_ps[_count]) Projector(p);
+    for (int i=_count+1; i<_ps.size(); i++)
+      new (&_ps[i]) Projector();
+    _count++;
+
+    _arity = std::max(_arity, p.arity());
+  }
+
+  void
+  ProjectorSet::scope(Support::DynamicArray<int>& s) const {
+    // Clear out s
+    for (int i=_arity+1; i--;)
+      s[i] = Set::PC_SET_ANY + 1;
+
+    // Collect scope from individual projectors
+    for (int i=_count; i--; ) {
+      _ps[i].scope(s);
+    }
+  }
+
+  ExecStatus
+  ProjectorSet::check(Space* home, ViewArray<Set::SetView>& x) {
+    ExecStatus es = ES_SUBSUMED;
+    for (int i=0; i<_count; i++) {
+      ExecStatus es_new = _ps[i].check(home, x);
+      switch (es_new) {
+      case ES_FAILED:
+	return ES_FAILED;
+      case ES_SUBSUMED:
+	break;
+      default:
+	es = es_new;
+	break;
+      }
+    }
+    return es;
+  }
+
+}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/projector-set.icc

@@ -0,0 +1,66 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:31:32 +0200 (Fri, 25 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3573 $
+ *
+ *  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 {
+
+  forceinline
+  ProjectorSet::ProjectorSet(void) : _ps(0), _count(0), _arity(0) {}
+
+  forceinline void
+  ProjectorSet::update(Space* home, bool share, ProjectorSet& p) {
+    _ps.update(share, p._ps);
+    _count = p._count;
+    _arity = p._arity;
+  }
+  
+  forceinline int
+  ProjectorSet::arity(void) const { return _arity; }
+
+  template <bool negated>
+  inline ExecStatus
+  ProjectorSet::propagate(Space* home, ViewArray<Set::SetView>& x) {
+    int failedCount = 0;
+    for (int i=_count; i--; ) {
+      ExecStatus es = _ps[i].propagate<negated>(home, x);
+      switch (es) {
+      case ES_FAILED:
+	if (!negated)
+	  return ES_FAILED;
+	failedCount++;
+	break;
+      case ES_SUBSUMED:
+	return ES_SUBSUMED;
+      default:
+	break;
+      }
+    }
+    return failedCount==_count ? ES_FAILED : ES_NOFIX;
+  }
+
+  forceinline int
+  ProjectorSet::size(void) const { return _count; }
+
+  forceinline const Projector&
+  ProjectorSet::operator[](int i) const { return _ps[i]; }
+
+}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,125 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-17 16:23:29 +0200 (Thu, 17 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3547 $
+ *
+ *  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"
+
+namespace Gecode {
+
+  int
+  Projector::arity(void) const {
+    return _arity;
+  }
+
+  void codeScope(Support::DynamicArray<int>& s, const SetExprCode& c,
+		 bool monotone) {
+    int tmp = 0;
+    for (int i=0; i<c.size(); i++) {
+      switch (c[i]) {
+      case SetExprCode::COMPLEMENT:
+      case SetExprCode::INTER:
+      case SetExprCode::UNION:
+      case SetExprCode::EMPTY:
+      case SetExprCode::UNIVERSE:
+	break;
+      case SetExprCode::GLB:
+	if (s[tmp] == Set::PC_SET_ANY+1)
+	  s[tmp] = monotone ? Set::PC_SET_CGLB : Set::PC_SET_CLUB;
+	else if (monotone && s[tmp] != Set::PC_SET_CGLB)
+	  s[tmp] = Set::PC_SET_ANY;
+	else if (!monotone && s[tmp] != Set::PC_SET_CLUB)
+	  s[tmp] = Set::PC_SET_ANY;
+	break;
+      case SetExprCode::LUB:
+	if (s[tmp] == Set::PC_SET_ANY+1)
+	  s[tmp] = monotone ? Set::PC_SET_CLUB : Set::PC_SET_CGLB;
+	else if (monotone && s[tmp] != Set::PC_SET_CLUB)
+	  s[tmp] = Set::PC_SET_ANY;
+	else if (!monotone && s[tmp] != Set::PC_SET_CGLB)
+	  s[tmp] = Set::PC_SET_ANY;
+	break;
+      default:
+        tmp = c[i]-SetExprCode::LAST;
+        break;
+      }
+    }
+  }
+
+  void
+  Projector::scope(Support::DynamicArray<int>& s) const {
+    codeScope(s, glb, false);
+    codeScope(s, lub, true);
+  }
+
+  ExecStatus
+  Projector::check(Space* home, ViewArray<Set::SetView>& x) {
+    {
+      // Check if glb violates current upper bound of x[i]
+      SetExprRanges glbranges(x,glb,false);
+      Iter::Ranges::Size<SetExprRanges> g(glbranges);
+      Set::LubRanges<Set::SetView> xir(x[i]);
+      if (!Iter::Ranges::subset(g, xir))
+	return ES_FAILED;
+      while (g()) ++g;
+      if (g.size() > x[i].cardMax()) {
+	return ES_FAILED;
+      }	
+    }
+    {
+      // Check if lub violates current lower bound of x[i]
+      SetExprRanges lubranges(x,lub,true);
+      Iter::Ranges::Size<SetExprRanges> l(lubranges);
+      Set::GlbRanges<Set::SetView> xir(x[i]);
+      if (!Iter::Ranges::subset(xir, l))
+	return ES_FAILED;
+      while (l()) ++l;
+      if (l.size() < x[i].cardMin()) {
+	return ES_FAILED;
+      }
+    }
+    {
+      // Check if monotone interpretation of lower bound is
+      // contained in current lower bound of x[i]. If not, the constraint
+      // is not subsumed.
+      SetExprRanges glbranges(x,glb,true);
+      Set::GlbRanges<Set::SetView> xir(x[i]);
+      if (!Iter::Ranges::subset(glbranges, xir)) {
+	return ES_FIX;
+      }
+    }
+    {
+      // Check if current upper bound of x[i] if contained in
+      // anti-monotone interpretation of upper bound. If not, the constraint
+      // is not subsumed.
+      SetExprRanges lubranges(x,lub,false);
+      Set::LubRanges<Set::SetView> xir(x[i]);
+      if (!Iter::Ranges::subset(xir, lubranges)) {
+	return ES_FIX;
+      }
+    }
+    // Both bounds, interpreted monotonically (glb) and anti-monotonically
+    // (lub) are contained in the respective bounds of x[i]. This means
+    // that the bounds are entailed.
+    return ES_SUBSUMED;
+  }
+
+}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/projector.icc

@@ -0,0 +1,79 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-25 17:31:32 +0200 (Fri, 25 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3573 $
+ *
+ *  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 {
+
+  forceinline
+  Projector::Projector(void) : i(0), glb(), lub() {}
+  
+  forceinline
+  Projector::Projector(SetExpr::var_idx x,
+		       const SetExpr& sglb, const SetExpr& slub)
+    : i(x), glb(sglb.encode()), lub(slub.encode()),
+      _arity(std::max(sglb.arity(), slub.arity())) {}
+
+  template <bool negated>
+  inline ExecStatus
+  Projector::propagate(Space* home, ViewArray<Set::SetView>& x) {
+    if (negated) {
+      switch (ExecStatus es=check(home, x)) {
+      case ES_FAILED: return ES_SUBSUMED;
+      case ES_SUBSUMED: return ES_FAILED;
+      default: return es;
+      }
+    } else {
+      // Prune greatest lower and least upper bound according to given ranges
+      {
+	SetExprRanges glbranges(x,glb,false);
+	GECODE_ME_CHECK(x[i].includeI(home, glbranges));
+      }
+      {
+	SetExprRanges lubranges(x,lub,true);
+	GECODE_ME_CHECK(x[i].intersectI(home, lubranges));
+      }
+      return ES_NOFIX;
+    }
+  }
+
+  forceinline unsigned int
+  Projector::glbSize(ViewArray<Set::SetView>& x) {
+    SetExprRanges glbranges(x, glb, false);
+    return Iter::Ranges::size(glbranges);
+  }
+
+  forceinline unsigned int
+  Projector::lubSize(ViewArray<Set::SetView>& x) {
+    SetExprRanges lubranges(x, lub, true);
+    return Iter::Ranges::size(lubranges);
+  }
+
+  forceinline const SetExprCode&
+  Projector::getGlb(void) const { return glb; }
+
+  forceinline const SetExprCode&
+  Projector::getLub(void) const { return lub; }
+
+  forceinline int
+  Projector::getIdx(void) const { return i; }
+
+}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/projectors/propagator.hh

@@ -0,0 +1,127 @@
+/*
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_GENERATOR_PROJECOTRS_HH
+#define __GECODE_GENERATOR_PROJECTORS_HH
+
+#include "gecode/set/projectors.hh"
+
+namespace Gecode { namespace Set { namespace Projection {
+
+  /**
+   * \brief Nary projection propagator
+   */
+  template <bool negated>
+  class NaryProjection : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<SetView> x;
+    /// Array of PropConds
+    Support::SharedArray<PropCond> pc;
+    /// The projector set to propagate
+    ProjectorSet ps;
+    /// Constructor for cloning \a p
+    NaryProjection(Space* home, bool share, NaryProjection& p);
+    /// Constructor for creation
+    NaryProjection(Space* home, ViewArray<SetView>& x, ProjectorSet& ps);
+  public:
+    /// Cost function
+    virtual PropCost cost(void) const;
+    /// Delete propagator
+    virtual size_t dispose(Space* home);
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    static  ExecStatus post(Space* home, ViewArray<SetView>& x,
+			    ProjectorSet& ps);
+  };
+
+  /**
+   * \brief Reified Nary projection propagator
+   */
+  class ReNaryProjection : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<SetView> x;
+    /// Boolean control view
+    Gecode::Int::BoolView b;
+    /// The projector set to propagate
+    ProjectorSet ps;
+    /// Constructor for cloning \a p
+    ReNaryProjection(Space* home, bool share, ReNaryProjection& p);
+    /// Constructor for creation
+    ReNaryProjection(Space* home,ViewArray<SetView>& x,
+		     Gecode::Int::BoolView,
+		     ProjectorSet& ps);
+  public:
+    /// Cost function
+    virtual PropCost cost(void) const;
+    /// Delete propagator
+    GECODE_SET_EXPORT virtual size_t dispose(Space* home);
+    /// Copy propagator during cloning
+    GECODE_SET_EXPORT virtual Actor* copy(Space* home,bool);
+    /// Perform propagation
+    GECODE_SET_EXPORT virtual ExecStatus propagate(Space* home);
+    GECODE_SET_EXPORT static  ExecStatus post(Space* home,
+					      ViewArray<SetView>& x,
+					      Gecode::Int::BoolView b,
+					      ProjectorSet& ps);
+  };
+
+  /**
+   * \brief Nary cardinality projection propagator
+   */
+  class CardProjection : public Propagator {
+  protected:
+    /// Array of views
+    ViewArray<SetView> x;
+    /// Integer view for cardinality
+    Gecode::Int::IntView i;
+    /// Array of PropConds
+    Support::SharedArray<PropCond> pc;
+    /// The projector to propagate
+    Projector proj;
+    /// Constructor for cloning \a p
+    CardProjection(Space* home, bool share, CardProjection& p);
+    /// Constructor for creation
+    CardProjection(Space* home, ViewArray<SetView>& x,
+		   Gecode::Int::IntView i, Projector& ps);
+  public:
+    /// Cost function
+    virtual PropCost cost(void) const;
+    /// Delete propagator
+    virtual size_t dispose(Space* home);
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space* home,bool);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    static  ExecStatus post(Space* home, ViewArray<SetView>& x,
+			    Gecode::Int::IntView i, Projector& p);
+  };
+  
+}}}
+
+#include "gecode/set/projectors/propagator/nary.icc"
+#include "gecode/set/projectors/propagator/re-nary.icc"
+#include "gecode/set/projectors/propagator/card.icc"
+  
+#endif