gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/channel.cc

@@ -0,0 +1,62 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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/int/channel.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  channel(Space* home, const IntVarArgs& x, const IntVarArgs& y,
+	  IntConLevel icl) {
+    using namespace Channel;
+    int n = x.size();
+    if (n != y.size())
+      throw ArgumentSizeMismatch("Int::channel");
+    if (x.same(y))
+      throw ArgumentSame("Int::channel");
+    if (home->failed()) return;
+    if (n == 0)
+      return;
+
+    if (icl == ICL_VAL) {
+      ValInfo<IntView>* vi
+	= ValInfo<IntView>::allocate(home,2*n);
+      for (int i=n; i--; ) {
+	vi[i  ].init(x[i],n);
+	vi[i+n].init(y[i],n);
+      }
+      GECODE_ES_FAIL(home,Val<IntView>::post(home,n,vi));
+    } else {
+      DomInfo<IntView>* di
+	= DomInfo<IntView>::allocate(home,2*n);
+      for (int i=n; i--; ) {
+	di[i  ].init(x[i],n);
+	di[i+n].init(y[i],n);
+      }
+      GECODE_ES_FAIL(home,Dom<IntView>::post(home,n,di));
+    }
+  }
+
+}
+
+// STATISTICS: int-post

data/ext/gecode-1.3.1/gecode/int/channel.hh

@@ -0,0 +1,144 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 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.
+ *
+ */
+
+#ifndef __GECODE_INT_CHANNEL_HH__
+#define __GECODE_INT_CHANNEL_HH__
+
+#include "gecode/int.hh"
+#include "gecode/int/distinct.hh"
+
+/**
+ * \namespace Gecode::Int::Channel
+ * \brief %Channel propagators
+ */
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  /**
+   * \brief Base-class for channel propagators
+   *
+   */
+  template <class Info, PropCond pc>
+  class Base : public Propagator {
+  protected:
+    /// Number of views (actually twice as many for both x and y)
+    int n;
+    /// Total number of not assigned views (not known to be assigned)
+    int n_na;
+    /// View and information for both \a x and \a y
+    Info* xy;
+    /// Constructor for cloning \a p
+    Base(Space* home, bool share, Base<Info,pc>& p);
+    /// Constructor for posting
+    Base(Space* home, int n, Info* xy, bool fd=false);
+  public:
+    /// Propagation cost
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+
+  /**
+   * \brief Combine view with information for value propagation
+   *
+   */
+  template <class View> class ValInfo;
+
+  /**
+   * \brief Naive channel propagator
+   *
+   * Only propagates if views become assigned.
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Val : public Base<ValInfo<View>,PC_INT_VAL> {
+ protected:
+    using Base<ValInfo<View>,PC_INT_VAL>::n;
+    using Base<ValInfo<View>,PC_INT_VAL>::n_na;
+    using Base<ValInfo<View>,PC_INT_VAL>::xy;
+    /// Constructor for cloning \a p
+    Val(Space* home, bool share, Val& p);
+    /// Constructor for posting
+    Val(Space* home, int n, ValInfo<View>* xy);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for channeling on \a xy
+    static  ExecStatus post(Space* home, int n, ValInfo<View>* xy);
+  };
+
+  /**
+   * \brief Combine view with information for domain propagation
+   *
+   */
+  template <class View> class DomInfo;
+
+  /**
+   * \brief Domain-consistent channel propagator
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Dom : public Base<DomInfo<View>,PC_INT_DOM> {
+  protected:
+    using Base<DomInfo<View>,PC_INT_DOM>::n;
+    using Base<DomInfo<View>,PC_INT_DOM>::n_na;
+    using Base<DomInfo<View>,PC_INT_DOM>::xy;
+    /// Propagation controller for propagating distinct
+    Distinct::DomCtrl<View> dc;
+    /// Constructor for cloning \a p
+    Dom(Space* home, bool share, Dom& p);
+    /// Constructor for posting
+    Dom(Space* home, int n, DomInfo<View>* xy);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Propagation cost
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for channeling on \a xy
+    static  ExecStatus post(Space* home, int n, DomInfo<View>* xy);
+    /// Flush propagation controller
+    virtual void flush(void);
+    /// Returns size of propagation controller
+    virtual size_t size(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+}}}
+
+#include "gecode/int/channel/base.icc"
+#include "gecode/int/channel/stack.icc"
+#include "gecode/int/channel/val.icc"
+#include "gecode/int/channel/dom.icc"
+
+#endif
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/channel/base.icc

@@ -0,0 +1,60 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 Int { namespace Channel {
+
+  template <class Info, PropCond pc>
+  forceinline
+  Base<Info,pc>::Base(Space* home, int n0, Info* xy0, bool fd)
+    : Propagator(home,fd), n(n0), n_na(2*n), xy(xy0) {
+    for (int i=2*n; i--; )
+      xy[i].view.subscribe(home,this,pc);
+  }
+
+  template <class Info, PropCond pc>
+  forceinline
+  Base<Info,pc>::Base(Space* home, bool share, Base<Info,pc>& p)
+    : Propagator(home,share,p), n(p.n), n_na(p.n_na),
+      xy(Info::allocate(home,2*n)) {
+    for (int i=2*n; i--; )
+      xy[i].update(home,share,p.xy[i]);
+  }
+
+  template <class Info, PropCond pc>
+  PropCost
+  Base<Info,pc>::cost(void) const {
+    return PC_QUADRATIC_LO;
+  }
+
+  template <class Info, PropCond pc>
+  size_t
+  Base<Info,pc>::dispose(Space* home) {
+    if (!home->failed())
+      for (int i=2*n; i--; )
+	xy[i].view.cancel(home,this,pc);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/channel/dom.icc

@@ -0,0 +1,313 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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/iter.hh"
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  /**
+   * \brief Combine view with information for domain propagation
+   *
+   */
+  template <class View>
+  class DomInfo {
+  public:
+    View         view;
+    unsigned int card;
+    int          min;
+    int          max;
+    /// Allocate memory from space \a home for \a n elements
+    static DomInfo<View>* allocate(Space* home, int n);
+    /// Initialize
+    void init(View x, int n);
+    /// Update during cloning
+    void update(Space* home, bool share, DomInfo<View>& vcb);
+    /// Check whether propagation for assignment is to be done
+    bool doval(void) const;
+    /// Check whether propagation for domain is to be done
+    bool dodom(void) const;
+    /// Record that view got assigned
+    void assigned(void);
+    /// Record that one value got removed
+    void removed(int i);
+    /// Update the cardinality and bounds information after pruning
+    void done(void);
+  };
+
+  template <class View>
+  forceinline DomInfo<View>*
+  DomInfo<View>::allocate(Space* home, int n) {
+    return reinterpret_cast<DomInfo<View>*>
+      (home->alloc(n*sizeof(DomInfo<View>)));
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::init(View x, int n) {
+    view = x;
+    card = static_cast<unsigned int>(n);
+    min  = 0;
+    max  = n-1;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::update(Space* home, bool share, DomInfo<View>& di) {
+    view.update(home,share,di.view);
+    card = di.card;
+    min  = di.min;
+    max  = di.max;
+  }
+
+  template <class View>
+  forceinline bool
+  DomInfo<View>::doval(void) const {
+    return (card != 1) && view.assigned();
+  }
+
+  template <class View>
+  forceinline bool
+  DomInfo<View>::dodom(void) const {
+    return card != view.size();
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::assigned(void) {
+    card = 1;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::removed(int i) {
+    card--;
+    if (i == min)
+      min++;
+    else if (i == max)
+      max--;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::done(void) {
+    card = view.size();
+    min  = view.min();
+    max  = view.max();
+  }
+
+  // Propagate domain information from x to y
+  template <class View>
+  ExecStatus
+  prop_dom(Space* home, int n, DomInfo<View>* x, DomInfo<View>* y,
+	   ProcessStack& ya) {
+    for (int i = n; i--; )
+      // Only views with not yet propagated missing values
+      if (x[i].dodom()) {
+	// Iterate the values in the complement of x[i]
+	ViewRanges<IntView>
+	  xir(x[i].view);
+	Iter::Ranges::ComplVal<ViewRanges<IntView> >
+	  xirc(x[i].min,x[i].max,xir);
+	Iter::Ranges::ToValues<Iter::Ranges::ComplVal<ViewRanges<IntView> > >
+	  jv(xirc);
+	while (jv()) {
+	  // j is not in the domain of x[i], so prune i from y[j]
+	  int j = jv.val();
+	  ModEvent me = y[j].view.nq(home,i);
+	  if (me_failed(me))
+	    return ES_FAILED;
+	  if (me_modified(me))
+	    if (me == ME_INT_VAL) {
+	      // Record that y[j] has been assigned and must be propagated
+	      ya.push(j);
+	    } else {
+	      // Obvious as x[i] is different from j
+	      y[j].removed(i);
+	    }
+	  ++jv;
+	}
+	// Update which values have been propagated and what are the new bounds
+	x[i].done();
+      }
+    return ES_OK;
+  }
+
+  /*
+   * The actual propagator
+   *
+   */
+  template <class View>
+  forceinline
+  Dom<View>::Dom(Space* home, int n, DomInfo<View>* xy)
+    : Base<DomInfo<View>,PC_INT_DOM>(home,n,xy,true) {}
+
+  template <class View>
+  forceinline
+  Dom<View>::Dom(Space* home, bool share, Dom<View>& p)
+    : Base<DomInfo<View>,PC_INT_DOM>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  Dom<View>::copy(Space* home, bool share) {
+    return new (home) Dom<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  Dom<View>::cost(void) const {
+    return (View::pme(this) == ME_INT_VAL) ? PC_QUADRATIC_LO : PC_CUBIC_HI;
+  }
+
+  template <class View>
+  ExecStatus
+  Dom<View>::propagate(Space* home) {
+    GECODE_AUTOARRAY(int, __xa, n+1);
+    GECODE_AUTOARRAY(int, __ya, n+1);
+    ProcessStack xa(__xa);
+    ProcessStack ya(__ya);
+
+    DomInfo<View>* x = xy;
+    DomInfo<View>* y = xy+n;
+
+    if (View::pme(this) == ME_INT_VAL) {
+      // Scan x and y for assigned but not yet propagated views
+      for (int i = n; i--; ) {
+	if (x[i].doval()) xa.push(i);
+	if (y[i].doval()) ya.push(i);
+      }
+
+      do {
+	// Propagate assigned views for x
+	if (prop_val<View,DomInfo<View> >(home,n,x,y,n_na,xa,ya) == ES_FAILED)
+	  return ES_FAILED;
+	// Propagate assigned views for y
+	if (prop_val<View,DomInfo<View> >(home,n,y,x,n_na,ya,xa) == ES_FAILED)
+	  return ES_FAILED;
+	assert(ya.empty());
+      } while (!xa.empty());
+      this->ES_FIX_PARTIAL(View::pme(ME_INT_DOM));
+    }
+
+    // Process changed views for y
+    // This propagates from y to x and possibly records xs that
+    // got assigned
+    if (prop_dom(home,n,y,x,xa) == ES_FAILED)
+      return ES_FAILED;
+
+    // Process assigned views for x
+    if (prop_val<View,DomInfo<View> >(home,n,x,y,n_na,xa,ya) == ES_FAILED)
+      return ES_FAILED;
+
+    // Perform domain consistent propagation for distinct on the x views
+    if (dc.available()) {
+      GECODE_ES_CHECK(dc.sync());
+    } else {
+      GECODE_AUTOARRAY(View,xv,n);
+      for (int i=n; i--; )
+	xv[i] = x[i].view;
+      GECODE_ES_CHECK(dc.init(n,&xv[0]));
+    }
+    dc.propagate(home);
+    // This might assign some more views in x which goes unnoticed
+    // (that is, not recorded in xa). This must be checked and propagated
+    // to the y views, however the distinctness on x is already
+    // propagated.
+    for (int i=n; i--; )
+      if (x[i].doval()) {
+	int j = x[i].view.val();
+	// Assign the y variable to i (or test if already assigned!)
+	ModEvent me = y[j].view.eq(home,i);
+	if (me_failed(me))
+	  return ES_FAILED;
+	if (me_modified(me)) {
+	  // Record that y[j] has been assigned and must be propagated
+	  assert(me == ME_INT_VAL);
+	  // Otherwise the modification event would not be ME_INT_VAL
+	  ya.push(j);
+	}
+	x[i].assigned(); n_na--;
+      }
+
+    // Process changed views for x
+    // This propagates from x to y and possibly records ys that
+    // got assigned
+    if (prop_dom(home,n,x,y,ya) == ES_FAILED)
+      return ES_FAILED;
+
+    // Process assigned view again (some might have been found above)
+    while (!xa.empty() || !ya.empty()) {
+      // Process assigned views for x
+      if (prop_val<View,DomInfo<View> >(home,n,x,y,n_na,xa,ya) == ES_FAILED)
+	return ES_FAILED;
+      // Process assigned views for y
+      if (prop_val<View,DomInfo<View> >(home,n,y,x,n_na,ya,xa) == ES_FAILED)
+	return ES_FAILED;
+    };
+
+    return (n_na == 0) ? ES_SUBSUMED : ES_FIX;
+  }
+
+  template <class View>
+  ExecStatus
+  Dom<View>::post(Space* home, int n, DomInfo<View>* xy) {
+    assert(n > 0);
+    if (n == 1) {
+      GECODE_ME_CHECK(xy[0].view.eq(home,0));
+      GECODE_ME_CHECK(xy[1].view.eq(home,0));
+      return ES_OK;
+    }
+    for (int i=2*n; i--; ) {
+      GECODE_ME_CHECK(xy[i].view.gq(home,0));
+      GECODE_ME_CHECK(xy[i].view.le(home,n));
+    }
+    (void) new (home) Dom<View>(home,n,xy);
+    return ES_OK;
+  }
+
+  template <class View>
+  void
+  Dom<View>::flush(void) {
+    dc.flush();
+  }
+
+  template <class View>
+  size_t
+  Dom<View>::size(void) const {
+    return dc.size();
+  }
+
+  template <class View>
+  size_t
+  Dom<View>::dispose(Space* home) {
+    dc.dispose();
+    (void) Base<DomInfo<View>,PC_INT_DOM>::dispose(home);
+    return sizeof(*this);
+  }
+
+
+}}}
+
+// STATISTICS: int-prop
+