gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,192 @@
+/*
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  /*
+   * Operations for set expression code
+   *
+   */
+
+  forceinline
+  SetExprCode::SetExprCode(void) : c(5), n(0) {}
+
+  forceinline
+  SetExprCode::SetExprCode(const SetExprCode& sc) : c(sc.c), n(sc.n) {}
+
+  forceinline void
+  SetExprCode::update(bool share, SetExprCode& sc) {
+    n=sc.n; c.update(share, sc.c);
+  }
+  
+  forceinline void
+  SetExprCode::add(int i) {
+    c.ensure(n+1);
+    c[n] = i;
+    n++;
+  }
+
+  forceinline int
+  SetExprCode::size(void) const { return n; }
+
+  forceinline int
+  SetExprCode::operator[](int i) const { return c[i]; }
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  forceinline
+  SetExpr::SetExpr(void) : ax(NULL), sign(1) {}
+
+  forceinline SetExpr
+  operator-(const SetExpr& s) { return SetExpr(s, -1); }
+
+  forceinline SetExpr
+  operator||(const SetExpr& s, const SetExpr& t) {
+    return SetExpr(s, 1, SetExpr::REL_UNION, t, 1);
+  }
+
+  forceinline SetExpr
+  operator&&(const SetExpr& s, const SetExpr& t) {
+    return SetExpr(s, 1, SetExpr::REL_INTER, t, 1);
+  }
+
+  forceinline SetExpr
+  operator-(const SetExpr& s, const SetExpr& t) {
+    return SetExpr(s, 1, SetExpr::REL_INTER, t, -1);
+  }
+
+  /**
+   * \brief Range iterator for set expressions
+   */
+  class SetExprRanges {
+  private:
+    /// Reference-counted range iterators with virtual member functions
+    class Iter;
+    /// The actual iterator
+    Iter *i;
+    const SetExprRanges& operator=(const SetExprRanges&);
+  public:
+    /// \name Constructors and destructor
+    //@{    
+    /// Copy constructor
+    SetExprRanges(const SetExprRanges&);
+    /** Initialize with the views \a x, a set expression \a s,
+     *  and a flag whether \a s is to be interpreted in a monotone or
+     *  anti-monotone way
+     */
+    SetExprRanges(const ViewArray<Set::SetView>& x, SetExpr& s,
+		  bool monotone);
+    /** Initialize with the views \a x, a set expression code \a c,
+     *  and a flag whether \a c is to be interpreted in a monotone or
+     *  anti-monotone way
+     */
+    SetExprRanges(const ViewArray<Set::SetView>& x,
+		  const SetExprCode& s,
+		  bool monotone);
+    /// Destructor
+    ~SetExprRanges(void);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    bool operator()(void);
+    /// Test whether iterator is still at a range or done
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /**
+   * \brief Reference-counted range iterators with virtual member functions
+   *
+   */
+  class SetExprRanges::Iter {
+  public:
+    /// The actual iterator
+    Gecode::Iter::Ranges::Virt::Iterator* i;
+    /// Reference count
+    int num;
+
+    /// Construct from iterator
+    Iter(Gecode::Iter::Ranges::Virt::Iterator*);
+    /// Destructor
+    ~Iter(void);
+    /// Increment reference count
+    void increment(void);
+    /// Decrement reference count
+    bool decrement(void);
+  };
+
+  forceinline
+  SetExprRanges::Iter::Iter(Gecode::Iter::Ranges::Virt::Iterator* i0)
+    : i(i0), num(1) {}
+  
+  forceinline
+  SetExprRanges::Iter::~Iter(void) { delete i; }
+
+  forceinline void
+  SetExprRanges::Iter::increment(void) { ++num; }
+
+  forceinline bool
+  SetExprRanges::Iter::decrement(void) { return --num==0; }
+
+  forceinline
+  SetExprRanges::SetExprRanges(const SetExprRanges& s) : i(s.i) {
+    i->increment();
+  }
+
+  forceinline
+  SetExprRanges::~SetExprRanges(void) {
+    if (i->decrement())
+      delete i;
+  }
+
+  forceinline bool
+  SetExprRanges::operator()(void) { return (*(i->i))(); }
+  
+  forceinline void
+  SetExprRanges::operator++(void) { ++(*(i->i)); }
+
+  forceinline int
+  SetExprRanges::min(void) const { return i->i->min(); }
+
+  forceinline int
+  SetExprRanges::max(void) const { return i->i->max(); }
+
+  forceinline unsigned int
+  SetExprRanges::width(void) const { return i->i->width(); }
+
+}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,96 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-05-29 09:42:21 +0200 (Mon, 29 May 2006) $ by $Author: schulte $
+ *     $Revision: 3246 $
+ *
+ *  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 {
+
+  /**
+   * \defgroup TaskPropSetPat Patterns for set propagators
+   *
+   * The optional last Boolean argument to the constructor for creation
+   * defines whether deletion must be forced.
+   * \ingroup TaskActor
+   */
+
+  //@{
+
+
+  /**
+   * \brief Set/Int connection propagator
+   *
+   * Stores single view of type \a View with propagation condition \a pcs
+   * and an integer variable with propagation condition \a pci.
+   */
+  template <class View, PropCond pcs, PropCond pci>
+  class IntSetPropagator : public Propagator {
+  protected:
+    View x0;
+    Gecode::Int::IntView x1;
+    /// Constructor for cloning
+    IntSetPropagator(Space* home,bool,IntSetPropagator&);
+    /// Constructor for creation
+    IntSetPropagator(Space* home,View,Gecode::Int::IntView,bool=false);
+  public:
+    /// Cost function (defined as PC_BINARY_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  //@}
+
+  template <class View, PropCond pcs, PropCond pci>
+  IntSetPropagator<View,pcs,pci>::IntSetPropagator
+  (Space* home, View y0, Gecode::Int::IntView y1, bool fd)
+    : Propagator(home,fd), x0(y0), x1(y1) {
+    x0.subscribe(home,this,pcs);
+    x1.subscribe(home,this,pci);
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  forceinline
+  IntSetPropagator<View,pcs,pci>::IntSetPropagator
+  (Space* home, bool share, IntSetPropagator<View,pcs,pci>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  PropCost
+  IntSetPropagator<View,pcs,pci>::cost(void) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  size_t
+  IntSetPropagator<View,pcs,pci>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pcs);
+      x1.cancel(home,this,pci);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+}
+
+// STATISTICS: set-prop
+

data/ext/gecode-1.3.1/gecode/set/rel-op-const.cc

@@ -0,0 +1,233 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  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/iter.hh"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode {
+  using namespace Gecode::Set;
+  using namespace Gecode::Set::Rel;
+  using namespace Gecode::Set::RelOp;
+
+  void
+  rel(Space* home, const IntSet& x, SetOpType op, SetVar y, SetRelType r,
+      SetVar z) {
+    ConstantView xv(home, x);
+    rel_op_post<ConstantView,SetView,SetView>(home, xv, op, y, r, z);
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, const IntSet& y, SetRelType r,
+      SetVar z) {
+    ConstantView yv(home, y);
+
+    if (op==SOT_MINUS) {
+      switch(r) {
+      case SRT_EQ:
+	{
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,SetView>
+			  ::post(home,cy,x,z)));
+	}
+	break;
+      case SRT_NQ:
+	{
+	  SetVar tmp(home);
+	  GECODE_ES_FAIL(home,
+			 (Distinct<SetView,SetView>
+			  ::post(home,z,tmp)));
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,SetView>
+			  ::post(home,cy,x,tmp)));
+	}
+	break;
+      case SRT_SUB:
+	{
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (SuperOfInter<SetView,
+			  ComplementView<ConstantView>,SetView>
+			  ::post(home,x,cy,z)));
+
+	}
+	break;
+      case SRT_SUP:
+	{
+	  SetVar tmp(home);
+	  GECODE_ES_FAIL(home,
+			 (SubSet<SetView,SetView>::post(home,z,tmp)));
+	  
+	  SetView xv(x);
+	  ComplementView<SetView> cx(xv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ConstantView,
+			  ComplementView<SetView>,SetView>
+			  ::post(home,yv,cx,tmp)));
+	}
+	break;
+      case SRT_DISJ:
+	{
+	  SetVar tmp(home);
+	  EmptyView emptyset;
+	  GECODE_ES_FAIL(home,(SuperOfInter<SetView,SetView,EmptyView>
+			       ::post(home, z, tmp, emptyset)));
+
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,SetView>
+			  ::post(home,cy,x,tmp)));
+	}
+	break;
+      case SRT_CMPL:
+	{
+	  SetView xv(x);
+	  ComplementView<SetView> cx(xv);
+	  GECODE_ES_FAIL(home,
+			 (Union<ConstantView,
+			  ComplementView<SetView>,
+			  SetView>::post(home, yv, cx, z)));
+	}
+	break;
+      }
+    } else {
+      rel_op_post<ConstantView,SetView,SetView>(home, yv, op, x, r, z);
+    }
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, SetVar y, SetRelType r,
+      const IntSet& z) {
+    ConstantView zv(home, z);
+    rel_op_post<SetView,SetView,ConstantView>(home, x, op, y, r, zv);
+  }  
+
+  void
+  rel(Space* home, const IntSet& x, SetOpType op, const IntSet& y,
+      SetRelType r, SetVar z) {
+    ConstantView xv(home, x);
+    ConstantView yv(home, y);
+    rel_op_post<ConstantView,ConstantView,SetView>(home, xv, op, yv, r, z);
+  }  
+
+  void
+  rel(Space* home, const IntSet& x, SetOpType op, SetVar y, SetRelType r,
+      const IntSet& z) {
+    ConstantView xv(home, x);
+    ConstantView zv(home, z);
+    rel_op_post<ConstantView,SetView,ConstantView>(home, xv, op, y, r, zv);
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, const IntSet& y, SetRelType r,
+      const IntSet& z) {
+    ConstantView yv(home, y);
+    ConstantView zv(home, z);
+
+    if (op==SOT_MINUS) {
+      switch(r) {
+      case SRT_EQ:
+	{
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,ConstantView>
+			  ::post(home,cy,x,zv)));
+	}
+	break;
+      case SRT_NQ:
+	{
+	  SetVar tmp(home);
+	  GECODE_ES_FAIL(home,
+			 (Distinct<ConstantView,SetView>
+			  ::post(home,zv,tmp)));
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,SetView>
+			  ::post(home,cy,x,tmp)));
+	}
+	break;
+      case SRT_SUB:
+	{
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (SuperOfInter<SetView,
+			  ComplementView<ConstantView>,ConstantView>
+			  ::post(home,x,cy,zv)));
+
+	}
+	break;
+      case SRT_SUP:
+	{
+	  // z <= tmp
+	  SetVar tmp(home,z,Limits::Set::int_min, Limits::Set::int_max);
+	  SetView xv(x);
+	  ComplementView<SetView> cx(xv);
+	  
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ConstantView,
+			  ComplementView<SetView>,SetView>
+			  ::post(home,yv,cx,tmp)));
+	}
+	break;
+      case SRT_DISJ:
+	{
+	  SetVar tmp(home);
+	  SetView tmpv(tmp);
+	  IntSetRanges zi(z);
+	  GECODE_ME_FAIL(home, tmpv.excludeI(home, zi));
+	  
+	  ComplementView<ConstantView> cy(yv);
+	  GECODE_ES_FAIL(home,
+			 (Intersection<ComplementView<ConstantView>,
+			  SetView,SetView>
+			  ::post(home,cy,x,tmp)));
+	}
+	break;
+      case SRT_CMPL:
+	{
+	  SetView xv(x);
+	  ComplementView<SetView> cx(xv);
+	  GECODE_ES_FAIL(home,
+			 (Union<ConstantView,
+			  ComplementView<SetView>,
+			  ConstantView>::post(home, yv, cx, zv)));
+	}
+	break;
+      }
+    } else {
+      rel_op_post<ConstantView,SetView,ConstantView>(home, yv, op, x, r, zv);
+    }
+  }  
+
+}
+
+// STATISTICS: set-post