gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,277 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2008-08-20 15:55:47 +0200 (Wed, 20 Aug 2008) $ by $Author: tack $
+ *     $Revision: 7658 $
+ *
+ *  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.
+ *
+ */
+
+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();
+  }
+
+  template <class DescType>
+  forceinline const BranchingDesc*
+  ReCoStack::nextDesc(EngineCtrl& stat, int& alt, int& closedDescs) {
+    closedDescs = 0;
+    while (!ds.empty())
+      if (ds.top().rightmost()) {
+        stat.pop(ds.top().space(),ds.top().desc());
+        if (dynamic_cast<const DescType*>(ds.top().desc()))
+          closedDescs++;
+        ds.pop().dispose();
+      } else {
+        ds.top().next();
+        alt = ds.top().alt();
+        return ds.top().desc();
+      }
+    return NULL;
+  }
+
+  template <class DescType, bool inclusive>
+  forceinline void
+  ReCoStack::closeBranch(EngineCtrl& stat) {
+    while (!ds.empty()) {
+      if (dynamic_cast<const DescType*>(ds.top().desc())) {
+        if (inclusive && !ds.empty()) {
+          stat.pop(ds.top().space(),ds.top().desc());
+          ds.pop().dispose();      
+        }
+        break;       
+      }
+      stat.pop(ds.top().space(),ds.top().desc());
+      ds.pop().dispose();
+    }
+  }
+
+  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 = static_cast<unsigned int>(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();
+      ds[l].space(c);
+      stat.constrained(s,c);
+    } else {
+      s = s->clone();
+    }
+    stat.clone++;
+
+    if (d < a_d) {
+      // No adaptive recomputation
+      for (int i=l; i<n; i++)
+        commit(s,i);
+    } else {
+      int m = l + static_cast<int>(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) {
+        // Propagate to fixpoint
+        SpaceStatus ss = s->status(stat.propagate);
+        /*
+         * Again, the space might already propagate to failure
+         *
+         * This can be for two reasons:
+         *  - constrain is true, so we fail
+         *  - the space has weakly monotonic propagators
+         */
+        if (ss == 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());
+        stat.adapt(ds[i].space());
+        d = static_cast<unsigned int>(n-i);
+      }
+      // Finally do the remaining commits
+      for (; i<n; i++)
+        commit(s,i);
+    }
+    stat.commit += d;
+    return s;
+  }
+
+}}
+
+// STATISTICS: search-any

data/ext/gecode-2.2.0/gecode/serialization.hh

@@ -0,0 +1,149 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:39:08 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7297 $
+ *
+ *  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_SERIALIZATION_HH__
+#define __GECODE_SERIALIZATION_HH__
+
+#include "gecode/kernel.hh"
+
+/*
+ * Support for DLLs under Windows
+ *
+ */
+
+#if !defined(GECODE_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_SERIALIZATION
+#define GECODE_SERIALIZATION_EXPORT __declspec( dllexport )
+#else
+#define GECODE_SERIALIZATION_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
+
+#define GECODE_SERIALIZATION_EXPORT __attribute__ ((visibility("default")))
+
+#else
+
+#define GECODE_SERIALIZATION_EXPORT
+
+#endif
+#endif
+
+#include <iostream>
+#include <vector>
+
+namespace Gecode {
+
+  /**
+   * \brief Produce FlatZinc-like representation of \a home
+   * \ingroup TaskSerialization
+   *
+   * A FlatZinc-like representation of the space \a home is written
+   * to \a os, respecting the variable names established by \a m.
+   *
+   * The generated code is not completely FlatZinc-compatible, as
+   * propagator names are represented as C++-style template names.
+   *
+   */
+  GECODE_SERIALIZATION_EXPORT
+  void emitFlatzinc(Space* home, std::ostream& os);
+
+  /**
+   * \brief Produce JavaScript representation of \a home
+   * \ingroup TaskSerialization
+   *
+   * A JavaScript representation of the space \a home is written
+   * to \a os, respecting the variable names established by \a m.
+   *
+   */
+  GECODE_SERIALIZATION_EXPORT
+  void emitJavaScript(Space* home, std::ostream& os);
+
+#ifdef GECODE_HAS_QT
+  /**
+    * \brief Parse JavaScript \a model and post constraints in \a home
+    * \ingroup TaskSerialization
+    */
+  GECODE_SERIALIZATION_EXPORT
+  void fromJavaScript(Space* home, const std::string& model);
+#endif
+
+namespace Serialization {
+  /**
+   * \namespace Gecode::Serialization
+   * \brief Serialization and deserialization support
+   */
+  
+  /// Initialize the registry of post functions
+  GECODE_SERIALIZATION_EXPORT 
+  void initRegistry(void);
+}
+}
+
+#ifdef GECODE_HAS_BOOST
+
+namespace Gecode {
+  /**
+   * \brief Serialize \a actors to \a os
+   * \ingroup TaskSerialization
+   */ 
+  GECODE_SERIALIZATION_EXPORT
+  void boostTextSerialization(std::ostream& os,
+    const std::vector<Reflection::VarSpec>& vars,
+    const std::vector<Reflection::ActorSpec>& actors);
+  /**
+   * \brief Deserialize \a is into \a actors
+   * \ingroup TaskSerialization
+   */
+  GECODE_SERIALIZATION_EXPORT
+  void boostTextSerialization(std::istream& is,
+    std::vector<Reflection::VarSpec>& vars,
+    std::vector<Reflection::ActorSpec>& actors);
+}
+
+#include "gecode/serialization/boost.icc"
+
+#endif
+
+
+#endif
+
+// STATISTICS: serialization-any