gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/search/engine-ctrl.icc

@@ -0,0 +1,109 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 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 { namespace Search {
+
+  forceinline
+  EngineCtrl::EngineCtrl(Stop* st0, size_t sz)
+    : st(st0), _stopped(false), mem_space(sz), mem_cur(0), mem_total(0) {
+    memory = 0;
+  }
+
+  forceinline void
+  EngineCtrl::start(void) {
+    _stopped = false;
+  }
+
+  forceinline bool
+  EngineCtrl::stop(size_t sz) {
+    if (st == NULL)
+      return false;
+    memory += sz;
+    _stopped |= st->stop(*this);
+    memory -= sz;
+    return _stopped;
+  }
+
+  forceinline bool
+  EngineCtrl::stopped(void) const {
+    return _stopped;
+  }
+
+  forceinline void
+  EngineCtrl::push(const Space* s, const BranchingDesc* d) {
+    if (s != NULL)
+      mem_total += mem_space + s->allocated();
+    mem_total += d->size();
+    if (mem_total > memory)
+      memory = mem_total;
+  }
+
+  forceinline void
+  EngineCtrl::adapt(const Space* s) {
+    mem_total += mem_space + s->allocated();
+    if (mem_total > memory)
+      memory = mem_total;
+  }
+
+  forceinline void
+  EngineCtrl::constrained(const Space* s1, const Space* s2) {
+    mem_total -= s1->allocated();
+    mem_total += s2->allocated();
+    if (mem_total > memory)
+      memory = mem_total;
+  }
+
+  forceinline void
+  EngineCtrl::lao(const Space* s) {
+    mem_total -= mem_space + s->allocated();
+  }
+
+  forceinline void
+  EngineCtrl::pop(const Space* s, const BranchingDesc* d) {
+    if (s != NULL)
+      mem_total -= mem_space + s->allocated();
+    mem_total -= d->size();
+  }
+
+  forceinline void
+  EngineCtrl::current(const Space* s) {
+    if (s == NULL) {
+      mem_total -= mem_cur;
+      mem_cur = 0;
+    } else {
+      mem_cur = mem_space + s->allocated() + s->cached();
+      mem_total += mem_cur;
+      if (mem_total > memory)
+	memory = mem_total;
+    }
+  }
+
+  forceinline void
+  EngineCtrl::reset(const Space* s) {
+    mem_cur   = mem_space+s->allocated()+s->cached();
+    mem_total = mem_cur;
+    if (mem_total > memory)
+      memory = mem_total;
+  }
+
+}}
+
+// STATISTICS: search-any

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

@@ -0,0 +1,237 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 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.
+ *
+ */
+
+#include "gecode/search.hh"
+
+namespace Gecode { namespace Search {
+
+  /*
+   * Nodes for the probing engine (just remember next alternative
+   * to try)
+   *
+   */
+
+  forceinline
+  ProbeEngine::ProbeNode
+  ::ProbeNode(Space* s, const BranchingDesc* d, unsigned int a)
+    : _space(s), _desc(d), _alt(a) {}
+
+  forceinline Space*
+  ProbeEngine::ProbeNode::space(void) const {
+    return _space;
+  }
+
+  forceinline const BranchingDesc*
+  ProbeEngine::ProbeNode::desc(void) const {
+    return _desc;
+  }
+
+  forceinline unsigned int
+  ProbeEngine::ProbeNode::alt(void) const {
+    return _alt;
+  }
+
+  forceinline void
+  ProbeEngine::ProbeNode::next(void) {
+    _alt--;
+  }
+
+
+  /*
+   * The probing engine: computes all solutions with
+   * exact number of discrepancies (solutions with
+   * fewer discrepancies are discarded)
+   *
+   */
+
+  forceinline
+  ProbeEngine::ProbeEngine(Stop* st, size_t sz)
+    : EngineCtrl(st,sz) {}
+
+  forceinline void
+  ProbeEngine::init(Space* s, unsigned int d0) {
+    cur = s;
+    d   = d0;
+  }
+
+  forceinline void
+  ProbeEngine::reset(Space* s, unsigned int d0) {
+    delete cur;
+    assert(ds.empty());
+    cur = s;
+    d   = d0;
+    EngineCtrl::reset(s);
+  }
+
+  forceinline size_t
+  ProbeEngine::stacksize(void) const {
+    return ds.size();
+  }
+
+  forceinline
+  ProbeEngine::~ProbeEngine(void) {
+    delete cur;
+    while (!ds.empty())
+      delete ds.pop().space();
+  }
+
+  forceinline Space*
+  ProbeEngine::explore(void) {
+    start();
+    while (true) {
+      if (stop(stacksize()))
+	return NULL;
+      if (cur == NULL) {
+      backtrack:
+	if (ds.empty())
+	  return NULL;
+	unsigned int a            = ds.top().alt();
+	const BranchingDesc* desc = ds.top().desc();
+	if (a == 0) {
+	  cur = ds.pop().space();
+	  EngineCtrl::pop(cur,desc);
+	  cur->commit(desc,a);
+	  delete desc;
+	} else {
+	  ds.top().next();
+	  cur = ds.top().space()->clone(true,propagate);
+	  clone++;
+	  cur->commit(desc,a);
+	}
+	EngineCtrl::current(cur);
+	d++;
+      }
+    check_discrepancy:
+      if (d == 0) {
+	Space* s = cur;
+	while (s->status(propagate) == SS_BRANCH) {
+	  if (stop(stacksize()))
+	    return NULL;
+	  const BranchingDesc* desc = s->description();
+	  s->commit(desc,0);
+	  delete desc;
+	}
+	cur = NULL;
+	EngineCtrl::current(NULL);
+	if (s->failed()) {
+	  delete s;
+	  goto backtrack;
+	}
+	return s;
+      }
+      switch (cur->status(propagate)) {
+      case SS_FAILED:
+	fail++;
+      case SS_SOLVED:	
+	delete cur;
+	cur = NULL;
+	EngineCtrl::current(NULL);
+	goto backtrack;
+      case SS_BRANCH:
+	{
+	  const BranchingDesc* desc = cur->description();
+	  unsigned int alt          = desc->alternatives();
+	  if (alt > 1) {
+	    unsigned int d_a = (d >= alt-1) ? alt-1 : d;
+	    Space* cc = cur->clone(true,propagate);
+	    EngineCtrl::push(cc,desc);
+	    ProbeNode sn(cc,desc,d_a-1);
+	    clone++;
+	    ds.push(sn);
+	    cur->commit(desc,d_a);
+	    d -= d_a;
+	  } else {
+	    cur->commit(desc,0);
+	    delete desc;
+	  }
+	  commit++;
+	  goto check_discrepancy;
+	}
+      default: GECODE_NEVER;
+      }
+    }
+  }
+
+
+  /*
+   * The LDS engine proper (_LDS means: all the logic but just
+   * for space, type casts are done in LDS)
+   *
+   */
+
+  LDS::LDS(Space* s, unsigned int d, Stop* st, size_t sz)
+    : d_cur(0), d_max(d), no_solution(true), e(st,sz) {
+    if (s->status(e.propagate) == SS_FAILED) {
+      root = NULL;
+      e.init(NULL,0);
+      e.fail += 1;
+      e.current(s);
+    } else {
+      root = s;
+      Space* c = (d_max == 0) ? s : s->clone(true,e.propagate);
+      e.init(c,0);
+      e.current(s);
+      e.current(NULL);
+      e.current(c);
+    }
+  }
+
+  LDS::~LDS(void) {
+    delete root;
+  }
+
+  Space*
+  LDS::next(void) {
+    while (true) {
+      Space* s = e.explore();
+      if (s != NULL) {
+	no_solution = false;
+	return s;
+      }
+      if (no_solution || (++d_cur > d_max))
+	break;
+      no_solution = true;
+      if (d_cur == d_max) {
+	e.reset(root,d_cur);
+	root = NULL;
+      } else {
+	e.clone++;
+	e.reset(root->clone(true,e.propagate),d_cur);
+      }
+    }
+    return NULL;
+  }
+
+  bool
+  LDS::stopped(void) const {
+    return e.stopped();
+  }
+
+  Statistics
+  LDS::statistics(void) const {
+    Statistics s = e;
+    s.memory += e.stacksize();
+    return e;
+  }
+
+}}
+
+// STATISTICS: search-any

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

@@ -0,0 +1,57 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-03-30 19:42:28 +0200 (Thu, 30 Mar 2006) $ by $Author: schulte $
+ *     $Revision: 3141 $
+ *
+ *  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 {
+
+  /*
+   * Control for LDS engine
+   *
+   */
+
+  template <class T>
+  forceinline
+  LDS<T>::LDS(T* s, unsigned int d, Search::Stop* st)
+    : Search::LDS(s,d,st,sizeof(T)) {}
+
+
+  template <class T>
+  forceinline T*
+  LDS<T>::next(void) {
+    return static_cast<T*>(Search::LDS::next());
+  }
+
+
+
+  /*
+   * Convenience for LDS
+   *
+   */
+
+  template <class T>
+  T*
+  lds(T* s, unsigned int d, Search::Stop* st) {
+    LDS<T> lds(s,d,st);
+    return static_cast<T*>(lds.next());
+  }
+
+}
+
+// STATISTICS: search-any

data/ext/gecode-1.3.1/gecode/search/reco-stack.icc

@@ -0,0 +1,219 @@
+/*
+ *  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 {
+
+  /*
+   * Node for recomputation
+   *
+   */
+
+  forceinline
+  ReCoNode::ReCoNode(Space* s, Space* c)
+    : _space(c), _alt(0), _desc(s->description()) {}
+
+  forceinline Space*
+  ReCoNode::space(void) const {
+    return _space;
+  }
+  forceinline void
+  ReCoNode::space(Space* s) {
+    _space = s;
+  }
+
+  forceinline unsigned int
+  ReCoNode::alt(void) const {
+    return _alt;
+  }
+  forceinline bool
+  ReCoNode::rightmost(void) const {
+    return _alt+1 == _desc->alternatives();
+  }
+  forceinline void
+  ReCoNode::next(void) {
+    _alt++;
+  }
+
+  forceinline const BranchingDesc*
+  ReCoNode::desc(void) const {
+    return _desc;
+  }
+
+  forceinline void
+  ReCoNode::dispose(void) {
+    delete _space;
+    delete _desc;
+  }
+
+
+
+  /*
+   * Depth-first stack with recomputation
+   *
+   */
+
+  forceinline
+  ReCoStack::ReCoStack(unsigned int a_d0) : a_d(a_d0) {}
+
+  forceinline const BranchingDesc*
+  ReCoStack::push(Space* s, Space* c) {
+    ReCoNode sn(s,c);
+    ds.push(sn);
+    return sn.desc();
+  }
+
+  forceinline bool
+  ReCoStack::next(EngineCtrl& stat) {
+    // Generate path for next node and return whether node exists.
+    while (!ds.empty())
+      if (ds.top().rightmost()) {
+	stat.pop(ds.top().space(),ds.top().desc());
+	ds.pop().dispose();
+      } else {
+	ds.top().next();
+	return true;
+      }
+    return false;
+  }
+
+  forceinline void
+  ReCoStack::commit(Space* s, int i) const {
+    const ReCoNode& n = ds[i];
+    s->commit(n.desc(),n.alt());
+  }
+
+  forceinline int
+  ReCoStack::lc(Space*& s) const {
+    int l = ds.entries()-1;
+    while (ds[l].space() == NULL)
+      l--;
+    s = ds[l].space();
+    return l;
+  }
+
+  forceinline int
+  ReCoStack::entries(void) const {
+    return ds.entries();
+  }
+
+  forceinline size_t
+  ReCoStack::stacksize(void) const {
+    return ds.size();
+  }
+
+  forceinline void
+  ReCoStack::unwind(int l) {
+    assert((ds[l].space() == NULL) || ds[l].space()->failed());
+    int n = ds.entries();
+    for (int i=l; i<n; i++)
+      ds.pop().dispose();
+    assert(ds.entries() == l);
+  }
+
+  inline void
+  ReCoStack::reset(void) {
+    while (!ds.empty())
+      ds.pop().dispose();
+  }
+
+  template <bool constrained>
+  forceinline Space*
+  ReCoStack::recompute(unsigned int& d, EngineCtrl& stat) {
+    assert(!ds.empty());
+    // Recompute space according to path
+    // Also say distance to copy (d == 0) requires immediate copying
+
+    // Check for LAO
+    if ((ds.top().space() != NULL) && ds.top().rightmost()) {
+      Space* s = ds.top().space();
+      s->commit(ds.top().desc(),ds.top().alt());
+      ds.top().space(NULL);
+      stat.lao(s);
+      d = 0;
+      stat.commit++;
+      return s;
+    }
+    // General case for recomputation
+    Space* s;             // Last clone
+    int l = lc(s);        // Position of last clone
+    int n = ds.entries(); // Number of stack entries
+    d = n - l;            // New distance, if no adaptive recomputation
+
+    if (constrained) {
+      // The space on the stack could be failed now as an additional
+      // constraint might have been added.
+      if (s->status(stat.propagate) == SS_FAILED) {
+	// s does not need deletion as it is on the stack (unwind does this)
+	stat.fail++;
+	unwind(l);
+	return NULL;
+      }
+      // It is important to replace the space on the stack with the
+      // copy: a copy might be much smaller due to flushed caches
+      // of propagators
+      Space* c = s->clone(true,stat.propagate);
+      ds[l].space(c);
+      stat.constrained(s,c);
+    } else {
+      s = s->clone(true,stat.propagate);
+    }
+    stat.clone++;
+
+    if (d < a_d) {
+      // No adaptive recomputation
+      for (int i=l; i<n; i++)
+	commit(s,i);
+    } else {
+      int m = l + (d >> 1); // Middle between copy and top
+      int i = l;            // To iterate over all entries
+      // Recompute up to middle
+      for (; i<m; i++ )
+	commit(s,i);
+      // Skip over all rightmost branches
+      for (; (i<n) && ds[i].rightmost(); i++)
+	commit(s,i);
+      // Is there any point to make a copy?
+      if (i<n-1) {
+	// Again, the space might already propagate to failure
+	if (constrained && s->status(stat.propagate) == SS_FAILED) {
+	  // s must be deleted as it is not on the stack
+	  delete s;
+	  stat.commit += (i-l);
+	  stat.fail++;
+	  unwind(i);
+	  return NULL;
+	}
+	stat.clone++;
+	ds[i].space(s->clone(true,stat.propagate));
+	stat.adapt(ds[i].space());
+	d = n-i;
+      }
+      // Finally do the remaining commits
+      for (; i<n; i++)
+	commit(s,i);
+    }
+    stat.commit += d;
+    return s;
+  }
+
+}}
+
+// STATISTICS: search-any