gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/minimodel/matrix.icc

@@ -0,0 +1,118 @@
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Bugfixes provided by:
+ *     Olof Sivertsson <olof@olofsivertsson.com>
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3513 $
+ *
+ *  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 MiniModel {
+
+  template <class A>
+  inline
+  Matrix<A>::Slice::Slice(Matrix<A>& a,
+			  unsigned int fc, unsigned int tc,
+			  unsigned int fr, unsigned int tr)
+    : _r(0), _fc(fc), _tc(tc), _fr(fr), _tr(tr) {
+    if (tc > a.width() || tr > a.height())
+      throw ArgumentOutOfRange("MiniModel::Matrix::Slice::Slice");
+    if (fc >= tc || fr >= tr)
+      throw ArgumentOutOfRange("MiniModel::Matrix::Slice::Slice");
+
+    _r = args_type((tc-fc)*(tr-fr));
+
+    int i = 0;
+    for (unsigned int h = fr; h < tr; ++h) {
+      for (unsigned int w = fc; w < tc; ++w) {
+	_r[i++] = a(w, h);
+      }
+    }
+  }
+
+  template <class A>
+  inline
+  Matrix<A>::Slice::operator typename Matrix<A>::args_type(void) {
+    return _r;
+  }
+  template <class A>
+  inline
+  Matrix<A>::Slice::operator Matrix<typename Matrix<A>::args_type>(void) {
+    return Matrix<args_type>(_r, _tc-_fc, _tr-_fr);
+  }
+
+
+  template <class A>
+  inline
+  Matrix<A>::Matrix(A a, unsigned int w, unsigned int h)
+    : _a(a), _w(w), _h(h) {
+    if (_w * _h != static_cast<unsigned int>(_a.size()))
+      throw ArgumentSizeMismatch("MiniModel::Matrix::Matrix(A, w, h)");
+  }
+
+  template <class A>
+  inline
+  Matrix<A>::Matrix(A a, unsigned int n)
+    : _a(a), _w(n), _h(n) {
+    if (n*n != static_cast<unsigned int>(_a.size()))
+      throw ArgumentSizeMismatch("MiniModel::Matrix::Matrix(A, n)");
+  }
+
+  template <class A>
+  inline unsigned int
+  Matrix<A>::width(void) const  { return _w; }
+  template <class A>
+  inline unsigned int
+  Matrix<A>::height(void) const { return _h; }
+  template <class A>
+  inline typename Matrix<A>::args_type const
+  Matrix<A>::get_array(void) {
+    return args_type(_a);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::value_type&
+  Matrix<A>::operator()(unsigned int c, unsigned int r) {
+    if (c >= _w || r >= _h)
+      throw ArgumentOutOfRange("MiniModel::Matrix::operator()");
+
+    return _a[r*_w + c];
+  }
+
+  template <class A>
+  inline typename Matrix<A>::Slice
+  Matrix<A>::slice(unsigned int fc, unsigned int tc,
+		   unsigned int fr, unsigned int tr) {
+    return Slice(*this, fc, tc, fr, tr);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::args_type
+  Matrix<A>::row(int r) {
+    return slice(0, width(), r, r+1);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::args_type
+  Matrix<A>::col(int c) {
+    return slice(c, c+1, 0, height());
+  }
+
+}}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/minimodel/scheduling.cc

@@ -0,0 +1,241 @@
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-09-04 14:13:40 +0200 (Mon, 04 Sep 2006) $ by $Author: zayenz $
+ *     $Revision: 3584 $
+ *
+ *  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/minimodel.hh"
+
+#include <algorithm>
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  producer_consumer(Space *home,
+		    const IntVarArgs& produce_date, const IntArgs& produce_amount,
+		    const IntVarArgs& consume_date, const IntArgs& consume_amount,
+		    int initial, IntConLevel cl)
+  {
+    if (produce_date.size() != produce_amount.size() ||
+	consume_date.size() != consume_amount.size())
+      throw new ArgumentSizeMismatch("Minimodel::producer_consumer");
+
+    int ntasks = produce_date.size() + consume_date.size();
+
+    IntArgs machine(ntasks), height(ntasks), limit(1);
+    IntVarArgs start(ntasks), duration(ntasks), end(ntasks);
+
+    int i = 0;
+    int sum_height = initial;
+    if (initial < Limits::Int::int_min ||
+	initial > Limits::Int::int_max)
+      throw new NumericalOverflow("MiniModel::producer_consumer");
+
+    int maxval = 0;
+    for (int j = produce_date.size(); j--; )
+	maxval = std::max(produce_date[i].max(), maxval);
+    for (int j = consume_date.size(); j--; )
+	maxval = std::max(consume_date[j].max(), maxval);
+    ++maxval;
+
+    IntVar minvar = IntVar(home, 0, 0);
+    IntVar maxvar = IntVar(home, maxval, maxval);
+
+
+    // Construct producer tasks
+    for (int k = produce_date.size(); k--; ++i) {
+      sum_height += produce_amount[k];
+      machine[i] = 0;
+
+      start[i] = minvar;
+      end[i] = produce_date[k];
+      duration[i] = IntVar(home, end[i].min(), end[i].max());
+      height[i] = produce_amount[k];
+      if (height[i] < Limits::Int::int_min ||
+	  height[i] > Limits::Int::int_max)
+	throw new NumericalOverflow("MiniModel::producer_consumer");
+    }
+
+    // Construct consumer tasks
+    for (int k = consume_date.size(); k--; ++i) {
+      machine[i] = 0;
+
+      start[i] = consume_date[k];
+      end[i] = maxvar;
+      duration[i] = IntVar(home, maxval - start[i].max(),
+			   maxval - start[i].min());
+      height[i] = consume_amount[k];
+      if (height[i] < Limits::Int::int_min ||
+	  height[i] > Limits::Int::int_max)
+	throw new NumericalOverflow("MiniModel::producer_consumer");
+    }
+
+    limit[0] = sum_height;
+
+    cumulatives(home, machine, start, duration, end, height, limit, true, cl);
+  }
+
+
+  namespace {
+    /// Delayed optimized construction of constant value.
+    class ConstVar {
+      Space *home_;
+      int val_;
+    public:
+      ConstVar(Space *home, int val) : home_(home), val_(val) {}
+
+      operator int() { return val_; }
+      operator IntVar() { return IntVar(home_, val_, val_); }
+    };
+
+    /// Return an IntVar representing the constant value \a val
+    IntVar make_intvar(Space *home, int val)
+    {
+      return IntVar(home, val, val);
+    }
+
+    /// Return the IntVar  \a iv directly
+    IntVar make_intvar(Space *home, IntVar iv)
+    {
+      return iv;
+    }
+
+    template<class Duration, class Height>
+    void
+    post_cumulative(Space *home, const IntVarArgs& start, const Duration& duration,
+		    const Height& height, int limit, bool at_most, IntConLevel cl)
+    {
+      if (start.size() != duration.size() ||
+	  duration.size() !=  height.size())
+	throw new ArgumentSizeMismatch("MiniModel::cumulative");
+
+      if (limit < Limits::Int::int_min ||
+	  limit > Limits::Int::int_max)
+	throw new NumericalOverflow("MiniModel::cumulative");
+
+      int n = start.size() + !at_most;
+      IntArgs m(n), l(1, limit);
+      IntVarArgs s(n), d(n), e(n);
+      Height h(n);
+
+      if (!at_most) {
+	int smin = Limits::Int::int_max, 
+	    smax = Limits::Int::int_min, 
+	    emin = Limits::Int::int_max, 
+	    emax = Limits::Int::int_min;
+	IntVarArgs end(n-1);
+	for (int i = start.size(); i--; ) {
+	  m[i] = 0;
+	  s[i] = start[i];
+	  smin = std::min(s[i].min(), smin);
+	  smax = std::max(s[i].max(), smax);
+	  d[i] = make_intvar(home, duration[i]);
+	  e[i] = IntVar(home, Limits::Int::int_min, Limits::Int::int_max);
+	  end[i] = e[i];
+	  emin = std::min(e[i].min(), emin);
+	  emax = std::max(e[i].max(), emax);
+	  h[i] = height[i];
+	}
+	m[n-1] = 0;
+	s[n-1] = IntVar(home, smin, smax);
+	d[n-1] = IntVar(home, 0, emax - smin);
+	e[n-1] = IntVar(home, emin, emax);
+	h[n-1] = ConstVar(home, 0);
+	
+	min(home, start, s[n-1]);
+	max(home, end, e[n-1]);
+      } else {
+	for (int i = start.size(); i--; ) {
+	  m[i] = 0;
+	  s[i] = start[i];
+	  d[i] = make_intvar(home, duration[i]);
+	  e[i] = IntVar(home, s[i].min()+d[i].min(), s[i].max()+d[i].max());
+	  h[i] = height[i];
+	}
+      }
+
+      cumulatives(home, m, s, d, e, h, l, at_most, cl);
+    }
+
+  }
+
+  void
+  cumulative(Space *home, const IntVarArgs& start, const IntVarArgs& duration,
+	     const IntVarArgs& height, int limit, bool at_most, IntConLevel cl)
+  {
+    post_cumulative(home, start, duration, height, limit, at_most, cl);
+  }
+
+  void
+  cumulative(Space *home, const IntVarArgs& start, const IntArgs& duration,
+	     const IntVarArgs& height, int limit, bool at_most, IntConLevel cl)
+  {
+    post_cumulative(home, start, duration, height, limit, at_most, cl);
+  }
+
+  void
+  cumulative(Space *home, const IntVarArgs& start, const IntVarArgs& duration,
+	     const IntArgs& height, int limit, bool at_most, IntConLevel cl)
+  {
+    post_cumulative(home, start, duration, height, limit, at_most, cl);
+  }
+
+  void
+  cumulative(Space *home, const IntVarArgs& start, const IntArgs& duration,
+	     const IntArgs& height, int limit, bool at_most, IntConLevel cl)
+  {
+    post_cumulative(home, start, duration, height, limit, at_most, cl);
+  }
+
+
+  namespace {
+    template <class Duration>
+    void
+    post_serialized(Space *home, const IntVarArgs& start, const Duration& duration,
+	       IntConLevel cl)
+    {
+      if (start.size() != duration.size())
+	throw new ArgumentSizeMismatch("MiniModel::serialized");
+
+      IntArgs height(start.size());
+      for (int i = start.size(); i--; ) height[i] = 1;
+
+      post_cumulative(home, start, duration, height, 1, true, cl);
+    }
+  }
+
+  void
+  serialized(Space *home, const IntVarArgs& start, const IntVarArgs& duration,
+	     IntConLevel cl)
+  {
+    post_serialized(home, start, duration, cl);
+  }
+
+
+  void
+  serialized(Space *home, const IntVarArgs& start, const IntArgs& duration,
+	     IntConLevel cl)
+  {
+        post_serialized(home, start, duration, cl);
+  }
+
+}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/search.hh

@@ -0,0 +1,745 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:06:38 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3516 $
+ *
+ *  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_SEARCH_HH__
+#define __GECODE_SEARCH_HH__
+
+#include <ctime>
+
+#include "gecode/kernel.hh"
+
+/*
+ * Support for DLLs under Windows
+ *
+ */
+
+#if !defined(GECODE_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_SEARCH
+#define GECODE_SEARCH_EXPORT __declspec( dllexport )
+#else
+#define GECODE_SEARCH_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#ifdef GCC_HASCLASSVISIBILITY
+
+#define GECODE_SEARCH_EXPORT __attribute__ ((visibility("default")))
+
+#else
+
+#define GECODE_SEARCH_EXPORT
+
+#endif
+#endif
+
+#include "gecode/support/dynamic-stack.hh"
+
+namespace Gecode {
+
+  /// %Search engines
+  namespace Search {
+
+    /**
+     * \brief %Search configuration
+     *
+     * \ingroup TaskIntSearch
+     */
+    namespace Config {
+      /// Create a clone after every \a c_d commits
+      const unsigned int c_d = 8;
+      /// Create a clone during recomputation if distance is greater than \a a_d
+      const unsigned int a_d = 2;
+    }
+
+    /**
+     * \brief %Search engine statistics
+     * \ingroup TaskIntSearch
+     */
+    class Statistics {
+    public:
+      /// Number of propagation steps
+      unsigned long int propagate;
+      /// Number of failed nodes in search tree
+      unsigned long int fail;
+      /// Number of clones created
+      unsigned long int clone;
+      /// Number of commit operations performed
+      unsigned long int commit;
+      /// Peak memory allocated
+      size_t memory;
+      /// Initialize with all numbers zero
+      Statistics(void);
+    };
+
+
+    /**
+     * \defgroup TaskIntSearchStop Stop-objects for stopping search
+     * \ingroup TaskIntSearch
+     *
+     * Allows to specify various criteria when a search engine should
+     * stop exploration. Only exploration but neither recomputation
+     * nor propagation will be interrupted.
+     *
+     */
+
+    /**
+     * \brief Base-class for %Stop-object
+     * \ingroup TaskIntSearchStop
+     */
+    class GECODE_SEARCH_EXPORT Stop {
+    public:
+      /// Default constructor
+      Stop(void);
+      /// Stop search, if returns true (can be based on statistics \a s)
+      virtual bool stop(const Statistics& s) = 0;
+      /// Destructor
+      virtual ~Stop(void);
+    };
+
+    /**
+     * \brief %Stop-object based on memory consumption
+     *
+     * \ingroup TaskIntSearchStop
+     */
+    class GECODE_SEARCH_EXPORT MemoryStop : public Stop {
+    protected:
+      /// Size limit
+      size_t l;
+    public:
+      /// Stop if memory limit \a l (in bytes) is exceeded
+      MemoryStop(size_t l);
+      /// Return current limit
+      size_t limit(void) const;
+      /// Set current limit to \a l (in bytes)
+      void limit(size_t l);
+      /// Return true if memory limit is exceeded
+      virtual bool stop(const Statistics& s);
+    };
+
+    /**
+     * \brief %Stop-object based on number of failures
+     *
+     * The number of failures reported (by the statistics) is the
+     * number since the engine started exploration. It is not the
+     * number since the last stop!
+     * \ingroup TaskIntSearchStop
+     */
+    class GECODE_SEARCH_EXPORT FailStop : public Stop {
+    protected:
+      /// Failure limit
+      unsigned long int l;
+    public:
+      /// Stop if failure limit \a l is exceeded
+      FailStop(unsigned long int l);
+      /// Return current limit
+      unsigned long int limit(void) const;
+      /// Set current limit to \a l failures
+      void limit(unsigned long int l);
+      /// Return true if failure limit is exceeded
+      virtual bool stop(const Statistics& s);
+    };
+
+    /**
+     * \brief %Stop-object based on time
+     * \ingroup TaskIntSearchStop
+     */
+    class GECODE_SEARCH_EXPORT TimeStop : public Stop {
+    protected:
+      /// Clock when execution should stop
+      clock_t s;
+      /// Current limit in milliseconds
+      unsigned long int l;
+    public:
+      /// Stop if search exceeds \a l milliseconds (from creation of this object)
+      TimeStop(unsigned long int l);
+      /// Return current limit in milliseconds
+      unsigned long int limit(void) const;
+      /// Set current limit to \a l milliseconds
+      void limit(unsigned long int l);
+      /// Reset time to zero
+      void reset(void);
+      /// Return true if time limit is exceeded
+      virtual bool stop(const Statistics& s);
+    };
+
+
+    /**
+     * \brief %Search engine control including memory information
+     */
+    class EngineCtrl : public Statistics {
+    protected:
+      /// %Stop-object to be used
+      Stop* st;
+      /// Whether engine has been stopped
+      bool _stopped;
+      /// Memory required for a single space
+      size_t mem_space;
+      /// Memory for the current space (including memory for caching)
+      size_t mem_cur;
+      /// Current total memory
+      size_t mem_total;
+    public:
+      /// Initialize with stop-object \a st and space size \a sz
+      EngineCtrl(Stop* st, size_t sz);
+      /// Reset stop information
+      void start(void);
+      /// Check whether engine must be stopped (with additional stackspace \a sz)
+      bool stop(size_t sz);
+      /// Check whether engine has been stopped
+      bool stopped(void) const;
+      /// New space \a s and branching description \a d get pushed on stack
+      void push(const Space* s, const BranchingDesc* d);
+      /// Space \a s1 is replaced by space \a s2 due to constraining
+      void constrained(const Space* s1, const Space* s2);
+      /// New space \a s is added for adaptive recomputation
+      void adapt(const Space* s);
+      /// Space \a s and branching description \a d get popped from stack
+      void pop(const Space* s, const BranchingDesc* d);
+      /// Space \a s gets used for LAO (removed from stack)
+      void lao(const Space* s);
+      /// Space \a s becomes current space (\a s = NULL: current space deleted)
+      void current(const Space* s);
+      /// Reset statistics for space \a s
+      void reset(const Space* s);
+    };
+
+    /**
+     * \brief %Search tree node for recomputation
+     *
+     */
+    class ReCoNode {
+    protected:
+      /// Space corresponding to this node (might be NULL)
+      Space*               _space;
+      /// Current alternative
+      unsigned int         _alt;
+      /// Braching description
+      const BranchingDesc* _desc;
+    public:
+      /// Node for space \a s with clone \a c (possibly NULL)
+      ReCoNode(Space* s, Space* c);
+
+      /// Return space for node
+      Space* space(void) const;
+      /// Set space to \a s
+      void space(Space* s);
+
+      /// Return branching description
+      const BranchingDesc* desc(void) const;
+
+      /// Return number for alternatives
+      unsigned int alt(void) const;
+      /// Test whether current alternative is rightmost
+      bool rightmost(void) const;
+      /// Move to next alternative
+      void next(void);
+
+      /// Free memory for node
+      void dispose(void);
+    };
+
+
+    /**
+     * \brief Stack of nodes supporting recomputation
+     *
+     * Maintains the invariant that it contains
+     * the path of the node being currently explored. This
+     * is required to support recomputation, of course.
+     *
+     * The stack supports adaptive recomputation controlled
+     * by the value of a_d: only if the recomputation
+     * distance is at least this large, an additional
+     * clone is created.
+     *
+     */
+    class ReCoStack {
+    private:
+      /// Stack to store node information
+      Support::DynamicStack<ReCoNode> ds;
+      /// Adaptive recomputation distance
+      const unsigned int a_d;
+    public:
+      /// Initialize with adaptive recomputation distance \a a_d
+      ReCoStack(unsigned int a_d);
+      /// Push space \a c (a clone of \a s or NULL)
+      const BranchingDesc* push(Space* s, Space* c);
+      /// Generate path for next node and return whether a next node exists
+      bool next(EngineCtrl& s);
+      /// Return position on stack of last copy
+      int lc(Space*& s) const;
+      /// Unwind the stack up to position \a l (after failure)
+      void unwind(int l);
+      /// Commit space \a s as described by stack entry at position \a i
+      void commit(Space* s, int i) const;
+      /**
+       * \brief Recompute space according to path with copying distance \a d
+       *
+       * The template parameter \a constrained describes whether the stack
+       * might contain spaces not propagated (from constraining during
+       * branch-and-bound).
+       */
+      template <bool constrained>
+      Space* recompute(unsigned int& d, EngineCtrl& s);
+      /// Return number of entries on stack
+      int entries(void) const;
+      /// Return stack size used
+      size_t stacksize(void) const;
+      /// Reset stack
+      void reset(void);
+    };
+
+    /**
+     * \brief Depth-first search engine implementation
+     *
+     */
+    class DfsEngine : public EngineCtrl {
+    private:
+      /// Recomputation stack of nodes
+      ReCoStack          rcs;
+      /// Current space being explored
+      Space*             cur;
+      /// Copying recomputation distance
+      const unsigned int c_d;
+      /// Distance until next clone
+      unsigned int       d;
+    public:
+      /**
+       * \brief Initialize engine
+       * \param c_d minimal recomputation distance
+       * \param a_d adaptive recomputation distance
+       * \param st %Stop-object
+       * \param sz size of one space
+       */
+      DfsEngine(unsigned int c_d, unsigned int a_d, Stop* st, size_t sz);
+      /// Initialize engine to start at space \a s
+      void init(Space* s);
+      /// Reset engine to restart at space \a s
+      void reset(Space* s);
+      /// %Search for next solution
+      Space* explore(void);
+      /// Return stack size used by engine
+      size_t stacksize(void) const;
+      /// Destructor
+      ~DfsEngine(void);
+    };
+
+    /**
+     * \brief Depth-first search engine
+     *
+     * This class implements depth-first exploration for spaces. In order to
+     * use depth-first search on subclasses of Space, additional
+     * functionality providing the necessary typecasts is available
+     * in Gecode::DFS.
+     */
+    class GECODE_SEARCH_EXPORT DFS {
+    protected:
+      /// Engine used for exploration
+      DfsEngine e;
+    public:
+      /**
+       * \brief Initialize search engine
+       * \param s root node (subclass of Space)
+       * \param c_d minimal recomputation distance
+       * \param a_d adaptive recomputation distance
+       * \param st %Stop-object
+       * \param sz size of one space
+       */
+      DFS(Space* s, unsigned int c_d, unsigned int a_d, Stop* st, size_t sz);
+      /// Return next solution (NULL, if none exists or search has been stopped)
+      Space* next(void);
+      /// Return statistics
+      Statistics statistics(void) const;
+      /// Check whether engine has been stopped
+      bool stopped(void) const;
+    };
+
+  }
+
+  /**
+   * \brief Depth-first search engine
+   *
+   * This class supports depth-first search for subclasses \a T of
+   * Space.
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  class DFS : public Search::DFS {
+  public:
+    /**
+     * \brief Initialize search engine
+     * \param s root node (subclass of Space)
+     * \param c_d minimal recomputation distance
+     * \param a_d adaptive recomputation distance
+     * \param st %Stop-object
+     */
+    DFS(T* s,
+	unsigned int c_d=Search::Config::c_d,
+	unsigned int a_d=Search::Config::a_d,
+	Search::Stop* st=NULL);
+    /// Return next solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+  };
+
+  /**
+   * \brief Invoke depth-first search engine
+   * \param s root node (subclass \a T of Space)
+   * \param c_d minimal recomputation distance
+   * \param a_d adaptive recomputation distance
+   * \param st %Stop-object
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  T* dfs(T* s,
+	 unsigned int c_d=Search::Config::c_d,
+	 unsigned int a_d=Search::Config::a_d,
+	 Search::Stop* st=NULL);
+
+
+
+  namespace Search {
+
+    /**
+     * \brief Probing engine for %LDS
+     *
+     */
+    class ProbeEngine : public EngineCtrl {
+    protected:
+      /// %Node in the search tree for %LDS
+      class ProbeNode {
+      private:
+	/// %Space of current node
+	Space*               _space;
+	/// Branching description
+	const BranchingDesc* _desc;
+	/// Next alternative to try
+	unsigned int         _alt;
+      public:
+	/// Initialize with node \a s, description \a d, and alternative \a a
+	ProbeNode(Space* s, const BranchingDesc* d, unsigned int a);
+	/// Return space
+	Space* space(void) const;
+	/// Return branching description
+	const BranchingDesc* desc(void) const;
+	/// Return next alternative
+	unsigned int alt(void) const;
+	/// %Set next alternative
+	void next(void);
+      };
+      /// %Stack storing current path in search tree
+      Support::DynamicStack<ProbeNode> ds;
+      /// Current space
+      Space* cur;
+      /// Current discrepancy
+      unsigned int d;
+    public:
+      /// Initialize for spaces of size \a s
+      ProbeEngine(Stop* st, size_t s);
+      /// Initialize with space \a s and discrepancy \a d
+      void init(Space* s, unsigned int d);
+      /// Reset with space \a s and discrepancy \a d
+      void reset(Space* s, unsigned int d);
+      /// Return stack size used by engine
+      size_t stacksize(void) const;
+      /// Destructor
+      ~ProbeEngine(void);
+      /// %Search for next solution
+      Space* explore(void);
+    };
+
+    /**
+     * \brief Limited discrepancy search engine
+     */
+    class GECODE_SEARCH_EXPORT LDS {
+    protected:
+      Space*       root;        ///< Root node for problem
+      unsigned int d_cur;       ///< Current discrepancy
+      unsigned int d_max;       ///< Maximal discrepancy
+      bool         no_solution; ///< Solution found for current discrepancy
+      ProbeEngine  e;           ///< The probe engine
+    public:
+      /** Initialize engine
+       * \param s root node
+       * \param d maximal discrepancy
+       * \param st %Stop-object
+       * \param sz size of space
+       */
+      LDS(Space* s, unsigned int d, Stop* st, size_t sz);
+      /// Return next solution (NULL, if none exists or search has been stopped)
+      Space* next(void);
+      /// Return statistics
+      Statistics statistics(void) const;
+      /// Check whether engine has been stopped
+      bool stopped(void) const;
+      /// Destructor
+      ~LDS(void);
+    };
+
+  }
+
+  /**
+   * \brief Limited discrepancy search engine
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  class LDS : public Search::LDS {
+  public:
+    /** \brief Initialize engine
+     * \param s root node (subclass \a T of Space)
+     * \param d maximal discrepancy
+     * \param st %Stop-object
+     */
+    LDS(T* s, unsigned int d, Search::Stop* st=NULL);
+    /// Return next solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+  };
+
+  /**
+   * \brief Invoke limited-discrepancy search
+   * \param s root node (subclass \a T of Space)
+   * \param d maximum number of discrepancies
+   * \param st %Stop-object
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  T* lds(T* s,unsigned int d, Search::Stop* st=NULL);
+
+
+
+
+
+  /*
+   * Best solution search engines
+   *
+   */
+
+  namespace Search {
+
+    /**
+     * \brief Implementation of depth-first branch-and-bound search engines
+     */
+    class BabEngine : public EngineCtrl {
+    public:
+      /// Status of the explore function
+      enum ExploreStatus {
+	ES_SOLUTION,
+	ES_CONSTRAIN
+      };
+    private:
+      /// Recomputation stack of nodes
+      ReCoStack          rcs;
+      /// Current space being explored
+      Space*             cur;
+      /// Number of entries not yet constrained to be better
+      int                mark;
+      /// Record which current operation is in progress
+      ExploreStatus      es;
+      /// Best solution found so far
+      Space*             best;
+      /// Copying recomputation distance
+      const unsigned int c_d;
+      /// Distance until next clone
+      unsigned int       d;
+    public:
+      /**
+       * \brief Initialize engine
+       * \param c_d minimal recomputation distance
+       * \param a_d adaptive recomputation distance
+       * \param st %Stop-object
+       * \param sz size of one space
+       */
+      BabEngine(unsigned int c_d, unsigned int a_d, Stop* st, size_t sz);
+      /// Initialize engine to start at space \a s
+      void init(Space* s);
+      /**
+       * \brief %Search for next better solution
+       *
+       * If \c ES_SOLUTION is returned, a next better solution has been found.
+       * This solution is available from \a s1.
+       *
+       * If \c ES_CONSTRAIN is returned, the engine requires that the
+       * space \a s1 is constrained to be better by the so-far best
+       * solution \a s2.
+       *
+       */
+      GECODE_SEARCH_EXPORT
+      ExploreStatus explore(Space*& s1, Space*& s2);
+      /// Return stack size used by engine
+      size_t stacksize(void) const;
+      /// Destructor
+      ~BabEngine(void);
+    };
+
+    /**
+     * \brief Depth-first branch-and-bound search engine
+     *
+     * This class implements depth-first branch-and-bound exploration
+     * for spaces. In order to use it on subclasses of Space, additional
+     * functionality providing the necessary typecasts is available
+     * in Gecode::BAB:
+     *
+     */
+    class GECODE_SEARCH_EXPORT BAB {
+    protected:
+      /// Engine used for exploration
+      BabEngine e;
+    public:
+      /**
+       * \brief Initialize engine
+       * \param s root node
+       * \param c_d minimal recomputation distance
+       * \param a_d adaptive recomputation distance
+       * \param st %Stop-object
+       * \param sz size of one space
+       */
+      BAB(Space* s, unsigned int c_d, unsigned int a_d, Stop* st, size_t sz);
+      /// Check whether engine has been stopped
+      bool stopped(void) const;
+      /// Return statistics
+      Statistics statistics(void) const;
+    };
+
+  }
+
+  /**
+   * \brief Depth-first branch-and-bound search engine
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  class BAB : public Search::BAB {
+  public:
+    /**
+     * \brief Initialize engine
+     * \param s Root node (subclass \a T of Space).
+     *          Additionally, \a s must implement
+     *          a member function \code void constrain(T* t) \endcode
+     *          Whenever exploration requires to add a constraint
+     *          to the space \a c currently being explored, the engine
+     *          executes \c c->constrain(t) where \a t is the so-far
+     *          best solution.
+     * \param c_d Minimal recomputation distance
+     * \param a_d Adaptive recomputation distance
+     * \param st %Stop-object
+     */
+    BAB(T* s,
+	unsigned int c_d=Search::Config::c_d,
+	unsigned int a_d=Search::Config::a_d,
+	Search::Stop* st=NULL);
+    /// Return next better solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+  };
+
+  /**
+   * \brief Perform depth-first branch-and-bound search
+   * \param s root node (subclass \a T of Space).
+   *          Additionally, \a s must implement
+   *          a member function \code void constrain(T* t) \endcode
+   *          Whenever exploration requires to add a constraint
+   *          to the space \a c currently being explored, the engine
+   *          executes \c c->constrain(t) where \a t is the so-far
+   *          best solution.
+   * \param c_d minimal recomputation distance
+   * \param a_d adaptive recomputation distance
+   * \param st %Stop-object
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  T* bab(T* s,
+	 unsigned int c_d=Search::Config::c_d,
+	 unsigned int a_d=Search::Config::a_d,
+	 Search::Stop* st=NULL);
+
+
+
+  /**
+   * \brief Depth-first restart best solution search engine
+   * \ingroup TaskIntSearch
+   */
+  template <class T>
+  class Restart : public DFS<T> {
+  protected:
+    /// Root node
+    Space* root;
+    /// So-far best solution
+    Space* best;
+  public:
+    /**
+     * \brief Initialize engine
+     * \param s root node (subclass \a T of Space).
+     *          Additionally, \a s must implement
+     *          a member function \code void constrain(T* t) \endcode
+     *          Whenever exploration requires to add a constraint
+     *          to the space \a c currently being explored, the engine
+     *          executes \c c->constrain(t) where \a t is the so-far
+     *          best solution.
+     * \param c_d minimal recomputation distance
+     * \param a_d adaptive recomputation distance
+     * \param st %Stop-object
+     */
+    Restart(T* s,
+	    unsigned int c_d=Search::Config::c_d,
+	    unsigned int a_d=Search::Config::a_d,
+	    Search::Stop* st=NULL);
+    /// Destructor
+    ~Restart(void);
+    /// Return next better solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+  };
+
+  /**
+   * \brief Perform depth-first restart best solution search
+   * \param s root node (subclass \a T of Space).
+   *          Additionally, \a s must implement
+   *          a member function \code void constrain(T* t) \endcode
+   *          Whenever exploration requires to add a constraint
+   *          to the space \a c currently being explored, the engine
+   *          executes \c c->constrain(t) where \a t is the so-far
+   *          best solution.
+   * \param c_d minimal recomputation distance
+   * \param a_d adaptive recomputation distance
+   * \param st %Stop-object
+   */
+  template <class T>
+  T* restart(T* s,
+	     unsigned int c_d=Search::Config::c_d,
+	     unsigned int a_d=Search::Config::a_d,
+	     Search::Stop* st=NULL);
+
+}
+
+#include "gecode/search/statistics.icc"
+#include "gecode/search/stop.icc"
+#include "gecode/search/engine-ctrl.icc"
+
+#include "gecode/search/reco-stack.icc"
+
+#include "gecode/search/dfs.icc"
+#include "gecode/search/lds.icc"
+#include "gecode/search/bab.icc"
+#include "gecode/search/restart.icc"
+
+#endif
+
+// STATISTICS: search-any