gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/search/bab.cc

@@ -0,0 +1,153 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:17 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3511 $
+ *
+ *  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/search.hh"
+
+namespace Gecode { namespace Search {
+
+  /*
+   * The invariant maintained by the engine is:
+   *   For all nodes stored at a depth less than mark, there
+   *   is no guarantee of betterness. For those above the mark,
+   *   betterness is guaranteed.
+   *
+   * The engine maintains the path on the stack for the current
+   * node to be explored.
+   *
+   */
+
+  BabEngine::ExploreStatus
+  BabEngine::explore(Space*& s1, Space*& s2) {
+    start();
+    /*
+     * Upon entry, cur can be either NULL or set to the initial
+     * space. For the initial case, es is also ES_CONSTRAIN.
+     *
+     * Otherwise (that is, cur == NULL), the actions depend on
+     * es. In case es is ES_CONSTRAIN, a space on stack has been
+     * constrained. Whether this is succesful recomputation finds
+     * out. In any case, the stack is not allowed to be moved to
+     * the next node.
+     *
+     * In case es is ES_SOLUTION, the stack must be moved to the next
+     * node and recomputation is to be performed.
+     */
+    while (true) {
+      assert((es == ES_SOLUTION) || (cur == NULL));
+      if (stop(stacksize())) {
+	s1 = NULL;
+	return ES_SOLUTION;
+      }
+      if (cur == NULL) {
+	if (es == ES_CONSTRAIN) {
+	  es = ES_SOLUTION;
+	  goto same;
+	}
+	do {
+	  if (!rcs.next(*this)) {
+	    s1 = NULL;
+	    return ES_SOLUTION;
+	  }
+	  {
+	    int l = rcs.lc(s1);
+	    if (l < mark) {
+	      es = ES_CONSTRAIN;
+	      mark = l;
+	      s2 = best;
+	      return ES_CONSTRAIN;
+	    }
+	  }
+	same:
+	  cur = rcs.recompute<true>(d,*this);
+	} while (cur == NULL);
+	EngineCtrl::current(cur);
+      }
+      switch (cur->status(propagate)) {
+      case SS_FAILED:
+	fail++;
+	delete cur;
+	cur = NULL;
+	EngineCtrl::current(NULL);
+	break;
+      case SS_SOLVED:
+	delete best;
+	best = cur;
+	mark = rcs.entries();
+	s1 = best->clone(true,propagate);
+	clone++;
+	cur = NULL;
+	EngineCtrl::current(NULL);
+	return ES_SOLUTION;
+      case SS_BRANCH:
+	{
+	  Space* c;
+	  if ((d == 0) || (d >= c_d)) {
+	    c = cur->clone(true,propagate);
+	    clone++;
+	    d = 1;
+	  } else {
+	    c = NULL;
+	    d++;
+	  }
+	  const BranchingDesc* desc = rcs.push(cur,c);
+	  EngineCtrl::push(c,desc);
+	  cur->commit(desc,0);
+	  commit++;
+	  break;
+	}
+      default:
+	GECODE_NEVER;
+      }
+    }
+    return ES_SOLUTION;
+  }
+
+
+
+
+  BAB::BAB(Space* s, unsigned int c_d, unsigned int a_d, Stop* st, size_t sz)
+    : e(c_d,a_d,st,sz) {
+    unsigned long int p = 0;
+    Space* c = (s->status(p) == SS_FAILED) ? NULL : s->clone(true,p);
+    e.init(c);
+    e.propagate += p;
+    e.current(s);
+    e.current(NULL);
+    e.current(c);
+    if (c == NULL)
+      e.fail += 1;
+  }
+
+  bool
+  BAB::stopped(void) const {
+    return e.stopped();
+  }
+
+  Statistics
+  BAB::statistics(void) const {
+    Statistics s = e;
+    s.memory += e.stacksize();
+    return s;
+  }
+
+}}
+
+// STATISTICS: search-any

data/ext/gecode-1.3.1/gecode/search/bab.icc

@@ -0,0 +1,101 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:17 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3511 $
+ *
+ *  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 {
+
+  /*
+   * BAB search engine
+   *
+   */
+
+  namespace Search {
+
+    forceinline
+    BabEngine::BabEngine(unsigned int c_d0, unsigned int a_d,
+			 Stop* st, size_t sz)
+      : EngineCtrl(st,sz), rcs(a_d), cur(NULL),
+	mark(0), es(ES_SOLUTION), best(NULL),
+	c_d(c_d0), d(0) {}
+
+
+    forceinline void
+    BabEngine::init(Space* s) {
+      cur = s;
+    }
+
+    forceinline size_t
+    BabEngine::stacksize(void) const {
+      return rcs.stacksize();
+    }
+
+    forceinline
+    BabEngine::~BabEngine(void) {
+      rcs.reset();
+      delete best;
+      delete cur;
+    }
+  }
+
+  /*
+   * Control for bab search engine
+   *
+   */
+
+  template <class T>
+  forceinline
+  BAB<T>::BAB(T* s, unsigned int c_d, unsigned int a_d, Search::Stop* st)
+    : Search::BAB(s,c_d,a_d,st,sizeof(T)) {}
+
+  template <class T>
+  forceinline T*
+  BAB<T>::next(void) {
+    Space *s1, *s2;
+    while (e.explore(s1,s2) == Search::BabEngine::ES_CONSTRAIN)
+      static_cast<T*>(s1)->constrain(static_cast<T*>(s2));
+    return static_cast<T*>(s1);
+  }
+
+
+
+
+  /*
+   * BAB convenience
+   *
+   */
+
+  template <class T>
+  T*
+  bab(T* s, unsigned int c_d, unsigned int a_d, Search::Stop* st) {
+    BAB<T> b(s,c_d,a_d,st);
+    T* l = NULL;
+    while (T* n = b.next()) {
+      delete l; l = n;
+    }
+    return l;
+  }
+
+}
+
+// STATISTICS: search-any

data/ext/gecode-1.3.1/gecode/search/dfs.cc

@@ -0,0 +1,63 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:17 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3511 $
+ *
+ *  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/search.hh"
+
+namespace Gecode { namespace Search {
+
+  /*
+   * Control for DFS
+   *
+   */
+
+  DFS::DFS(Space* s, unsigned int c_d, unsigned int a_d, Stop* st, size_t sz)
+    : e(c_d,a_d,st,sz) {
+    unsigned long int p = 0;
+    Space* c = (s->status(p) == SS_FAILED) ? NULL : s->clone(true,p);
+    e.init(c);
+    e.propagate += p;
+    e.current(s);
+    e.current(NULL);
+    e.current(c);
+    if (c == NULL)
+      e.fail += 1;
+  }
+
+  Space*
+  DFS::next(void) {
+    return e.explore();
+  }
+
+  bool
+  DFS::stopped(void) const {
+    return e.stopped();
+  }
+
+  Statistics
+  DFS::statistics(void) const {
+    Statistics s = e;
+    s.memory += e.stacksize();
+    return s;
+  }
+
+}}
+
+// STATISTICS: search-any

data/ext/gecode-1.3.1/gecode/search/dfs.icc

@@ -0,0 +1,144 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:17 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3511 $
+ *
+ *  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 Search {
+
+    /*
+     * DFS engine
+     *
+     */
+    forceinline
+    DfsEngine::DfsEngine(unsigned int c_d0, unsigned int a_d0,
+			 Stop* st, size_t sz)
+      : EngineCtrl(st,sz), rcs(a_d0), cur(NULL), c_d(c_d0), d(0) {}
+
+
+    forceinline void
+    DfsEngine::init(Space* s) {
+      cur = s;
+    }
+
+    forceinline void
+    DfsEngine::reset(Space* s) {
+      delete cur;
+      rcs.reset();
+      cur = s;
+      d   = 0;
+      EngineCtrl::reset(s);
+    }
+
+    forceinline size_t
+    DfsEngine::stacksize(void) const {
+      return rcs.stacksize();
+    }
+
+    forceinline Space*
+    DfsEngine::explore(void) {
+      start();
+      while (true) {
+	while (cur) {
+	  if (stop(stacksize()))
+	    return NULL;
+	  switch (cur->status(propagate)) {
+	  case SS_FAILED:
+	    fail++;
+	    delete cur;
+	    cur = NULL;
+	    EngineCtrl::current(NULL);
+	    break;
+	  case SS_SOLVED:
+	    {
+	      Space* s = cur;
+	      cur = NULL;
+	      EngineCtrl::current(NULL);
+	      return s;
+	    }
+	  case SS_BRANCH:
+	    {
+	      Space* c;
+	      if ((d == 0) || (d >= c_d)) {
+		clone++;
+		c = cur->clone(true,propagate);
+		d = 1;
+	      } else {
+		c = NULL;
+		d++;
+	      }
+	      const BranchingDesc* desc = rcs.push(cur,c);
+	      EngineCtrl::push(c,desc);
+	      commit++;
+	      cur->commit(desc,0);
+	      break;
+	    }
+	  default: GECODE_NEVER;
+	  }
+	}
+	if (!rcs.next(*this))
+	  return NULL;
+	cur = rcs.recompute<false>(d,*this);
+	EngineCtrl::current(cur);
+      }
+      return NULL;
+    }
+
+    forceinline
+    DfsEngine::~DfsEngine(void) {
+      delete cur;
+      rcs.reset();
+    }
+
+  }
+
+  /*
+   * Control for DFS search engine
+   *
+   */
+
+  template <class T>
+  forceinline
+  DFS<T>::DFS(T* s, unsigned int c_d, unsigned int a_d, Search::Stop* st)
+    : Search::DFS(s,c_d,a_d,st,sizeof(T)) {}
+
+  template <class T>
+  forceinline T*
+  DFS<T>::next(void) {
+    return static_cast<T*>(Search::DFS::next());
+  }
+
+
+
+  /*
+   * DFS convenience
+   *
+   */
+
+  template <class T>
+  forceinline T*
+  dfs(T* s, unsigned int c_d, unsigned int a_d, Search::Stop* st) {
+    DFS<T> d(s,c_d,a_d,st);
+    return static_cast<T*>(d.next());
+  }
+
+}
+
+// STATISTICS: search-any