gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/gist/shapelist.hh

@@ -0,0 +1,140 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-12-04 12:51:49 +0100 (Tue, 04 Dec 2007) $ by $Author: tack $
+ *     $Revision: 5571 $
+ *
+ *  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_SHAPELIST_HH
+#define GECODE_GIST_SHAPELIST_HH
+
+#include <vector>
+#include <iostream>
+
+namespace Gecode { namespace Gist {
+
+  /// \brief Bounding box
+  class BoundingBox {
+  public:
+    /// Left coordinate
+    int left;
+    /// Right coordinate 
+    int right;
+    /// Depth
+    int depth;
+    /// Constructor
+    BoundingBox(int l, int r, int d);
+    /// Default constructor
+    BoundingBox(void) {}
+  };
+
+  /// \brief Extent, representing shape of a tree at one depth level
+  class Extent {
+  public:
+    /// Left extent
+    int l;
+    /// Right extent
+    int r;
+    /// Default constructor
+    Extent(void);
+    /// Construct with \a l0 and \a r0
+    Extent(int l0, int r0);
+    /// Construct with width \a width
+    Extent(int width);
+    
+    /// Extend extent by \a deltaL and \a deltaR
+    void extend(int deltaL, int deltaR);
+    /// Move extent by \a delta
+    void move(int delta);
+  };
+
+  /// \brief The shape of a subtree
+  class Shape {
+  private:
+    /// The shape is a vector of extents, one for each depth level
+    std::vector<Extent> shape;
+    /// Copy construtor
+    Shape(const Shape&);
+  public:
+    /// Default constructor
+    Shape(void);
+    /// Construct with single extent \a e
+    Shape(Extent e);
+    /// Construct with \e for the root and \a subShape for the children
+    Shape(Extent e, const Shape* subShape);
+    /// Construct from \a subShape
+    Shape(const Shape* subShape);
+    
+    /// Return depth of the shape
+    int depth(void) const;
+    /// Add \a to the shape
+    void add(Extent e);
+    /// Return extent at depth \a i
+    Extent get(int i);
+    /// Extend the shape by \a deltaL and \a deltaR
+    void extend(int deltaL, int deltaR);
+    /// Move the shape by \a delta
+    void move(int delta);
+    /// Return if extent exists at \a depth, if yes return it in \a extent
+    bool getExtentAtDepth(int depth, Extent& extent);
+    BoundingBox getBoundingBox(void);
+  };
+
+  /// \brief Container for shapes
+  class ShapeList {
+  private:
+    /// The shapes
+    std::vector<Shape*> shapes;
+    /// The minimal distance necessary between two nodes
+    int minimalSeparation;
+    /// Offsets computed
+    std::vector<int> offsets;
+    /// Compute distance needed between \a shape1 and \a shape2
+    int getAlpha(Shape* shape1, Shape* shape2);
+    /// Merge \a shape1 and \a shape2 with distance \a alpha
+    static Shape* merge(Shape* shape1, Shape* shape2, int alpha);
+  public:
+    /// Constructor
+    ShapeList(int length, int minSeparation);
+    /// Return the merged shape
+    Shape* getMergedShape(bool left = false);
+    /// Return offset computed for child \a i
+    int getOffsetOfChild(int i);
+    /// Return shape no \a i
+    Shape*& operator[](int i);
+  };
+  
+}}
+
+#endif
+
+// STATISTICS: gist-any

data/ext/gecode-2.1.1/gecode/gist/spacenode.cc

@@ -0,0 +1,531 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-02-19 11:05:15 +0100 (Tue, 19 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6231 $
+ *
+ *  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 <stack>
+
+namespace Gecode { namespace Gist {
+  
+  // TODO nikopp: doxygen comments
+  enum BranchKind {
+    BK_NORMAL, BK_SPECIAL_IN, BK_SPECIAL_OUT, BK_STEP
+  };
+
+  /// \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 BranchKind branchKind;
+    union {
+      /// Special branching description
+      const SpecialDesc* special;
+      /// Branching description
+      const BranchingDesc* branch;
+      /// Step description
+      const StepDesc* step;
+    } desc;
+    
+    /// Constructor
+    Branch(int a, const BranchingDesc* d, SpaceNode* best = NULL, BranchKind bk = BK_NORMAL)
+      : alternative(a), ownBest(best), branchKind(bk) {
+        desc.branch = d;
+      }
+    Branch(int a, const SpecialDesc* d, BranchKind bk, SpaceNode* best = NULL)
+      : alternative(a), ownBest(best), branchKind(bk) {
+        desc.special = d;
+      }
+    Branch(int a, const StepDesc* d, BranchKind bk, SpaceNode* best = NULL)
+      : alternative(a), ownBest(best), branchKind(bk) {
+        desc.step = d;
+      }
+ };
+
+ Statistics Statistics::dummy;
+
+  /// \brief Initial configuration settings for search
+  class Config {
+  public:
+    /// Distance for adaptive recomputation
+    static const int a_d = 100000;
+    /// Distance for fixed recomputation
+    static const int mrd = 4;
+  };
+  
+  StepDesc::StepDesc(int steps) : noOfSteps(steps), debug(false) { }
+  
+  void
+  StepDesc::toggleDebug(void) {
+   debug = !debug;
+  }
+  
+  SpecialDesc::SpecialDesc(std::string varName, int rel0, int v0)
+  : vn(varName), v(v0), rel(rel0) { }
+
+  BestNode::BestNode(SpaceNode* s0, Better* b0) : s(s0), b(b0) {}
+  
+  SpaceNode*
+  SpaceNode::getParent() {
+    return static_cast<SpaceNode*>(Node::getParent());
+  }
+
+  SpaceNode*
+  SpaceNode::getChild(int i) {
+    return static_cast<SpaceNode*>(Node::getChild(i));
+  }
+
+  int
+  SpaceNode::recompute(void) {
+    int rdist = 0;
+    
+    if (workingSpace == NULL) {
+      SpaceNode* curNode = this;
+      SpaceNode* lastFixpoint = NULL;
+
+      if(curNode->getStatus() != SPECIAL && curNode->getStatus() != STEP) {
+        lastFixpoint = curNode;
+      }
+      
+      std::stack<Branch> stck;
+      bool specialNodeOnPath = false;
+      
+      while (curNode->copy == NULL) {
+        SpaceNode* parent = curNode->getParent();
+
+        if(curNode->getStatus() == STEP) {
+          Branch b(curNode->alternative, curNode->desc.step, BK_STEP);
+          stck.push(b);
+          if(lastFixpoint == NULL && parent->getStatus() == BRANCH) {
+             lastFixpoint = parent;
+          }
+      } else if(curNode->getStatus() == SPECIAL) {
+          Branch b(curNode->alternative, curNode->desc.special, BK_SPECIAL_IN);
+          stck.push(b);
+          if(lastFixpoint == NULL && parent->getStatus() == BRANCH) {
+            lastFixpoint = parent;
+          }
+          specialNodeOnPath = true;
+          // TODO nikopp: if the root node is failed, it neither has a copy nor a parent and we are not allowed to do the following
+        } else if(parent->getStatus() == SPECIAL || parent->getStatus() == STEP) {
+           Branch b(curNode->alternative, curNode->desc.special, BK_SPECIAL_OUT);
+          stck.push(b);
+        } else {
+          Branch b(curNode->alternative, parent->desc.branch,
+                   curBest == NULL ? NULL : curNode->ownBest);
+          stck.push(b);
+        }
+        
+        curNode = parent;
+        rdist++;
+      }
+      Space* curSpace = curNode->copy->clone();
+      
+      SpaceNode* lastBest = NULL;
+      SpaceNode* middleNode = curNode;
+      int curDist = 0;
+
+      while (!stck.empty()) {
+        if (Config::a_d >= 0 &&
+            curDist > Config::a_d &&
+            middleNode->getStatus() != SPECIAL &&
+            middleNode->getStatus() != STEP &&
+            curDist == rdist / 2) {
+              middleNode->copy = curSpace->clone();
+        }
+        Branch b = stck.top(); stck.pop();
+        
+        if(middleNode == lastFixpoint) {
+          curSpace->status();
+        }
+        
+        switch (b.branchKind) {
+        case BK_NORMAL:
+            {
+              curSpace->commit(b.desc.branch, b.alternative);
+            }
+            break;
+        case BK_STEP:
+            {
+            }
+            break;
+        case BK_SPECIAL_IN:
+            {
+            }
+            break;
+        case BK_SPECIAL_OUT:
+         // really do nothing
+          break;
+        }
+
+        if (b.ownBest != NULL && b.ownBest != lastBest) {
+          b.ownBest->acquireSpace();
+          curBest->b->constrain(curSpace, b.ownBest->workingSpace);
+          lastBest = b.ownBest;
+        }
+        curDist++;
+        middleNode = middleNode->getChild(b.alternative);
+      }
+      workingSpace = curSpace;
+      
+    }
+    return rdist;
+  }
+  
+  Space*
+  SpaceNode::donateSpace(int alt, SpaceNode* ownBest) {
+    Space* ret = workingSpace;
+    if (ret != NULL) {
+      workingSpace = NULL;
+      if (desc.branch != NULL)
+        ret->commit(desc.branch, alt);
+      
+      if (ownBest != NULL) {
+        ownBest->acquireSpace();
+        curBest->b->constrain(ret, ownBest->workingSpace);
+      }
+    }
+    return ret;
+  }
+  
+  Space*
+  SpaceNode::checkLAO(int alt, SpaceNode* ownBest) {
+    Space* ret = NULL;
+    if (copy != NULL && noOfOpenChildren == 1 && getParent() != NULL) {
+      // last alternative optimization
+      ret = copy;
+      copy = NULL;
+      
+      if(desc.branch != NULL)
+        ret->commit(desc.branch, alt);
+
+      if (ownBest != NULL) {
+        ownBest->acquireSpace();
+        curBest->b->constrain(ret, ownBest->workingSpace);
+      }
+    }
+    return ret;
+  }
+  
+  void
+  SpaceNode::acquireSpace(void) {
+    SpaceNode* p = getParent();
+
+    if (status == UNDETERMINED && curBest != NULL && ownBest == NULL &&
+        p != NULL && curBest->s != p->ownBest) {
+          ownBest = curBest->s;
+    }
+
+    if (status != SPECIAL && status != STEP) {
+      if (workingSpace == NULL && p != NULL) {
+        workingSpace = p->donateSpace(alternative, ownBest);
+      }
+    }
+
+    if (workingSpace == NULL) {
+      if (recompute() > Config::mrd && Config::mrd >= 0 &&
+          status != SPECIAL && status != STEP &&
+          workingSpace->status() == SS_BRANCH) {
+            copy = workingSpace->clone();
+      }
+    }
+
+    if (status != SPECIAL && status != STEP) {
+      // always return a fixpoint
+      workingSpace->status();
+      if (copy == NULL && p != NULL && isOpen()) {
+        copy = p->checkLAO(alternative, ownBest);
+        if (copy != NULL && copy->status() == SS_FAILED) {
+          delete copy;
+          copy = NULL;
+        }
+      }
+    }
+  }
+  
+  Better*
+  SpaceNode::getBetterWrapper(void) const {
+    return curBest == NULL ? NULL : curBest->b;
+  }
+  
+  void
+  SpaceNode::solveUp(void) {
+    SpaceNode* p = getParent();
+    _hasSolvedChildren = true;
+    if (p != NULL && !p->_hasSolvedChildren) {
+        p->solveUp();
+    }
+  }
+  
+  void
+  SpaceNode::closeChild(bool hadFailures, bool hadSolutions) {
+    noOfOpenChildren--;
+    _hasFailedChildren = _hasFailedChildren || hadFailures;
+    _hasSolvedChildren = _hasSolvedChildren || hadSolutions;
+    SpaceNode* p = getParent();
+    if (noOfOpenChildren == 0) {
+      // stats.close();
+      if (p != NULL) {
+        delete copy;
+        copy = NULL;        
+        p->closeChild(_hasFailedChildren, _hasSolvedChildren);
+      }
+    } else if (hadSolutions) {
+        solveUp();
+    }
+  }
+
+  SpaceNode::SpaceNode(int alt, BestNode* cb)
+  : copy(NULL), workingSpace(NULL), curBest(cb), ownBest(NULL) {
+    desc.branch = NULL;
+    alternative = alt;
+    status = UNDETERMINED;
+    _hasSolvedChildren = false;
+    _hasFailedChildren = false;
+  }
+
+  SpaceNode::SpaceNode(Space* root, Better* b)
+  : workingSpace(root), curBest(NULL), ownBest(NULL) {
+    desc.branch = NULL;
+    if (root == NULL) {
+      status = FAILED;
+      _hasSolvedChildren = false;
+      _hasFailedChildren = true;
+      setNumberOfChildren(0);
+      copy = root;
+      return;
+    }
+    if (!root->failed())
+      copy = root->clone();
+    else
+      copy = root;
+    status = UNDETERMINED;
+    _hasSolvedChildren = false;
+    _hasFailedChildren = false;
+    if (b != NULL)
+      curBest = new BestNode(NULL, b);
+  }
+
+  SpaceNode::~SpaceNode(void) {
+    if(status == SPECIAL)
+      delete desc.special;
+    else if (status == STEP)
+      delete desc.step;
+    else
+      delete desc.branch;
+    delete copy;
+    delete workingSpace;
+    if (getParent() == NULL)
+      delete curBest;
+  }
+    
+  Space*
+  SpaceNode::getSpace(void) {
+    acquireSpace();
+    Space* ret = workingSpace;
+    workingSpace = NULL;
+    return ret;
+  }
+
+  bool
+  SpaceNode::isCurrentBest(void) {
+    return curBest != NULL && curBest->s == this;
+  }
+
+
+  int
+  SpaceNode::getNumberOfChildNodes(Statistics& stats) {
+    int kids = getNumberOfChildren();
+    if (kids == -1) {
+      stats.undetermined--;
+      acquireSpace();
+      switch (workingSpace->status()) {
+      case SS_FAILED:
+        {
+          delete workingSpace;
+          workingSpace = NULL;
+          // we may have got a copy from LAO!
+          if (getParent() != NULL) {
+            delete copy;
+            copy = NULL;
+          }
+          kids = 0;
+          _hasSolvedChildren = false;
+          _hasFailedChildren = true;
+          status = FAILED;
+          stats.failures++;
+          // stats.newDepth(getDepth());
+          SpaceNode* p = getParent();
+          if (p != NULL)
+            p->closeChild(true, false);
+        }
+        break;
+      case SS_SOLVED:
+        {
+          kids = 0;
+          status = SOLVED;
+          // we may have got a copy from LAO
+          if (getParent() != NULL) {
+            delete copy;
+            copy = NULL;
+          }
+          _hasSolvedChildren = true;
+          _hasFailedChildren = false;
+          stats.solutions++;
+          // stats.newDepth(getDepth());
+          if (curBest != NULL) {
+            curBest->s = this;
+          }
+          SpaceNode* p = getParent();
+          if (p != NULL)
+            p->closeChild(false, true);
+        }
+        break;
+      case SS_BRANCH:
+        desc.branch = workingSpace->description();
+        kids = desc.branch->alternatives();
+        status = BRANCH;
+        stats.choices++;
+        stats.undetermined += kids;
+        // stats.newOpen();
+        // stats.newDepth(getDepth() + 1);
+        break;
+      }
+      changedStatus();
+      setNumberOfChildren(kids);
+      noOfOpenChildren = kids;
+      for (int i=kids; i--;) {
+        SpaceNode* child = createChild(i);
+        setChild(i, child);
+      }
+    }
+    return kids;
+  }
+  
+  NodeStatus
+  SpaceNode::getStatus(void) {
+    return status;
+  }
+  
+  void
+  SpaceNode::setStatus(NodeStatus s) {
+    status = s;
+  }
+    
+  void
+  SpaceNode::setSpecialDesc(const SpecialDesc* d) {
+    desc.special = d;
+  }
+    
+  void
+  SpaceNode::setStepDesc(StepDesc* d) {
+    desc.step = d;
+  }
+    
+  StepDesc*
+  SpaceNode::getStepDesc(void) {
+    StepDesc* ret = NULL;
+    if(isStepNode()) {
+      ret = desc.step;
+    }
+    return ret;
+  }
+    
+  bool
+  SpaceNode::isStepNode(void) {
+    return getStatus() == STEP;
+  }
+
+ int
+  SpaceNode::getAlternative(void) {
+    return alternative;
+  }
+    
+  bool
+  SpaceNode::isOpen(void) {
+    return status == UNDETERMINED || noOfOpenChildren > 0;
+  }
+  
+  void
+  SpaceNode::openUp(void) {
+    if(!isOpen() && parent != NULL) {
+      getParent()->openUp();
+    }
+    noOfOpenChildren++;
+  }
+  
+  bool
+  SpaceNode::hasFailedChildren(void) {
+    return _hasFailedChildren;
+  }
+  
+  bool
+  SpaceNode::hasSolvedChildren(void) {
+    return _hasSolvedChildren;
+  }
+
+  int
+  SpaceNode::getNoOfOpenChildren(void) {
+    return noOfOpenChildren;
+  }
+        
+  void
+  SpaceNode::setNoOfOpenChildren(int n) {
+    noOfOpenChildren = n;
+  }
+        
+  bool
+  SpaceNode::hasCopy(void) {
+    return copy != NULL;
+  }
+
+  bool
+  SpaceNode::hasWorkingSpace(void) {
+    return workingSpace != NULL;
+  }
+
+  SpaceNode*
+  SpaceNode::createChild(int alternative) {
+    return new SpaceNode(alternative, curBest);
+  }
+  
+  void
+  SpaceNode::changedStatus() {}
+  
+}}
+
+// STATISTICS: gist-any