dep-selector-libgecode 1.0.0.alpha.0

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

@@ -0,0 +1,294 @@
+/* -*- 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 18:29:27 +1000 (Thu, 12 Aug 2010) $ by $Author: tack $
+ *     $Revision: 11346 $
+ *
+ *  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_QTGIST_HH
+#define GECODE_GIST_QTGIST_HH
+
+#include <gecode/gist/treecanvas.hh>
+#include <gecode/gist/nodestats.hh>
+
+/*
+ * Configure linking
+ *
+ */
+
+#if !defined(GIST_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_GIST
+#define GECODE_GIST_EXPORT __declspec( dllexport )
+#else
+#define GECODE_GIST_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
+#define GECODE_GIST_EXPORT __attribute__ ((visibility("default")))
+#else
+#define GECODE_GIST_EXPORT
+#endif
+
+#endif
+
+// Configure auto-linking
+#ifndef GECODE_BUILD_GIST
+#define GECODE_LIBRARY_NAME "Gist"
+#include <gecode/support/auto-link.hpp>
+#endif
+
+namespace Gecode {  namespace Gist {
+
+  /**
+   * \brief %Gecode Interactive %Search Tool
+   *
+   * This class provides an interactive search tree viewer and explorer as
+   * a Qt widget. You can embedd or inherit from this widget to use %Gist
+   * in your own project.
+   *
+   * \ingroup TaskGist
+   */
+  class GECODE_GIST_EXPORT Gist : public QWidget {
+    Q_OBJECT
+  private:
+    /// The canvas implementation
+    TreeCanvas* canvas;
+    /// The time slider
+    QSlider* timeBar;
+    /// Context menu
+    QMenu* contextMenu;
+    /// Action used when no solution inspector is registered
+    QAction* nullSolutionInspector;
+    /// Menu of solution inspectors
+    QMenu* solutionInspectorMenu;
+    /// Action used when no double click inspector is registered
+    QAction* nullDoubleClickInspector;
+    /// Menu of double click inspectors
+    QMenu* doubleClickInspectorMenu;
+    /// Action used when no double click inspector is registered
+    QAction* nullMoveInspector;
+    /// Menu of double click inspectors
+    QMenu* moveInspectorMenu;
+    /// Action used when no comparator is registered
+    QAction* nullComparator;
+    /// Menu of comparators
+    QMenu* comparatorMenu;
+    /// Action used when no bookmark exists
+    QAction* nullBookmark;
+    /// Bookmark menu
+    QMenu* bookmarksMenu;
+    /// Menu for direct node inspection
+    QMenu* inspectNodeMenu;
+    /// Menu for direct node inspection before fixpoint
+    QMenu* inspectNodeBeforeFPMenu;
+    /// Information about individual nodes
+    NodeStatInspector* nodeStatInspector;
+  public:
+    /// Inspect current node
+    QAction* inspect;
+    /// Inspect current node before fixpoint
+    QAction* inspectBeforeFP;
+    /// Stop search
+    QAction* stop;
+    /// Reset %Gist
+    QAction* reset;
+    /// Navigate to parent node
+    QAction* navUp;
+    /// Navigate to leftmost child node
+    QAction* navDown;
+    /// Navigate to left sibling
+    QAction* navLeft;
+    /// Navigate to right sibling
+    QAction* navRight;
+    /// Navigate to root node
+    QAction* navRoot;
+    /// Navigate to next solution (to the left)
+    QAction* navNextSol;
+    /// Navigate to previous solution (to the right)
+    QAction* navPrevSol;
+    /// Search next solution in current subtree
+    QAction* searchNext;
+    /// Search all solutions in current subtree
+    QAction* searchAll;
+    /// Toggle whether current node is hidden
+    QAction* toggleHidden;
+    /// Hide failed subtrees under current node
+    QAction* hideFailed;
+    /// Unhide all hidden subtrees under current node
+    QAction* unhideAll;
+    /// Zoom tree to fit window
+    QAction* zoomToFit;
+    /// Center on current node
+    QAction* center;
+    /// Export PDF of current subtree
+    QAction* exportPDF;
+    /// Export PDF of whole tree
+    QAction* exportWholeTreePDF;
+    /// Print tree
+    QAction* print;
+
+    /// Bookmark current node
+    QAction* bookmarkNode;
+    /// Compare current node to other node
+    QAction* compareNode;
+    /// Compare current node to other node before fixpoint
+    QAction* compareNodeBeforeFP;
+    /// Set path from current node to the root
+    QAction* setPath;
+    /// Inspect all nodes on selected path
+    QAction* inspectPath;
+    /// Open node statistics inspector
+    QAction* showNodeStats;
+    /// Bookmark current node
+    QAction* toggleStop;
+    /// Bookmark current node
+    QAction* unstopAll;
+
+    /// Group of all actions for solution inspectors
+    QActionGroup* solutionInspectorGroup;
+    /// Group of all actions for double click inspectors
+    QActionGroup* doubleClickInspectorGroup;
+    /// Group of all actions for move inspectors
+    QActionGroup* moveInspectorGroup;
+    /// Group of all actions for comparators
+    QActionGroup* comparatorGroup;
+    /// Group of all actions for bookmarks
+    QActionGroup* bookmarksGroup;
+    /// Group of all actions for direct inspector selection
+    QActionGroup* inspectGroup;
+    /// Group of all actions for direct inspector selection
+    QActionGroup* inspectBeforeFPGroup;
+  public:
+    /// Constructor
+    Gist(Space* root, bool bab, QWidget* parent, const Options& opt);
+    /// Destructor
+    ~Gist(void);
+
+    /// Add double click inspector \a i0
+    void addDoubleClickInspector(Inspector* i0);
+    /// Add solution inspector \a i0
+    void addSolutionInspector(Inspector* i0);
+    /// Add move inspector \a i0
+    void addMoveInspector(Inspector* i0);
+    /// Add comparator \a c0
+    void addComparator(Comparator* c0);
+
+    /// Set preference whether to automatically hide failed subtrees
+    void setAutoHideFailed(bool b);
+    /// Set preference whether to automatically zoom to fit
+    void setAutoZoom(bool b);
+    /// Return preference whether to automatically hide failed subtrees
+    bool getAutoHideFailed(void);
+    /// Return preference whether to automatically zoom to fit
+    bool getAutoZoom(void);
+    /// Set preference whether to show copies in the tree
+    void setShowCopies(bool b);
+    /// Return preference whether to show copies in the tree
+    bool getShowCopies(void);
+
+    /// Set refresh rate
+    void setRefresh(int i);
+    /// Set refresh pause in msec
+    void setRefreshPause(int i);
+    /// Return preference whether to use smooth scrolling and zooming
+    bool getSmoothScrollAndZoom(void);
+    /// Set preference whether to use smooth scrolling and zooming
+    void setSmoothScrollAndZoom(bool b);
+
+    /// Set recomputation parameters \a c_d and \a a_d
+    void setRecompDistances(int c_d, int a_d);
+    /// Return recomputation distance
+    int getCd(void);
+    /// Return adaptive recomputation distance
+    int getAd(void);
+
+    /// Stop search and wait until finished
+    bool finish(void);
+
+    /// Handle resize event
+    void resizeEvent(QResizeEvent*);
+
+  Q_SIGNALS:
+    /// Signals that the tree has changed
+    void statusChanged(const Statistics&, bool);
+
+    /// Signals that a solution has been found
+    void solution(const Space*);
+
+    /// Signals that %Gist is ready to be closed
+    void searchFinished(void);
+
+  private Q_SLOTS:
+    /// Displays the context menu for a node
+    void on_canvas_contextMenu(QContextMenuEvent*);
+    /// Reacts on status changes
+    void on_canvas_statusChanged(VisualNode*, const Statistics&, bool);
+    /// Reacts on double click inspector selection
+    void selectDoubleClickInspector(QAction*);
+    /// Reacts on solution inspector selection
+    void selectSolutionInspector(QAction*);
+    /// Reacts on move inspector selection
+    void selectMoveInspector(QAction*);
+    /// Reacts on comparator selection
+    void selectComparator(QAction*);
+    /// Reacts on bookmark selection
+    void selectBookmark(QAction*);
+    /// Reacts on adding a bookmark
+    void addBookmark(const QString& id);
+    /// Reacts on removing a bookmark
+    void removeBookmark(int idx);
+    /// Populate the inspector menus from the actions found in Gist
+    void populateInspectors(void);
+    /// Populate the bookmarks menu
+    void populateBookmarksMenu(void);
+    /// Shows node status information
+    void showStats(void);
+    /// Inspect current node with inspector described by \a a
+    void inspectWithAction(QAction* a);
+    /// Inspect current node with inspector described by \a a
+    void inspectBeforeFPWithAction(QAction* a);
+  protected:
+    /// Add inspector \a i0
+    void addInspector(Inspector* i, QAction*& nas, QAction*& nad,
+                      QAction*& nam);
+  };
+
+}}
+
+#endif
+
+// STATISTICS: gist-any

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

@@ -0,0 +1,369 @@
+/* -*- 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.
+ *
+ */
+
+#include <gecode/gist/spacenode.hh>
+#include <gecode/gist/visualnode.hh>
+#include <gecode/gist/stopbrancher.hh>
+#include <gecode/search.hh>
+#include <stack>
+
+namespace Gecode { namespace Gist {
+
+  /// \brief Representation of a branch in the search tree
+  class Branch {
+  public:
+    /// Alternative number
+    int alternative;
+    /// The best space known when the branch was created
+    SpaceNode* ownBest;
+    const Choice* choice;
+
+    /// Constructor
+    Branch(int a, const Choice* c, SpaceNode* best = NULL)
+      : alternative(a), ownBest(best) {
+        choice = c;
+      }
+  };
+
+  BestNode::BestNode(SpaceNode* s0) : s(s0) {}
+
+  int
+  SpaceNode::recompute(NodeAllocator& na,
+                       BestNode* curBest, int c_d, int a_d) {
+    int rdist = 0;
+
+    if (copy == NULL) {
+      SpaceNode* curNode = this;
+      SpaceNode* lastFixpoint = NULL;
+
+      lastFixpoint = curNode;
+
+      std::stack<Branch> stck;
+
+      int idx = getIndex(na);
+      while (curNode->copy == NULL) {
+        SpaceNode* parent = curNode->getParent(na);
+        int parentIdx = curNode->getParent();
+        int alternative = curNode->getAlternative(na);
+
+        SpaceNode* ownBest = na.best(idx);
+        Branch b(alternative, parent->choice,
+                 curBest == NULL ? NULL : ownBest);
+        stck.push(b);
+
+        curNode = parent;
+        idx = parentIdx;
+        rdist++;
+      }
+      Space* curSpace = curNode->copy->clone();
+      curNode->setDistance(0);
+
+      SpaceNode* lastBest = NULL;
+      SpaceNode* middleNode = curNode;
+      int curDist = 0;
+
+      while (!stck.empty()) {
+        if (a_d >= 0 &&
+            curDist > a_d &&
+            curDist == rdist / 2) {
+            if (curSpace->status() == SS_FAILED) {
+              copy = static_cast<Space*>(Support::mark(curSpace));
+              return rdist;
+            } else {
+              middleNode->copy = curSpace->clone();
+            }
+        }
+        Branch b = stck.top(); stck.pop();
+
+        if(middleNode == lastFixpoint) {
+          curSpace->status();
+        }
+
+        curSpace->commit(*b.choice, b.alternative);
+
+        if (b.ownBest != NULL && b.ownBest != lastBest) {
+          b.ownBest->acquireSpace(na,curBest, c_d, a_d);
+          Space* ownBestSpace =
+            static_cast<Space*>(Support::funmark(b.ownBest->copy));
+          if (ownBestSpace->status() != SS_SOLVED) {
+            // in the presence of weakly monotonic propagators, we may have to
+            // use search to find the solution here
+            ownBestSpace = Gecode::dfs(ownBestSpace);
+            if (Support::marked(b.ownBest->copy)) {
+              delete static_cast<Space*>(Support::unmark(b.ownBest->copy));
+              b.ownBest->copy = 
+                static_cast<Space*>(Support::mark(ownBestSpace));
+            } else {
+              delete b.ownBest->copy;
+              b.ownBest->copy = ownBestSpace;
+            }
+          }
+          curSpace->constrain(*ownBestSpace);
+          lastBest = b.ownBest;
+        }
+        curDist++;
+        middleNode = middleNode->getChild(na,b.alternative);
+        middleNode->setDistance(curDist);
+      }
+      copy = static_cast<Space*>(Support::mark(curSpace));
+
+    }
+    return rdist;
+  }
+
+  void
+  SpaceNode::acquireSpace(NodeAllocator& na,
+                          BestNode* curBest, int c_d, int a_d) {
+    SpaceNode* p = getParent(na);
+    int parentIdx = getParent();
+    int idx = getIndex(na);
+
+    if (getStatus() == UNDETERMINED && curBest != NULL &&
+        na.best(idx) == NULL &&
+        p != NULL && curBest->s != na.best(parentIdx)) {
+      na.setBest(idx, curBest->s->getIndex(na));
+    }
+    SpaceNode* ownBest = na.best(idx);
+
+    if (copy == NULL && p != NULL && p->copy != NULL && 
+        Support::marked(p->copy)) {
+      // If parent has a working space, steal it
+      copy = p->copy;
+      p->copy = NULL;
+      if (p->choice != NULL)
+        static_cast<Space*>(Support::unmark(copy))->
+          commit(*p->choice, getAlternative(na));
+
+      if (ownBest != NULL) {
+        ownBest->acquireSpace(na,curBest, c_d, a_d);
+        Space* ownBestSpace = 
+          static_cast<Space*>(Support::funmark(ownBest->copy));
+        if (ownBestSpace->status() != SS_SOLVED) {
+          // in the presence of weakly monotonic propagators, we may have to
+          // use search to find the solution here
+
+          ownBestSpace = Gecode::dfs(ownBestSpace);
+          if (Support::marked(ownBest->copy)) {
+            delete static_cast<Space*>(Support::unmark(ownBest->copy));
+            ownBest->copy =
+              static_cast<Space*>(Support::mark(ownBestSpace));
+          } else {
+            delete ownBest->copy;
+            ownBest->copy = ownBestSpace;
+          }
+        }
+        static_cast<Space*>(Support::unmark(copy))->constrain(*ownBestSpace);
+      }
+      int d = p->getDistance()+1;
+      if (d > c_d && c_d >= 0 &&
+          static_cast<Space*>(Support::unmark(copy))->status() == SS_BRANCH) {
+        copy = static_cast<Space*>(Support::unmark(copy));
+        d = 0;
+      }
+      setDistance(d);
+    }
+
+    if (copy == NULL) {
+      if (recompute(na, curBest, c_d, a_d) > c_d && c_d >= 0 &&
+          static_cast<Space*>(Support::unmark(copy))->status() == SS_BRANCH) {
+        copy = static_cast<Space*>(Support::unmark(copy));
+        setDistance(0);
+      }
+    }
+
+    // always return a fixpoint
+    static_cast<Space*>(Support::funmark(copy))->status();
+    if (Support::marked(copy) && p != NULL && isOpen() &&
+        p->copy != NULL && p->getNoOfOpenChildren(na) == 1 &&
+        !p->isRoot()) {
+      // last alternative optimization
+
+      // If p->copy was a working space, we would have stolen it by now
+      assert(!Support::marked(p->copy));
+
+      copy = static_cast<Space*>(Support::unmark(copy));
+      delete p->copy;
+      p->copy = NULL;
+      setDistance(0);
+      p->setDistance(p->getParent(na)->getDistance()+1);
+    }
+  }
+
+  void
+  SpaceNode::closeChild(const NodeAllocator& na,
+                        bool hadFailures, bool hadSolutions) {
+    setHasFailedChildren(hasFailedChildren() || hadFailures);
+    setHasSolvedChildren(hasSolvedChildren() || hadSolutions);
+
+    bool allClosed = true;
+    for (int i=getNumberOfChildren(); i--;) {
+      if (getChild(na,i)->isOpen()) {
+        allClosed = false;
+        break;
+      }
+    }
+
+    if (allClosed) {
+      setHasOpenChildren(false);
+      for (unsigned int i=0; i<getNumberOfChildren(); i++)
+        setHasSolvedChildren(hasSolvedChildren() ||
+          getChild(na,i)->hasSolvedChildren());
+      SpaceNode* p = getParent(na);
+      if (p != NULL) {
+        delete copy;
+        copy = NULL;
+        p->closeChild(na, hasFailedChildren(), hasSolvedChildren());
+      }
+    } else {
+      
+      if (hadSolutions) {
+        setHasSolvedChildren(true);
+        SpaceNode* p = getParent(na);
+        while (p != NULL && !p->hasSolvedChildren()) {
+          p->setHasSolvedChildren(true);
+          p = p->getParent(na);
+        }
+      }
+      if (hadFailures) {
+        SpaceNode* p = getParent(na);
+        while (p != NULL && !p->hasFailedChildren()) {
+          p->setHasFailedChildren(true);
+          p = p->getParent(na);
+        }        
+      }
+    }
+
+  }
+
+  SpaceNode::SpaceNode(Space* root)
+  : Node(-1, root==NULL),
+    copy(root), choice(NULL), nstatus(0) {
+    if (root == NULL) {
+      setStatus(FAILED);
+      setHasSolvedChildren(false);
+      setHasFailedChildren(true);
+    } else {
+      setStatus(UNDETERMINED);
+      setHasSolvedChildren(false);
+      setHasFailedChildren(false);
+    }
+  }
+
+  void
+  SpaceNode::dispose(void) {
+    delete choice;
+    delete static_cast<Space*>(Support::funmark(copy));
+  }
+
+
+  int
+  SpaceNode::getNumberOfChildNodes(NodeAllocator& na,
+                                   BestNode* curBest, Statistics& stats,
+                                   int c_d, int a_d) {
+    int kids = 0;
+    if (isUndetermined()) {
+      stats.undetermined--;
+      acquireSpace(na, curBest, c_d, a_d);
+      switch (static_cast<Space*>(Support::funmark(copy))->status(stats)) {
+      case SS_FAILED:
+        {
+          purge(na);
+          kids = 0;
+          setHasOpenChildren(false);
+          setHasSolvedChildren(false);
+          setHasFailedChildren(true);
+          setStatus(FAILED);
+          stats.failures++;
+          SpaceNode* p = getParent(na);
+          if (p != NULL)
+            p->closeChild(na, true, false);
+        }
+        break;
+      case SS_SOLVED:
+        {
+          // Deletes all pending branchers
+          (void) static_cast<Space*>(Support::funmark(copy))->choice();
+          kids = 0;
+          setStatus(SOLVED);
+          setHasOpenChildren(false);
+          setHasSolvedChildren(true);
+          setHasFailedChildren(false);
+          stats.solutions++;
+          if (curBest != NULL) {
+            curBest->s = this;
+          }
+          SpaceNode* p = getParent(na);
+          if (p != NULL)
+            p->closeChild(na, false, true);
+        }
+        break;
+      case SS_BRANCH:
+        {
+          choice = static_cast<Space*>(Support::funmark(copy))->choice();
+          kids = choice->alternatives();
+          setHasOpenChildren(true);
+          if (dynamic_cast<const StopChoice*>(choice)) {
+            setStatus(STOP);
+          } else {
+            setStatus(BRANCH);
+            stats.choices++;
+          }
+          stats.undetermined += kids;
+        }
+        break;
+      }
+      static_cast<VisualNode*>(this)->changedStatus(na);
+      setNumberOfChildren(kids, na);
+    } else {
+      kids = getNumberOfChildren();
+    }
+    return kids;
+  }
+
+  int
+  SpaceNode::getNoOfOpenChildren(const NodeAllocator& na) {
+    if (!hasOpenChildren())
+      return 0;
+    int noOfOpenChildren = 0;
+    for (int i=getNumberOfChildren(); i--;)
+      noOfOpenChildren += (getChild(na,i)->isOpen());
+    return noOfOpenChildren;
+  }
+
+}}
+
+// STATISTICS: gist-any