dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/minimodel/set-expr.hpp

@@ -0,0 +1,96 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2010
+ *
+ *  Last modified:
+ *     $Date: 2011-01-22 02:01:14 +1100 (Sat, 22 Jan 2011) $ by $Author: schulte $
+ *     $Revision: 11553 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifdef GECODE_HAS_SET_VARS
+
+namespace Gecode {
+
+  /*
+   * Operations for expressions
+   *
+   */
+  forceinline
+  SetExpr::Node::Node(void) : use(1) {}
+
+  forceinline void*
+  SetExpr::Node::operator new(size_t size) {
+    return heap.ralloc(size);
+  }
+  forceinline void
+  SetExpr::Node::operator delete(void* p, size_t) {
+    heap.rfree(p);
+  }
+
+  forceinline
+  SetExpr::SetExpr(void) : n(NULL) {}
+
+  forceinline
+  SetExpr::SetExpr(const SetExpr& e) : n(e.n) {
+    n->use++;
+  }
+
+  forceinline bool
+  SetExpr::same(NodeType t0, NodeType t1) {
+    return (t0==t1) || (t1==NT_VAR) || (t1==NT_CONST) || (t1==NT_LEXP);
+  }
+
+  inline SetVar
+  SetExpr::post(Home home) const {
+    Region r(home);
+    SetVar s(home,IntSet::empty,
+             IntSet(Set::Limits::min,Set::Limits::max));
+    NNF::nnf(r,n,false)->post(home,SRT_EQ,s);
+    return s;
+  }
+
+  inline void
+  SetExpr::post(Home home, SetRelType srt, const SetExpr& e) const {
+    Region r(home);
+    return NNF::nnf(r,n,false)->post(home,srt,NNF::nnf(r,e.n,false));
+  }
+  inline void
+  SetExpr::post(Home home, BoolVar b, bool t,
+                SetRelType srt, const SetExpr& e) const {
+    Region r(home);
+    return NNF::nnf(r,n,false)->post(home,b,t,srt,NNF::nnf(r,e.n,false));                  
+  }
+
+}
+
+#endif
+
+// STATISTICS: minimodel-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/minimodel/set-rel.cpp

@@ -0,0 +1,81 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2010-07-16 18:51:05 +1000 (Fri, 16 Jul 2010) $ by $Author: tack $
+ *     $Revision: 11208 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/minimodel.hh>
+
+#ifdef GECODE_HAS_SET_VARS
+
+namespace Gecode {
+
+  /*
+   * Operators
+   *
+   */
+  SetRel
+  operator ==(const SetExpr& e0, const SetExpr& e1) {
+    return SetRel(e0, SRT_EQ, e1);
+  }
+  SetRel
+  operator !=(const SetExpr& e0, const SetExpr& e1) {
+    return SetRel(e0, SRT_NQ, e1);
+  }
+  SetCmpRel
+  operator <=(const SetExpr& e0, const SetExpr& e1) {
+    return SetCmpRel(e0, SRT_SUB, e1);
+  }
+  BoolExpr
+  operator <=(const SetCmpRel& r, const SetExpr& l) {
+    return BoolExpr(r) && BoolExpr(r.r <= l);
+  }
+  SetCmpRel
+  operator >=(const SetExpr& e0, const SetExpr& e1) {
+    return SetCmpRel(e0, SRT_SUP, e1);
+  }
+  BoolExpr
+  operator >=(const SetCmpRel& r, const SetExpr& l) {
+    return BoolExpr(r) && BoolExpr(r.r >= l);
+  }
+  SetRel
+  operator ||(const SetExpr& e0, const SetExpr& e1) {
+    return SetRel(e0, SRT_DISJ, e1);
+  }
+  
+}
+
+#endif
+
+// STATISTICS: minimodel-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/minimodel/set-rel.hpp

@@ -0,0 +1,84 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2010-07-15 04:32:01 +1000 (Thu, 15 Jul 2010) $ by $Author: schulte $
+ *     $Revision: 11195 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifdef GECODE_HAS_SET_VARS
+
+namespace Gecode {
+
+  /*
+   * Operations for set relations
+   *
+   */
+  forceinline
+  SetCmpRel::SetCmpRel(const SetExpr& l0, SetRelType srt0, const SetExpr& r0)
+    : l(l0), r(r0), srt(srt0) {}
+
+  forceinline
+  SetRel::SetRel(void) {}
+   
+  forceinline
+  SetRel::SetRel(const SetExpr& e0, SetRelType srt, const SetExpr& e1)
+    : _e0(e0), _srt(srt), _e1(e1) {}
+
+  forceinline
+  SetRel::SetRel(const SetCmpRel& r)
+    : _e0(r.l), _srt(r.srt), _e1(r.r) {}
+
+  forceinline void
+  SetRel::post(Home home, bool t) const {
+    if (t)
+      _e0.post(home,_srt,_e1);
+    else if (_srt == SRT_EQ)
+      _e0.post(home,SRT_NQ,_e1);
+    else if (_srt == SRT_NQ)
+      _e0.post(home,SRT_EQ,_e1);
+    else {
+      BoolVar b(home,0,0);
+      _e0.post(home,b,true,_srt,_e1);
+    }
+  }
+
+  forceinline void
+  SetRel::post(Home home, BoolVar b, bool t) const {
+    _e0.post(home,b,t,_srt,_e1);
+  }
+
+}
+
+#endif
+
+// STATISTICS: minimodel-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search.hh

@@ -0,0 +1,458 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2010-10-09 22:58:12 +1100 (Sat, 09 Oct 2010) $ by $Author: schulte $
+ *     $Revision: 11498 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef __GECODE_SEARCH_HH__
+#define __GECODE_SEARCH_HH__
+
+#include <gecode/kernel.hh>
+
+/*
+ * Configure linking
+ *
+ */
+#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 GECODE_GCC_HAS_CLASS_VISIBILITY
+#define GECODE_SEARCH_EXPORT __attribute__ ((visibility("default")))
+#else
+#define GECODE_SEARCH_EXPORT
+#endif
+
+#endif
+
+// Configure auto-linking
+#ifndef GECODE_BUILD_SEARCH
+#define GECODE_LIBRARY_NAME "Search"
+#include <gecode/support/auto-link.hpp>
+#endif
+
+
+namespace Gecode {
+
+  /// %Search engines
+  namespace Search {
+
+    /**
+     * \brief %Search configuration
+     *
+     * \ingroup TaskModelSearch
+     */
+    namespace Config {
+      /// Whether engines create a clone when being initialized
+      const bool clone = true;
+      /// Number of threads to use
+      const double threads = 1.0;
+      /// Create a clone after every \a c_d commits (commit distance)
+      const unsigned int c_d = 8;
+      /// Create a clone during recomputation if distance is greater than \a a_d (adaptive distance)
+      const unsigned int a_d = 2;
+
+      /// Minimal number of open nodes for stealing
+      const unsigned int steal_limit = 3;
+      /// Initial delay in milliseconds for all but first worker thread
+      const unsigned int initial_delay = 5;
+    }
+
+    /**
+     * \brief %Search engine statistics
+     * \ingroup TaskModelSearch
+     */
+    class Statistics : public StatusStatistics {
+    public:
+      /// Number of failed nodes in search tree
+      unsigned long int fail;
+      /// Number of nodes expanded
+      unsigned long int node;
+      /// Maximum depth of search stack
+      unsigned long int depth;
+      /// Peak memory allocated
+      size_t memory;
+      /// Initialize
+      Statistics(void);
+      /// Reset
+      void reset(void);
+      /// Return sum with \a s
+      Statistics operator +(const Statistics& s);
+      /// Increment by statistics \a s
+      Statistics& operator +=(const Statistics& s);
+    };
+
+    class Stop;
+
+    /**
+     * \brief %Search engine options
+     *
+     * Defines options for search engines. Not all search engines might
+     * honor all option values.
+     *
+     *  - \a c_d as minimal recomputation distance: this guarantees that
+     *    a path between two nodes in the search tree for which copies are
+     *    stored has at least length \a c_d. That is, in order to recompute
+     *    a node in the search tree, \a c_d recomputation steps are needed.
+     *    The minimal recomputation distance yields a guarantee on saving
+     *    memory compared to full copying: it stores \a c_d times less nodes
+     *    than full copying.
+     *  - \a a_d as adaptive recomputation distance: when a node needs to be
+     *    recomputed and the path is longer than \a a_d, an intermediate copy
+     *    is created (approximately in the middle of the path) to speed up
+     *    future recomputation. Note that small values of \a a_d can increase
+     *    the memory consumption considerably.
+     *
+     * Full copying corresponds to a maximal recomputation distance
+     * \a c_d of 1.
+     *
+     * All recomputation performed is based on batch recomputation: batch
+     * recomputation performs propagation only once for an entire path
+     * used in recomputation.
+     *
+     * The number of threads to be used is controlled by a double \f$n\f$
+     * (assume that \f$m\f$ is the number of processing units available). If
+     * \f$1 \leq n\f$, \f$n\f$ threads are chosen (of course with rounding).
+     * If \f$n \leq -1\f$, then \f$m + n\f$ threads are 
+     * chosen (all but \f$-n\f$ processing units get a thread). If \f$n\f$
+     * is zero, \f$m\f$ threads are chosen. If \f$0<n<1\f$,
+     * \f$n \times m\f$ threads are chosen. If \f$-1 <n<0\f$, 
+     * \f$(1+n)\times m\f$ threads are chosen.
+     * 
+     * \ingroup TaskModelSearch
+     */
+    class Options {
+    public:
+      /// Whether engines create a clone when being initialized
+      bool clone;
+      /// Number of threads to use
+      double threads;
+      /// Create a clone after every \a c_d commits (commit distance)
+      unsigned int c_d;
+      /// Create a clone during recomputation if distance is greater than \a a_d (adaptive distance)
+      unsigned int a_d;
+      /// Stop object for stopping search
+      Stop* stop;
+      /// Default options
+      GECODE_SEARCH_EXPORT static const Options def;
+      /// Initialize with default values
+      Options(void);
+      /// Expand with real number of threads
+      GECODE_SEARCH_EXPORT Options
+      expand(void) const;
+    };
+
+    /**
+     * \defgroup TaskModelSearchStop Stop-objects for stopping search
+     * \ingroup TaskModelSearch
+     *
+     * 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 TaskModelSearchStop
+     */
+    class GECODE_SEARCH_EXPORT Stop {
+    public:
+      /// Default constructor
+      Stop(void);
+      /// Stop search, if returns true
+      virtual bool stop(const Statistics& s, const Options& o) = 0;
+      /// Destructor
+      virtual ~Stop(void);
+    };
+
+    /**
+     * \brief %Stop-object based on memory consumption
+     *
+     * \ingroup TaskModelSearchStop
+     */
+    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, const Options& o);
+    };
+
+    /**
+     * \brief %Stop-object based on number of nodes
+     *
+     * The number of nodes reported (by the statistics) is the
+     * number since the engine started exploration. It is not the
+     * number since the last stop!
+     * \ingroup TaskModelSearchStop
+     */
+    class GECODE_SEARCH_EXPORT NodeStop : public Stop {
+    protected:
+      /// Node limit
+      unsigned long int l;
+    public:
+      /// Stop if node limit \a l is exceeded
+      NodeStop(unsigned long int l);
+      /// Return current limit
+      unsigned long int limit(void) const;
+      /// Set current limit to \a l nodes
+      void limit(unsigned long int l);
+      /// Return true if node limit is exceeded
+      virtual bool stop(const Statistics& s, const Options& o);
+    };
+
+    /**
+     * \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 TaskModelSearchStop
+     */
+    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, const Options& o);
+    };
+
+    /**
+     * \brief %Stop-object based on time
+     * \ingroup TaskModelSearchStop
+     */
+    class GECODE_SEARCH_EXPORT TimeStop : public Stop {
+    protected:
+      /// Time when execution should stop
+      Support::Timer t;
+      /// 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, const Options& o);
+    };
+
+
+    /**
+     * \brief %Search engine interface
+     */
+    class Engine {
+    public:
+      /// Return next solution (NULL, if none exists or search has been stopped)
+      virtual Space* next(void) = 0;
+      /// Return statistics
+      virtual Search::Statistics statistics(void) const = 0;
+      /// Check whether engine has been stopped
+      virtual bool stopped(void) const = 0;
+      /// Destructor
+      virtual ~Engine(void) {}
+    };
+
+    /// %Sequential search engine implementations
+    namespace Sequential {}
+
+    /// %Parallel search engine implementations
+    namespace Parallel {}
+
+  }
+
+}
+
+#include <gecode/search/statistics.hpp>
+#include <gecode/search/stop.hpp>
+#include <gecode/search/options.hpp>
+
+namespace Gecode {
+
+  /**
+   * \brief Depth-first search engine
+   *
+   * This class supports depth-first search for subclasses \a T of
+   * Space.
+   * \ingroup TaskModelSearch
+   */
+  template<class T>
+  class DFS {
+  private:
+    /// The actual search engine
+    Search::Engine* e;
+  public:
+    /// Initialize search engine for space \a s with options \a o
+    DFS(T* s, const Search::Options& o=Search::Options::def);
+    /// Return next solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+    /// Return statistics
+    Search::Statistics statistics(void) const;
+    /// Check whether engine has been stopped
+    bool stopped(void) const;
+    /// Destructor
+    ~DFS(void);
+  };
+
+  /// Invoke depth-first search engine for subclass \a T of space \a s with options \a o
+  template<class T>
+  T* dfs(T* s, const Search::Options& o=Search::Options::def);
+
+
+
+  /**
+   * \brief Depth-first branch-and-bound search engine
+   *
+   * Additionally, \a s must implement a member function
+   * \code virtual void constrain(const 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.
+   * \ingroup TaskModelSearch
+   */
+  template<class T>
+  class BAB {
+  private:
+    /// The actual search engine
+    Search::Engine* e;
+  public:
+    /// Initialize engine for space \a s and options \a o
+    BAB(T* s, const Search::Options& o=Search::Options::def);
+    /// Return next better solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+    /// Return statistics
+    Search::Statistics statistics(void) const;
+    /// Check whether engine has been stopped
+    bool stopped(void) const;
+    /// Destructor
+    ~BAB(void);
+  };
+
+  /**
+   * \brief Perform depth-first branch-and-bound search for subclass \a T of space \a s and options \a o
+   *
+   * Additionally, \a s must implement a member function
+   * \code virtual void constrain(const 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.
+   *
+   * \ingroup TaskModelSearch
+   */
+  template<class T>
+  T* bab(T* s, const Search::Options& o=Search::Options::def);
+
+
+
+  /**
+   * \brief Depth-first restart best solution search engine
+   *
+   * Additionally, \a s must implement a member function
+   * \code virtual 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.
+   * \ingroup TaskModelSearch
+   */
+  template<class T>
+  class Restart {
+  private:
+    /// The actual search engine
+    Search::Engine* e;
+  public:
+    /// Initialize engine for space \a s and options \a o
+    Restart(T* s, const Search::Options& o=Search::Options::def);
+    /// Return next better solution (NULL, if none exists or search has been stopped)
+    T* next(void);
+    /// Return statistics
+    Search::Statistics statistics(void) const;
+    /// Check whether engine has been stopped
+    bool stopped(void) const;
+    /// Destructor
+    ~Restart(void);
+  };
+
+  /**
+   * \brief Perform depth-first restart best solution search for subclass \a T of space \a s and options \a o
+   *
+   * Additionally, \a s must implement a member function
+   * \code virtual 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.
+   * \ingroup TaskModelSearch
+   */
+  template<class T>
+  T* restart(T* s, const Search::Options& o=Search::Options::def);
+
+}
+
+#include <gecode/search/dfs.hpp>
+#include <gecode/search/bab.hpp>
+#include <gecode/search/restart.hpp>
+
+#endif
+
+// STATISTICS: search-other