gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/gist/nodecursor.cc

@@ -0,0 +1,123 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:30:10 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7335 $
+ *
+ *  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/nodecursor.hh"
+
+namespace Gecode { namespace Gist {
+  
+  HideFailedCursor::HideFailedCursor(VisualNode* root)
+   : NodeCursor<VisualNode>(root) {}
+    
+  void
+  HideFailedCursor::processCurrentNode(void) {
+    VisualNode* n = node();
+    if ((n->getStatus() == BRANCH ||
+         ((n->getStatus() == SPECIAL || n->getStatus() == STEP) && n->hasFailedChildren())) &&
+        !n->hasSolvedChildren() &&
+        n->getNoOfOpenChildren() == 0) {
+      n->setHidden(true);
+      n->setChildrenLayoutDone(false);
+      n->dirtyUp();
+    }
+  }
+
+  UnhideAllCursor::UnhideAllCursor(VisualNode* root)
+   : NodeCursor<VisualNode>(root) {}
+  
+  void
+  UnhideAllCursor::processCurrentNode(void) {
+    VisualNode* n = node();
+    if (n->isHidden()) {
+      n->setHidden(false);
+      n->dirtyUp();
+    }
+  }
+
+  NextSolCursor::NextSolCursor(VisualNode* theNode, bool backwards)
+   : NodeCursor<VisualNode>(theNode), back(backwards) {}
+
+  void
+  NextSolCursor::processCurrentNode(void) {}
+
+  bool
+  NextSolCursor::notOnSol(void) {
+    return node() == startNode() || node()->getStatus() != SOLVED;
+  }
+
+  bool
+  NextSolCursor::mayMoveUpwards(void) {
+    return notOnSol() && !node()->isRoot();
+  }
+
+  bool
+  NextSolCursor::mayMoveDownwards(void) {
+    return notOnSol() && !(back && node() == startNode())
+           && node()->hasSolvedChildren()
+           && NodeCursor<VisualNode>::mayMoveDownwards();
+  }
+
+  void
+  NextSolCursor::moveDownwards(void) {
+    NodeCursor<VisualNode>::moveDownwards();
+    if (back) {
+      while (NodeCursor<VisualNode>::mayMoveSidewards())
+        NodeCursor<VisualNode>::moveSidewards();
+    }
+  }
+
+  bool
+  NextSolCursor::mayMoveSidewards(void) {
+    if (back) {
+      return notOnSol() && !node()->isRoot() && alternative() > 0;
+    } else {
+      return notOnSol() && !node()->isRoot() &&
+             (alternative() < node()->getParent()->getNumberOfChildren() - 1);
+    }
+  }
+
+  void
+  NextSolCursor::moveSidewards(void) {
+    if (back) {
+      alternative(alternative()-1);
+      node(node()->getParent()->getChild(alternative()));
+    } else {
+      NodeCursor<VisualNode>::moveSidewards();      
+    }
+  }
+  
+}}
+
+// STATISTICS: gist-any

data/ext/gecode-2.2.0/gecode/gist/nodecursor.hh

@@ -0,0 +1,147 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:30:10 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7335 $
+ *
+ *  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_NODECURSOR_HH
+#define GECODE_GIST_NODECURSOR_HH
+
+#include "gecode/gist/visualnode.hh"
+
+namespace Gecode { namespace Gist {
+  
+  /// \brief A cursor that can be run over a tree
+  template <class Node>
+  class NodeCursor {
+  private:
+    /// The node where the iteration starts
+    Node* _startNode;
+    /// The current node
+    Node* _node;
+    /// The current alternative
+    unsigned int _alternative;
+  protected:
+    /// Set current node to \a n
+    void node(Node* n);
+    /// Return start node
+    Node* startNode(void);
+  public:
+    /// Construct cursor, initially set to \a theNode
+    NodeCursor(Node* theNode);
+    /// Return current node
+    Node* node(void);
+    /// Return current alternative
+    unsigned int alternative(void);
+    /// Set current alternative
+    void alternative(unsigned int a);
+    
+    /// \name Cursor interface
+    //@{
+    /// Test if the cursor may move to the parent node
+    bool mayMoveUpwards(void);
+    /// Move cursor to the parent node
+    void moveUpwards(void);
+    /// Test if cursor may move to the first child node
+    bool mayMoveDownwards(void);
+    /// Move cursor to the first child node
+    void moveDownwards(void);
+    /// Test if cursor may move to the first sibling
+    bool mayMoveSidewards(void);
+    /// Move cursor to the first sibling
+    void moveSidewards(void);    
+    //@}
+  };
+
+  /// \brief A cursor that marks failed subtrees as hidden
+  class HideFailedCursor : public NodeCursor<VisualNode> {
+  public:
+    /// Constructor
+    HideFailedCursor(VisualNode* theNode);
+    /// \name Cursor interface
+    //@{
+    /// Test if the cursor may move to the first child node
+    bool mayMoveDownwards(void);
+    /// Process node
+    void processCurrentNode(void);
+    //@}
+  };
+  
+  /// \brief A cursor that marks all nodes in the tree as not hidden
+  class UnhideAllCursor : public NodeCursor<VisualNode> {
+  public:
+    /// Constructor
+    UnhideAllCursor(VisualNode* theNode);
+    /// \name Cursor interface
+    //@{
+    /// Process node
+    void processCurrentNode(void);
+    //@}
+  };
+  
+  /// \brief A cursor that finds the next solution
+  class NextSolCursor : public NodeCursor<VisualNode> {
+  private:
+    /// The root node
+    VisualNode* root;
+    /// Whether to search backwards
+    bool back;
+    /// Whether the current node is not a solution
+    bool notOnSol(void);
+  public:
+    /// Constructor
+    NextSolCursor(VisualNode* theNode, bool backwards);
+    /// \name Cursor interface
+    //@{
+    /// Do nothing
+    void processCurrentNode(void);
+    /// Test if the cursor may move to the parent node
+    bool mayMoveUpwards(void);
+    /// Test if cursor may move to the first child node
+    bool mayMoveDownwards(void);
+    /// Move cursor to the first child node
+    void moveDownwards(void);
+    /// Test if cursor may move to the first sibling
+    bool mayMoveSidewards(void);
+    /// Move cursor to the first sibling
+    void moveSidewards(void);    
+    //@}
+  };
+  
+}}
+
+#include "gecode/gist/nodecursor.icc"
+
+#endif
+
+// STATISTICS: gist-any

data/ext/gecode-2.2.0/gecode/gist/nodecursor.icc

@@ -0,0 +1,122 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:30:10 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7335 $
+ *
+ *  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 {
+
+  template <class Node>
+  forceinline
+  NodeCursor<Node>::NodeCursor(Node* theNode) : _startNode(theNode), _node(theNode), _alternative(theNode->getAlternative()) {}
+
+  template <class Node>
+  forceinline Node*
+  NodeCursor<Node>::node(void) { return _node; }
+
+  template <class Node>
+  forceinline unsigned int
+  NodeCursor<Node>::alternative(void) { return _alternative; }
+
+  template <class Node>
+  forceinline void
+  NodeCursor<Node>::alternative(unsigned int a) { _alternative=a; }
+
+  template <class Node>
+  forceinline Node*
+  NodeCursor<Node>::startNode(void) { return _startNode; }
+
+  template <class Node>
+  forceinline void
+  NodeCursor<Node>::node(Node* n) { _node = n; }
+
+  template <class Node>
+  forceinline bool
+  NodeCursor<Node>::mayMoveUpwards(void) {
+    return _node != _startNode && !_node->isRoot();
+  }
+
+  template <class Node>
+  forceinline void
+  NodeCursor<Node>::moveUpwards(void) {
+    _node = static_cast<Node*>(_node->getParent());
+    if (_node->isRoot()) {
+      _alternative = 0;
+    } else {
+      Node* p = static_cast<Node*>(_node->getParent());
+      for (int i=p->getNumberOfChildren(); i--;) {
+        if (p->getChild(i) == _node) {
+          _alternative = i;
+          break;
+        }
+      }
+    }
+  }
+
+  template <class Node>
+  forceinline bool
+  NodeCursor<Node>::mayMoveDownwards(void) {
+    return _node->getNumberOfChildren() > 0;
+  }
+
+  template <class Node>
+  forceinline void
+  NodeCursor<Node>::moveDownwards(void) {
+    _alternative = 0;
+    _node = _node->getChild(0);
+  }
+
+  template <class Node>
+  forceinline bool
+  NodeCursor<Node>::mayMoveSidewards(void) {
+    return (!_node->isRoot()) && (_node != _startNode) &&
+      (_alternative < _node->getParent()->getNumberOfChildren() - 1);
+  }
+
+  template <class Node>
+  forceinline void
+  NodeCursor<Node>::moveSidewards(void) {
+    _node = static_cast<Node*>(_node->getParent()->getChild(++_alternative));
+  }
+
+  forceinline bool
+  HideFailedCursor::mayMoveDownwards(void) {
+    VisualNode* n = node();
+    return NodeCursor<VisualNode>::mayMoveDownwards() &&
+           (n->hasSolvedChildren() || n->getNoOfOpenChildren() > 0) &&
+           (! n->isHidden());
+  }
+
+}}
+
+// STATISTICS: gist-any

data/ext/gecode-2.2.0/gecode/gist/preferences.cc

@@ -0,0 +1,120 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-26 22:53:19 +0200 (Sat, 26 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7427 $
+ *
+ *  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/preferences.hh"
+
+namespace Gecode { namespace Gist {
+  
+  PreferencesDialog::PreferencesDialog(QWidget *parent) : QDialog(parent) {
+    QSettings settings("gecode.org", "Gist");
+    hideFailed = settings.value("search/hideFailed", true).toBool();
+    zoom = settings.value("search/zoom", false).toBool();
+    refresh = settings.value("search/refresh", 500).toInt();
+    smoothScrollAndZoom =
+      settings.value("smoothScrollAndZoom", true).toBool();
+    
+    hideCheck =
+      new QCheckBox(tr("Hide failed subtrees automatically"));
+    hideCheck->setChecked(hideFailed);
+    zoomCheck =
+      new QCheckBox(tr("Automatic zoom enabled on start-up"));
+    zoomCheck->setChecked(zoom);
+    smoothCheck =
+      new QCheckBox(tr("Smooth scrolling and zooming"));
+    smoothCheck->setChecked(smoothScrollAndZoom);
+    
+    QPushButton* defButton = new QPushButton(tr("Defaults"));
+    QPushButton* cancelButton = new QPushButton(tr("Cancel"));
+    QPushButton* okButton = new QPushButton(tr("Ok"));
+    okButton->setDefault(true);
+    QHBoxLayout* buttonLayout = new QHBoxLayout();
+    buttonLayout->addWidget(defButton);
+    buttonLayout->addWidget(cancelButton);
+    buttonLayout->addWidget(okButton);
+    
+    connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
+    connect(defButton, SIGNAL(clicked()), this, SLOT(defaults()));
+    connect(okButton, SIGNAL(clicked()), this, SLOT(writeBack()));
+    
+    QLabel* refreshLabel = new QLabel(tr("Display refresh rate:"));
+    refreshBox  = new QSpinBox();
+    refreshBox->setRange(0, 1000000);
+    refreshBox->setValue(refresh);
+    refreshBox->setSingleStep(100);
+    QHBoxLayout* refreshLayout = new QHBoxLayout();
+    refreshLayout->addWidget(refreshLabel);
+    refreshLayout->addWidget(refreshBox);
+    
+    QVBoxLayout* layout = new QVBoxLayout();
+    layout->addWidget(hideCheck);
+    layout->addWidget(zoomCheck);
+    layout->addWidget(smoothCheck);
+    layout->addLayout(refreshLayout);
+    layout->addLayout(buttonLayout);
+    setLayout(layout);
+    setWindowTitle(tr("Preferences"));
+  }
+
+  void
+  PreferencesDialog::writeBack(void) {
+    hideFailed = hideCheck->isChecked();
+    zoom = zoomCheck->isChecked();
+    refresh = refreshBox->value();
+    smoothScrollAndZoom = smoothCheck->isChecked();
+    QSettings settings("gecode.org", "Gist");
+    settings.setValue("search/hideFailed", hideFailed);
+    settings.setValue("search/zoom", zoom);
+    settings.setValue("search/refresh", refresh);
+    settings.setValue("smoothScrollAndZoom", smoothScrollAndZoom);
+    
+    accept();
+  }
+
+  void
+  PreferencesDialog::defaults(void) {
+    hideFailed = true;
+    zoom = false;
+    refresh = 500;
+    smoothScrollAndZoom = true;
+    hideCheck->setChecked(hideFailed);
+    zoomCheck->setChecked(zoom);
+    refreshBox->setValue(refresh);
+    smoothCheck->setChecked(smoothScrollAndZoom);
+  }
+  
+}}
+
+// STATISTICS: gist-any