dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/spacenode.hh

@@ -0,0 +1,221 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-08-11 23:13:48 +1000 (Wed, 11 Aug 2010) $ by $Author: tack $
+ *     $Revision: 11343 $
+ *
+ *  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_GIST_SPACENODE_HH
+#define GECODE_GIST_SPACENODE_HH
+
+#include <gecode/gist/node.hh>
+#include <gecode/kernel.hh>
+
+namespace Gecode { namespace Gist {
+
+  /** \brief Status of nodes in the search tree
+   */
+  enum NodeStatus {
+    SOLVED,       ///< Node representing a solution
+    FAILED,       ///< Node representing failure
+    BRANCH,       ///< Node representing a branch
+    UNDETERMINED, ///< Node that has not been explored yet
+    STOP,         ///< Node representing stop point
+    UNSTOP,       ///< Node representing ignored stop point
+  };
+
+  static const unsigned int FIRSTBIT = 24; //< First free bit in status word
+  static const unsigned int STATUSMASK = 7<<20; //< Mask for accessing status
+  static const unsigned int MAXDISTANCE = (1<<20)-1; //< Maximum representable distance
+  static const unsigned int DISTANCEMASK = (1<<20)-1; //< Mask for accessing distance
+
+  /// %Statistics about the search tree
+  class Statistics : public StatusStatistics {
+  public:
+    /// Number of solutions
+    int solutions;
+    /// Number of failures
+    int failures;
+    /// Number of choice nodes
+    int choices;
+    /// Number of open, undetermined nodes
+    int undetermined;
+    /// Maximum depth of the tree
+    int maxDepth;
+
+    /// Constructor
+    Statistics(void)
+      : solutions(0), failures(0), choices(0), undetermined(1), maxDepth(0) {}
+  };
+
+  class SpaceNode;
+
+  /// \brief Static reference to the currently best space
+  class BestNode {
+  public:
+    /// The currently best node found, or NULL
+    SpaceNode* s;
+    /// Constructor
+    BestNode(SpaceNode* s0);
+  };
+
+  /// \brief A node of a search tree of %Gecode spaces
+  class SpaceNode : public Node {
+  protected:
+    /** \brief A copy used for recomputation, or NULL
+     *
+     * If the copy is marked, it is a working copy, i.e.,
+     * it does not have to be kept for recomputation.
+     */
+    Space* copy;
+  protected:
+    const Choice* choice;
+
+    /** \brief Status of the node
+     *
+     * If the node has a working copy, the first 20 bits encode the distance
+     * to the closest copy. The next 5 bits encode the NodeStatus, and the
+     * remaining bits are used by the VisualNode class for further flags.
+     */
+    unsigned int nstatus;
+
+    /// Set distance from copy
+    void setDistance(unsigned int d);
+    
+    /// Return distance from copy
+    unsigned int getDistance(void) const;
+
+    /// Set status flag
+    void setFlag(int flag, bool value);
+
+    /// Return status flag
+    bool getFlag(int flag) const;
+
+    /// Flags for SpaceNodes
+    enum SpaceNodeFlags {
+      HASOPENCHILDREN = FIRSTBIT,
+      HASFAILEDCHILDREN,
+      HASSOLVEDCHILDREN
+    };
+    /// Last bit used for SpaceNode flags
+    static const int LASTBIT = HASSOLVEDCHILDREN;
+
+  private:
+    /// Set whether the node has children that are not fully explored
+    void setHasOpenChildren(bool b);
+    /// Set whether the subtree of this node is known to contain failure
+    void setHasFailedChildren(bool b);
+    /// Set whether the subtree of this node is known to contain solutions
+    void setHasSolvedChildren(bool b);
+
+    /// Recompute workingSpace from a copy higher up, return distance to copy
+    int recompute(NodeAllocator& na,
+                  BestNode* curBest, int c_d, int a_d);
+
+    /// Book-keeping of open children
+    void closeChild(const NodeAllocator& na,
+                    bool hadFailures, bool hadSolutions);
+  protected:
+    /// Set status to \a s
+    void setStatus(NodeStatus s);
+    /// Acquire working space, either from parent or by recomputation
+    void acquireSpace(NodeAllocator& na,
+                      BestNode* curBest, int c_d, int a_d);
+  public:
+    /// Construct node with parent \a p
+    SpaceNode(int p);
+    /// Construct root node from Space \a root and branch-and-bound object \a better
+    SpaceNode(Space* root);
+
+    /// Return working space.  Receiver must delete the space.
+    Space* getSpace(NodeAllocator& na,
+                    BestNode* curBest, int c_d, int a_d);
+
+    /// Return working space (if present).
+    const Space* getWorkingSpace(void) const;
+
+    /// Clear working space and copy (if present and this is not the root).
+    void purge(const NodeAllocator& na);
+
+    /// Free allocated memory
+    void dispose(void);
+
+    /// Return whether this node is the currently best solution
+    bool isCurrentBest(BestNode* curBest);
+
+    /** \brief Compute and return the number of children
+      *
+      * On a node whose status is already determined, this function
+      * just returns the number of children.  On an undetermined node,
+      * it first acquires a Space (possibly through recomputation), and
+      * then asks for its status.  If the space is solved or failed, the
+      * node's status will be set accordingly, and 0 will be returned.
+      * Otherwise, the status is SS_BRANCH, and as many new children will
+      * be created as the branch has alternatives, and the number returned.
+      */
+    int getNumberOfChildNodes(NodeAllocator& na,
+                              BestNode* curBest,
+                              Statistics& stats,
+                              int c_d, int a_d);
+
+    /// Return current status of the node
+    NodeStatus getStatus(void) const;
+
+    /// Return whether this node still has open children
+    bool isOpen(void);
+    /// Return whether the subtree of this node has any failed children
+    bool hasFailedChildren(void);
+    /// Return whether the subtree of this node has any solved children
+    bool hasSolvedChildren(void);
+    /// Return whether the subtree of this node has any open children
+    bool hasOpenChildren(void);
+    /// Return number of open children
+    int getNoOfOpenChildren(const NodeAllocator& na);
+    /// Set number of open children to \a n
+    void setNoOfOpenChildren(int n);
+    /// Return whether the node has a copy
+    bool hasCopy(void);
+    /// Return whether the node has a working space
+    bool hasWorkingSpace(void);
+
+    /// Return alternative number of this node
+    int getAlternative(const NodeAllocator& na) const;
+    /// Return choice of this node
+    const Choice* getChoice(void);
+  };
+
+}}
+
+#endif
+
+// STATISTICS: gist-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/spacenode.hpp

@@ -0,0 +1,191 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-08-12 19:02:06 +1000 (Thu, 12 Aug 2010) $ by $Author: tack $
+ *     $Revision: 11347 $
+ *
+ *  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 Gist {
+
+  forceinline void
+  SpaceNode::setFlag(int flag, bool value) {
+    if (value)
+      nstatus |= 1<<(flag-1);
+    else
+      nstatus &= ~(1<<(flag-1));
+  }
+
+  forceinline bool
+  SpaceNode::getFlag(int flag) const {
+    return (nstatus & (1<<(flag-1))) != 0;
+  }
+
+  forceinline void
+  SpaceNode::setHasOpenChildren(bool b) {
+    setFlag(HASOPENCHILDREN, b);
+  }
+
+  forceinline void
+  SpaceNode::setHasFailedChildren(bool b) {
+    setFlag(HASFAILEDCHILDREN, b);
+  }
+
+  forceinline void
+  SpaceNode::setHasSolvedChildren(bool b) {
+    setFlag(HASSOLVEDCHILDREN, b);
+  }
+
+  forceinline void
+  SpaceNode::setStatus(NodeStatus s) {
+    nstatus &= ~( STATUSMASK );
+    nstatus |= s << 20;
+  }
+
+  forceinline NodeStatus
+  SpaceNode::getStatus(void) const {
+    return static_cast<NodeStatus>((nstatus & STATUSMASK) >> 20);
+  }
+
+  forceinline void
+  SpaceNode::setDistance(unsigned int d) {
+    if (d > MAXDISTANCE)
+      d = MAXDISTANCE;
+    nstatus &= ~( DISTANCEMASK );
+    nstatus |= d;
+  }
+  
+  forceinline unsigned int
+  SpaceNode::getDistance(void) const {
+    return nstatus & DISTANCEMASK;
+  }
+
+  forceinline
+  SpaceNode::SpaceNode(int p)
+  : Node(p), copy(NULL), nstatus(0) {
+    choice = NULL;
+    setStatus(UNDETERMINED);
+    setHasSolvedChildren(false);
+    setHasFailedChildren(false);
+  }
+
+  forceinline Space*
+  SpaceNode::getSpace(NodeAllocator& na,
+                      BestNode* curBest, int c_d, int a_d) {
+    acquireSpace(na,curBest,c_d,a_d);
+    Space* ret;
+    if (Support::marked(copy)) {
+      ret = static_cast<Space*>(Support::unmark(copy));
+      copy = NULL;
+    } else {
+      ret = copy->clone();
+    }
+    return ret;
+  }
+
+  forceinline const Space*
+  SpaceNode::getWorkingSpace(void) const {
+    assert(copy != NULL);
+    if (Support::marked(copy))
+      return static_cast<Space*>(Support::unmark(copy));
+    return copy;
+  }
+
+  forceinline void
+  SpaceNode::purge(const NodeAllocator& na) {
+    if (!isRoot() && (getStatus() != SOLVED || !na.bab())) {
+      // only delete copies from solutions if we are not in BAB
+      if (Support::marked(copy))
+        delete static_cast<Space*>(Support::unmark(copy));
+      else
+        delete copy;
+      copy = NULL;
+    }
+  }
+
+
+  forceinline bool
+  SpaceNode::isCurrentBest(BestNode* curBest) {
+    return curBest != NULL && curBest->s == this;
+  }
+
+  forceinline bool
+  SpaceNode::isOpen(void) {
+    return ((getStatus() == UNDETERMINED) ||
+            getFlag(HASOPENCHILDREN));
+  }
+
+  forceinline bool
+  SpaceNode::hasFailedChildren(void) {
+    return getFlag(HASFAILEDCHILDREN);
+  }
+
+  forceinline bool
+  SpaceNode::hasSolvedChildren(void) {
+    return getFlag(HASSOLVEDCHILDREN);
+  }
+
+  forceinline bool
+  SpaceNode::hasOpenChildren(void) {
+    return getFlag(HASOPENCHILDREN);
+  }
+
+  forceinline bool
+  SpaceNode::hasCopy(void) {
+    return copy != NULL;
+  }
+
+  forceinline bool
+  SpaceNode::hasWorkingSpace(void) {
+    return copy != NULL && Support::marked(copy);
+  }
+
+  forceinline int
+  SpaceNode::getAlternative(const NodeAllocator& na) const {
+    SpaceNode* p = getParent(na);
+    if (p == NULL)
+      return -1;
+    for (int i=p->getNumberOfChildren(); i--;)
+      if (p->getChild(na,i) == this)
+        return i;
+    GECODE_NEVER;
+    return -1;
+  }
+
+  forceinline const Choice*
+  SpaceNode::getChoice(void) {
+    return choice;
+  }
+
+}}
+
+// STATISTICS: gist-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/standalone-example/mygist.cpp

@@ -0,0 +1,80 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 20:35:31 +1000 (Thu, 08 Apr 2010) $ by $Author: schulte $
+ *     $Revision: 10684 $
+ *
+ *  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 <QtGui>
+
+#include <gecode/int.hh>
+#include <gecode/gist/qtgist.hh>
+#include <gecode/gist/mainwindow.hh>
+
+using namespace Gecode;
+
+/// Space for testing
+class TestSpace : public Space {
+public:
+  IntVarArray x;
+  TestSpace(void) : x(*this,2,0,2) {
+    branch(*this, x, INT_VAR_NONE, INT_VAL_MIN);
+  }
+  TestSpace(bool share, TestSpace& t) : Space(share, t) {
+    x.update(*this, share, t.x);
+  }
+  virtual Space* copy(bool share) { 
+    return new TestSpace(share,*this); 
+  }
+  virtual void print(std::ostream& os) const {
+    os << x << std::endl;
+  }
+};
+
+int main(int argc, char** argv) {
+  QApplication app(argc,argv);
+  Gist::Print<TestSpace> p("My Gist");
+  Gist::Options o;
+  o.inspect.click(&p);
+
+  Gist::GistMainWindow gist_mw(new TestSpace(), false, o);
+  gist_mw.show();
+
+  QMainWindow mw;
+  Gist::Gist gist_widget(new TestSpace(), false, &mw, o);
+  mw.setCentralWidget(&gist_widget);
+  mw.resize(500,300);
+  mw.show();
+
+  return app.exec();
+}