gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -1,118 +0,0 @@
-/*
- *  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

@@ -1,241 +0,0 @@
-/*
- *  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

@@ -1,745 +0,0 @@
-/*
- *  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