gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,81 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 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/int/dom.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  dom(Space* home, IntVar x, int min, int max, IntConLevel) {
+    if (home->failed()) return;
+    IntView xv(x);
+    GECODE_ME_FAIL(home,xv.gq(home,min));
+    GECODE_ME_FAIL(home,xv.lq(home,max));
+  }
+
+  void
+  dom(Space* home, IntVarArgs& x, int min, int max, IntConLevel) {
+    if (home->failed()) return;
+    for (int i=x.size(); i--; ) {
+      IntView xv(x[i]);
+      GECODE_ME_FAIL(home,xv.gq(home,min));
+      GECODE_ME_FAIL(home,xv.lq(home,max));
+    }
+  }
+
+  void
+  dom(Space* home, IntVar x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    IntView xv(x);
+    IntSetRanges ris(is);
+    GECODE_ME_FAIL(home,xv.inter(home,ris));
+  }
+
+  void
+  dom(Space* home, IntVarArgs& x, const IntSet& is, IntConLevel) {
+    if (home->failed()) return;
+    for (int i = x.size(); i--; ) {
+      IntSetRanges ris(is);
+      IntView xv(x[i]);
+      GECODE_ME_FAIL(home,xv.inter(home,ris));
+    }
+  }
+
+  void
+  dom(Space* home, IntVar x, int min, int max, BoolVar b, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,Dom::ReRange<IntView>::post(home,x,min,max,b));
+  }
+
+
+  void
+  dom(Space* home, IntVar x, const IntSet& is, BoolVar b, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,Dom::ReIntSet<IntView>::post(home,x,is,b));
+  }
+
+}
+
+// STATISTICS: int-post
+

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

@@ -0,0 +1,101 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_DOM_HH__
+#define __GECODE_INT_DOM_HH__
+
+#include "gecode/int.hh"
+#include "gecode/int/rel.hh"
+#include "gecode/iter.hh"
+
+/**
+ * \namespace Gecode::Int::Dom
+ * \brief Domain propagators
+ */
+
+namespace Gecode { namespace Int { namespace Dom {
+
+  /**
+   * \brief Reified range dom-propagator
+   *
+   * Requires \code #include "gecode/int/dom.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class ReRange : public ReUnaryPropagator<View,PC_INT_BND,BoolView> {
+  protected:
+    using ReUnaryPropagator<View,PC_INT_BND,BoolView>::x0;
+    using ReUnaryPropagator<View,PC_INT_BND,BoolView>::b;
+    /// Minimum of range
+    int min;
+    /// Maximum of range
+    int max;
+    /// Constructor for cloning \a p
+    ReRange(Space* home, bool share, ReRange& p);
+    /// Constructor for creation
+    ReRange(Space* home, View x, int min, int max, BoolView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$ (l\leq x \leq m) \Leftrightarrow b\f$
+    static ExecStatus post(Space* home, View x, int min, int max, BoolView b);
+  };
+
+  /**
+   * \brief Reified domain dom-propagator
+   *
+   * Requires \code #include "gecode/int/dom.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class ReIntSet : public ReUnaryPropagator<View,PC_INT_DOM,BoolView> {
+  protected:
+    using ReUnaryPropagator<View,PC_INT_DOM,BoolView>::x0;
+    using ReUnaryPropagator<View,PC_INT_DOM,BoolView>::b;
+
+    /// %Domain
+    IntSet is;
+    /// Constructor for cloning \a p
+    ReIntSet(Space* home, bool share, ReIntSet& p);
+    /// Constructor for creation
+    ReIntSet(Space* home, View x, const IntSet& s, BoolView b);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$ (x \in d) \Leftrightarrow b\f$
+    static ExecStatus post(Space* home, View x, const IntSet& s, BoolView b);
+  };
+
+}}}
+
+#include "gecode/int/dom/range.icc"
+#include "gecode/int/dom/spec.icc"
+
+#endif
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,85 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  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 Dom {
+
+  template <class View>
+  forceinline
+  ReRange<View>::ReRange(Space* home, View x, int min0, int max0, BoolView b)
+    : ReUnaryPropagator<View,PC_INT_BND,BoolView>(home,x,b),
+      min(min0), max(max0) {}
+
+  template <class View>
+  ExecStatus
+  ReRange<View>::post(Space* home, View x, int min, int max, BoolView b) {
+    if (min > max)
+      return ES_FAILED;
+    if ((max < x.min()) || (min > x.max())) {
+      GECODE_ME_CHECK(b.t_zero(home));
+    } else if ((min <= x.min()) && (x.max() <= max)) {
+      GECODE_ME_CHECK(b.t_one(home));
+    } else {
+      (void) new (home) ReRange<View>(home,x,min,max,b);
+    }
+    return ES_OK;
+  }
+
+
+  template <class View>
+  forceinline
+  ReRange<View>::ReRange(Space* home, bool share, ReRange& p)
+    : ReUnaryPropagator<View,PC_INT_BND,BoolView>(home,share,p),
+      min(p.min), max(p.max) {}
+
+  template <class View>
+  Actor*
+  ReRange<View>::copy(Space* home, bool share) {
+    return new (home) ReRange<View>(home,share,*this);
+  }
+
+
+  template <class View>
+  ExecStatus
+  ReRange<View>::propagate(Space* home) {
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.gq(home,min));
+      GECODE_ME_CHECK(x0.lq(home,max));
+      return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      Iter::Ranges::Singleton r(min,max);
+      GECODE_ME_CHECK(x0.minus(home,r));
+      return ES_SUBSUMED;
+    }
+    if ((x0.max() <= max) && (x0.min() >= min)) {
+      b.t_one_none(home); return ES_SUBSUMED;
+    }
+    if ((x0.max() < min) || (x0.min() > max)) {
+      b.t_zero_none(home); return ES_SUBSUMED;
+    }
+    return ES_FIX;
+  }
+
+
+}}}
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,85 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-07-19 14:57:38 +0200 (Wed, 19 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3413 $
+ *
+ *  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 Dom {
+
+  template <class View>
+  forceinline
+  ReIntSet<View>::ReIntSet
+  (Space* home, View x, const IntSet& s, BoolView b)
+    : ReUnaryPropagator<View,PC_INT_DOM,BoolView>(home,x,b,true), is(s) {}
+
+  template <class View>
+  ExecStatus
+  ReIntSet<View>::post(Space* home, View x, const IntSet& s, BoolView b) {
+    if (s.size() == 0) {
+      GECODE_ME_CHECK(b.t_zero(home));
+    } else if (s.size() == 1) {
+      return ReRange<View>::post(home,x,s.min(),s.max(),b);
+    } else {
+      (void) new (home) ReIntSet<View>(home,x,s,b);
+    }
+    return ES_OK;
+  }
+
+
+  template <class View>
+  forceinline
+  ReIntSet<View>::ReIntSet(Space* home, bool share, ReIntSet& p)
+    : ReUnaryPropagator<View,PC_INT_DOM,BoolView>(home,share,p) {
+    is.update(share,p.is);
+  }
+
+  template <class View>
+  Actor*
+  ReIntSet<View>::copy(Space* home, bool share) {
+    return new (home) ReIntSet(home,share,*this);
+  }
+
+  template <class View>
+  ExecStatus
+  ReIntSet<View>::propagate(Space* home) {
+    IntSetRanges i_is(is);
+    if (b.one()) {
+      GECODE_ME_CHECK(x0.inter(home,i_is)); return ES_SUBSUMED;
+    }
+    if (b.zero()) {
+      GECODE_ME_CHECK(x0.minus(home,i_is)); return ES_SUBSUMED;
+    }
+
+    ViewRanges<View> i_x(x0);
+
+    switch (Iter::Ranges::subsumes(i_is,i_x)) {
+    case Iter::Ranges::SS_SUBSUMED:
+      b.t_one_none(home); return ES_SUBSUMED;
+    case Iter::Ranges::SS_EMPTY:
+      b.t_zero_none(home); return ES_SUBSUMED;
+    case Iter::Ranges::SS_NONE:
+      break;
+    default: GECODE_NEVER;
+    }
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

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

@@ -0,0 +1,58 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 15:23:45 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3509 $
+ *
+ *  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/element.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  element(Space* home, const IntArgs& c, IntVar x0, IntVar x1,
+	  IntConLevel) {
+    if (home->failed()) return;
+    Element::IntSharedArray cs(c.size());
+    for (int i = c.size(); i--; )
+      if ((c[i] < Limits::Int::int_min) || (c[i] > Limits::Int::int_max))
+	throw NumericalOverflow("Int::element");
+      else
+	cs[i] = c[i];
+    GECODE_ES_FAIL(home,(Element::Int<IntView,IntView>::post(home,cs,x0,x1)));
+  }
+
+  void
+  element(Space* home, const IntVarArgs& c, IntVar x0, IntVar x1,
+	  IntConLevel icl) {
+    if (home->failed()) return;
+    Element::IdxView<IntView>* iv = Element::IdxView<IntView>::init(home,c);
+    if (icl == ICL_BND) {
+      GECODE_ES_FAIL(home,(Element::ViewBnd<IntView,IntView>
+			   ::post(home,iv,c.size(),x0,x1)));
+    } else {
+      GECODE_ES_FAIL(home,(Element::ViewDom<IntView,IntView>
+			   ::post(home,iv,c.size(),x0,x1)));
+    }
+  }
+
+}
+
+// STATISTICS: int-post
+

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

@@ -0,0 +1,203 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_ELEMENT_HH__
+#define __GECODE_INT_ELEMENT_HH__
+
+#include "gecode/int.hh"
+#include "gecode/int/rel.hh"
+
+#include "gecode/support/shared-array.hh"
+#include "gecode/support/sort.hh"
+
+#include "gecode/iter.hh"
+
+/**
+ * \namespace Gecode::Int::Element
+ * \brief %Element propagators
+ */
+
+namespace Gecode { namespace Int { namespace Element {
+
+  /*
+   * Element constraint for array of integers
+   *
+   */
+
+  typedef Support::SharedArray<int> IntSharedArray;
+
+  /// Class for index-value ma
+  class IdxValMap;
+
+  /**
+   * \brief %Element propagator for array of integers
+   *
+   * Requires \code #include "gecode/int/element.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class ViewA, class ViewB>
+  class Int : public Propagator {
+  protected:
+    /// View for index
+    ViewA          x0;
+    /// View for result
+    ViewB          x1;
+    /// Shared array of integer values
+    IntSharedArray c;
+    /// Cache for index-value map
+    IdxValMap*     ivm;
+    /// Constructor for cloning \a p
+    Int(Space* home, bool shared, Int& p);
+    /// Constructor for creation
+    Int(Space* home, IntSharedArray& i, ViewA x0, ViewB x1);
+  public:
+    /// Perform copying during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Const function (return PC_BINARY_HI)
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$i_{x_0}=x_1\f$
+    static  ExecStatus post(Space* home, IntSharedArray& i,
+			    ViewA x0, ViewB x1);
+    /// Flush cached index-value map
+    virtual void flush(void);
+    /// Return size of index-value map
+    virtual size_t size(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+
+
+  /**
+   * \brief Class for index-view map
+   *
+   */
+  template <class ViewB> class IdxView;
+
+  /**
+   * \brief Base-class for element propagator for array of views
+   *
+   */
+  template <class ViewA, class ViewB, PropCond pcb>
+  class View : public Propagator {
+  protected:
+    /// View for index
+    ViewA    x0;
+    /// View for result
+    ViewB    x1;
+    /// Number of elements in index-view map
+    int      n;
+    /// Current index-view map
+    IdxView<ViewB>* iv;
+    /// Constructor for cloning \a p
+    View(Space* home, bool share, View& p);
+    /// Constructor for creation
+    View(Space* home, IdxView<ViewB>* iv, int n, ViewA x0, ViewB x1);
+  public:
+    // Cost function (defined as dynamic PC_LINEAR_LO)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+
+  /**
+   * \brief Bounds-consistent element propagator for array of views
+   *
+   * Requires \code #include "gecode/int/element.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class ViewA, class ViewB>
+  class ViewBnd : public View<ViewA,ViewB,PC_INT_BND> {
+  protected:
+    using View<ViewA,ViewB,PC_INT_BND>::x0;
+    using View<ViewA,ViewB,PC_INT_BND>::x1;
+    using View<ViewA,ViewB,PC_INT_BND>::n;
+    using View<ViewA,ViewB,PC_INT_BND>::iv;
+
+    /// Constructor for cloning \a p
+    ViewBnd(Space* home, bool share, ViewBnd& p);
+    /// Constructor for creation
+    ViewBnd(Space* home, IdxView<ViewB>* iv, int n, ViewA x0, ViewB x1);
+  public:
+    /// Perform copying during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$iv_{x_0}=x_1\f$
+    static  ExecStatus post(Space* home, IdxView<ViewB>* iv, int n,
+			    ViewA x0, ViewB x1);
+  };
+
+  /**
+   * \brief Domain-consistent element propagator for array of views
+   *
+   * The propagator uses staging: first it uses
+   * bounds-propagation on the array of views and the uses
+   * domain-propagation on the array of views.
+   *
+   * Requires \code #include "gecode/int/element.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class ViewA, class ViewB>
+  class ViewDom : public View<ViewA,ViewB,PC_INT_DOM> {
+  protected:
+    using View<ViewA,ViewB,PC_INT_DOM>::x0;
+    using View<ViewA,ViewB,PC_INT_DOM>::x1;
+    using View<ViewA,ViewB,PC_INT_DOM>::n;
+    using View<ViewA,ViewB,PC_INT_DOM>::iv;
+
+    /// Constructor for cloning \a p
+    ViewDom(Space* home, bool share, ViewDom& p);
+    /// Constructor for creation
+    ViewDom(Space* home, IdxView<ViewB>* iv, int n, ViewA x0, ViewB x1);
+  public:
+    /// Perform copying during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If in stage for bounds-propagation defined as dynamic PC_LINEAR_LO,
+     * otherwise as dynamic PC_LINEAR_HI.
+     *
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator for \f$iv_{x_0}=x_1\f$
+    static  ExecStatus post(Space* home, IdxView<ViewB>* iv, int n,
+			    ViewA x0, ViewB x1);
+  };
+
+}}}
+
+#include "gecode/int/element/int.icc"
+#include "gecode/int/element/view.icc"
+
+#endif
+
+
+// STATISTICS: int-prop
+