dep-selector-libgecode 1.0.0.alpha.0

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

@@ -0,0 +1,82 @@
+/* -*- 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 20:41:24 +1000 (Wed, 11 Aug 2010) $ by $Author: tack $
+ *     $Revision: 11340 $
+ *
+ *  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/support.hh>
+#include <gecode/gist/node.hh>
+#include <gecode/gist/visualnode.hh>
+#include <cassert>
+
+namespace Gecode { namespace Gist {
+
+  void
+  Node::setNumberOfChildren(unsigned int n, NodeAllocator& na) {
+    assert(getTag() == UNDET);
+    switch (n) {
+    case 0:
+      setTag(LEAF);
+      break;
+    case 1:
+      childrenOrFirstChild = 
+        reinterpret_cast<void*>(na.allocate(getIndex(na)) << 2);
+      noOfChildren = 1;
+      setTag(TWO_CHILDREN);
+      break;
+    case 2:
+      {
+        int idx = getIndex(na);
+        childrenOrFirstChild =
+          reinterpret_cast<void*>(na.allocate(idx) << 2);
+        noOfChildren = -na.allocate(idx);
+        setTag(TWO_CHILDREN);
+      }
+      break;
+    default:
+      {
+        int idx = getIndex(na);
+        noOfChildren = n;
+        int* children = heap.alloc<int>(n);
+        childrenOrFirstChild = static_cast<void*>(children);
+        setTag(MORE_CHILDREN);
+        for (unsigned int i=n; i--;)
+          children[i] = na.allocate(idx);
+      }
+    }
+  }
+
+}}
+
+// STATISTICS: gist-any

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

@@ -0,0 +1,160 @@
+/* -*- 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 21:38:27 +1000 (Thu, 12 Aug 2010) $ by $Author: zayenz $
+ *     $Revision: 11349 $
+ *
+ *  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_NODE_HH
+#define GECODE_GIST_NODE_HH
+
+#include <gecode/kernel.hh>
+
+namespace Gecode { namespace Gist {
+
+  class VisualNode;
+
+  /// Node allocator
+  template<class T>
+  class NodeAllocatorBase {
+  private:
+    /// Size of each block of nodes
+    static const int NodeBlockSize = 1<<14;
+    /// Blocks of nodes
+    class Block {
+    public:
+      /// The actual nodes
+      T b[NodeBlockSize];
+      /// The index of the best known previous solution for each node
+      int best[NodeBlockSize];
+    };
+    /// Array of blocks
+    Block** b;
+    /// Size of the array
+    int n;
+    /// Current block number
+    int cur_b;
+    /// Current node number in current block
+    int cur_t;
+    /// Allocate new block, potentially reallocate block array
+    void allocate(void);
+    /// Flag whether search uses branch-and-bound
+    bool _bab;
+  public:
+    /// Constructor
+    NodeAllocatorBase(bool bab);
+    /// Destructor
+    ~NodeAllocatorBase(void);
+    /// Allocate new node with parent \a p
+    int allocate(int p);
+    /// Allocate new root node for space \a root
+    int allocate(Space* root);
+    /// Return node for index \a i
+    T* operator [](int i) const;
+    /// Return index of best node before \a i
+    T* best(int i) const;
+    /// Set index of best node before \a i to \a b
+    void setBest(int i, int b);
+    /// Return branch-and-bound flag
+    bool bab(void) const;
+  };
+
+  /// \brief Base class for nodes of the search tree
+  class Node {
+  private:
+    /// Tags that are used to encode the number of children
+    enum {
+      UNDET, //< Number of children not determined
+      LEAF,  //< Leaf node
+      TWO_CHILDREN, //< Node with at most two children
+      MORE_CHILDREN //< Node with more than two children
+    };
+
+    /// The children, or in case there are at most two, the first child
+    void* childrenOrFirstChild;
+
+    /** The number of children, in case it is greater than 2, or the first
+     *  child (if negative)
+     */
+    int noOfChildren;
+
+    /// The parent of this node, or NULL for the root
+    int parent;
+
+    /// Read the tag of childrenOrFirstChild
+    unsigned int getTag(void) const;
+    /// Set the tag of childrenOrFirstChild
+    void setTag(unsigned int tag);
+    /// Return childrenOrFirstChild without tag
+    void* getPtr(void) const;
+    /// Return childrenOrFirstChild as integer
+    int getFirstChild(void) const;
+
+  protected:
+    /// Return whether this node is undetermined
+    bool isUndetermined(void) const;
+
+    /// Return index of child no \a n
+    int getChild(int n) const;
+  public:
+    typedef NodeAllocatorBase<VisualNode> NodeAllocator;
+
+    /// Construct node with parent \a p
+    Node(int p, bool failed = false);
+
+    /// Return the parent
+    int getParent(void) const;
+    /// Return the parent
+    VisualNode* getParent(const NodeAllocator& na) const;
+    /// Return child no \a n
+    VisualNode* getChild(const NodeAllocator& na, int n) const;
+
+    /// Return index of this node
+    int getIndex(const NodeAllocator& na) const;
+
+    /// Check if this node is the root of a tree
+    bool isRoot(void) const;
+
+    /// Set the number of children to \a n and initialize children
+    void setNumberOfChildren(unsigned int n, NodeAllocator& na);
+
+    /// Return the number of children
+    unsigned int getNumberOfChildren(void) const;
+    
+  };
+
+}}
+
+#endif
+
+// STATISTICS: gist-any

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

@@ -0,0 +1,210 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-05-02 23:44:28 +1000 (Mon, 02 May 2011) $ by $Author: tack $
+ *     $Revision: 11981 $
+ *
+ *  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 T>
+  void
+  NodeAllocatorBase<T>::allocate(void) {
+    cur_b++;
+    cur_t = 0;
+    if (cur_b==n) {
+      int oldn = n;
+      n *= 1.5;
+      b = heap.realloc<Block*>(b,oldn,n);
+    }
+    b[cur_b] = static_cast<Block*>(heap.ralloc(sizeof(Block)));
+  }
+
+  template<class T>
+  NodeAllocatorBase<T>::NodeAllocatorBase(bool bab) : _bab(bab) {
+    b = heap.alloc<Block*>(10);
+    n = 10;
+    cur_b = -1;
+    cur_t = NodeBlockSize-1;
+  }
+
+  template<class T>
+  NodeAllocatorBase<T>::~NodeAllocatorBase(void) {
+    for (int i=cur_b+1; i--;)
+      heap.rfree(b[i]);
+    heap.free<Block*>(b,n);
+  }
+
+  template<class T>
+  forceinline int
+  NodeAllocatorBase<T>::allocate(int p) {
+    cur_t++;
+    if (cur_t==NodeBlockSize)
+      allocate();
+    new (&b[cur_b]->b[cur_t]) T(p);
+    b[cur_b]->best[cur_t] = -1;
+    return cur_b*NodeBlockSize+cur_t;
+  }
+
+  template<class T>
+  forceinline int
+  NodeAllocatorBase<T>::allocate(Space* root) {
+    cur_t++;
+    if (cur_t==NodeBlockSize)
+      allocate();
+    new (&b[cur_b]->b[cur_t]) T(root);
+    b[cur_b]->best[cur_t] = -1;
+    return cur_b*NodeBlockSize+cur_t;
+  }
+
+  template<class T>
+  forceinline T*
+  NodeAllocatorBase<T>::operator [](int i) const {
+    assert(i/NodeBlockSize < n);
+    assert(i/NodeBlockSize < cur_b || i%NodeBlockSize <= cur_t);
+    return &(b[i/NodeBlockSize]->b[i%NodeBlockSize]);
+  }
+
+  template<class T>
+  forceinline T*
+  NodeAllocatorBase<T>::best(int i) const {
+    assert(i/NodeBlockSize < n);
+    assert(i/NodeBlockSize < cur_b || i%NodeBlockSize <= cur_t);
+    int bi = b[i/NodeBlockSize]->best[i%NodeBlockSize];
+    return bi == -1 ? NULL : (*this)[bi];
+  }
+
+  template<class T>
+  forceinline void
+  NodeAllocatorBase<T>::setBest(int i, int best) {
+    assert(i/NodeBlockSize < n);
+    assert(i/NodeBlockSize < cur_b || i%NodeBlockSize <= cur_t);
+    b[i/NodeBlockSize]->best[i%NodeBlockSize] = best;
+  }
+  
+  template<class T>
+  forceinline bool
+  NodeAllocatorBase<T>::bab(void) const {
+    return _bab;
+  }
+  
+  forceinline unsigned int
+  Node::getTag(void) const {
+    return static_cast<unsigned int>
+      (reinterpret_cast<ptrdiff_t>(childrenOrFirstChild) & 3);
+  }
+
+  forceinline void
+  Node::setTag(unsigned int tag) {
+    assert(tag <= 3);
+    assert(getTag() == UNDET);
+    childrenOrFirstChild = reinterpret_cast<void*>
+      ( (reinterpret_cast<ptrdiff_t>(childrenOrFirstChild) & ~(3)) | tag);
+  }
+
+  forceinline void*
+  Node::getPtr(void) const {
+    return reinterpret_cast<void*>
+      (reinterpret_cast<ptrdiff_t>(childrenOrFirstChild) & ~(3));
+  }
+
+  forceinline int
+  Node::getFirstChild(void) const {
+    return static_cast<int>
+      ((reinterpret_cast<ptrdiff_t>(childrenOrFirstChild) & ~(3)) >> 2);
+  }
+
+  forceinline
+  Node::Node(int p, bool failed) : parent(p) {
+    childrenOrFirstChild = NULL;
+    noOfChildren = 0;
+    setTag(failed ? LEAF : UNDET);
+  }
+
+  forceinline int
+  Node::getParent(void) const {
+    return parent;
+  }
+
+  forceinline VisualNode*
+  Node::getParent(const NodeAllocator& na) const {
+    return parent < 0 ? NULL : na[parent];
+  }
+
+  forceinline bool
+  Node::isUndetermined(void) const { return getTag() == UNDET; }
+
+  forceinline int
+  Node::getChild(int n) const {
+    assert(getTag() != UNDET && getTag() != LEAF);
+    if (getTag() == TWO_CHILDREN) {
+      assert(n != 1 || noOfChildren <= 0);
+      return n == 0 ? getFirstChild() : -noOfChildren;
+    }
+    assert(n < noOfChildren);
+    return static_cast<int*>(getPtr())[n];
+  }
+
+  forceinline VisualNode*
+  Node::getChild(const NodeAllocator& na, int n) const {
+    return na[getChild(n)];
+  }
+
+  forceinline bool
+  Node::isRoot(void) const { return parent == -1; }
+
+  forceinline unsigned int
+  Node::getNumberOfChildren(void) const {
+    switch (getTag()) {
+    case UNDET: return 0;
+    case LEAF:  return 0;
+    case TWO_CHILDREN: return 1+(noOfChildren <= 0);
+    default: return noOfChildren;
+    }
+  }
+
+  inline int
+  Node::getIndex(const NodeAllocator& na) const {
+    if (parent==-1)
+      return 0;
+    Node* p = na[parent];
+    for (int i=p->getNumberOfChildren(); i--;)
+      if (p->getChild(na,i) == this)
+        return p->getChild(i);
+    GECODE_NEVER;
+    return -1;
+  }
+
+}}
+
+// STATISTICS: gist-any