gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/int/sorted/matching.icc

@@ -0,0 +1,182 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-11-08 15:53:26 +0100 (Thu, 08 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5219 $
+ *
+ *  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 Int { namespace Sorted {
+
+  /**
+   * \brief Glover's maximum matching in a bipartite graph
+   *
+   * Compute a matching in the bipartite convex intersection graph with
+   * one partition containing the x views and the other containing
+   * the y views. The algorithm works with an implicit array structure
+   * of the intersection graph.
+   *
+   * Union-Find Implementation of F.Glover's matching algorithm.
+   *
+   * The idea is to mimick a priority queue storing x-indices
+   * \f$[i_0,\dots, i_{n-1}]\f$, s.t. the upper domain bounds are sorted
+   * \f$D_{i_0} \leq\dots\leq D_{i_{n-1}}\f$ where \f$ D_{i_0}\f$
+   * is the top element
+   *
+   */
+
+  template <class View, class Tuple, bool Perm>
+  inline bool
+  glover(Space*,
+         ViewArray<Tuple>& xz,
+         ViewArray<View>& y,
+         int tau[],
+         int phi[],
+         OfflineMinItem sequence[],
+         int vertices[]) {
+
+    int xs = xz.size();
+    OfflineMin seq(sequence, vertices, xs);
+    int s  = 0;
+    seq.makeset();
+
+    for (int z = 0; z < xs; z++) {  // forall y nodes
+      int maxy = y[z].max();
+      // creating the sequence of inserts and extractions from the queue
+      for( ; s <xs && xz[s][0].min() <= maxy; s++) {
+        seq[s].iset = z;
+        seq[z].rank++;
+      }
+    }
+
+    // offline-min-procedure
+    for (int i = 0; i < xs; i++) {
+      // the upper bound of the x-node should be minimal
+      int perm = tau[i];
+      // find the iteration where \tau(i) became a maching candidate
+      int iter = seq[perm].iset;
+      if (iter<0)
+        return false;
+      int j = 0;
+      j = seq.find_pc(iter);
+      // check whether the sequence is valid
+      if (j >= xs)
+        return false;
+      // if there is no intersection between the matching candidate
+      // and the y node then there exists NO perfect matching
+      if (xz[perm][0].max() < y[j].min())
+        return false;
+      phi[j]         = perm;
+      seq[perm].iset = -5;           //remove from candidate set
+      int sqjsucc    = seq[j].succ;
+      if (sqjsucc < xs) {
+        seq.unite(j,sqjsucc,sqjsucc);
+      } else {
+        seq[seq[j].root].name = sqjsucc; // end of sequence achieved
+      }
+
+      // adjust tree list
+      int pr = seq[j].pred;
+      if (pr != -1)
+        seq[pr].succ = sqjsucc;
+      if (sqjsucc != xs)
+        seq[sqjsucc].pred = pr;
+    }
+    return true;
+  }
+
+  /**
+   * \brief Symmetric glover function for the upper domain bounds
+   *
+   */
+  template <class View, class Tuple, bool Perm>
+  inline bool
+  revglover(Space*,
+            ViewArray<Tuple>& xz,
+            ViewArray<View>& y,
+            int tau[],
+            int phiprime[],
+            OfflineMinItem sequence[],
+            int vertices[]) {
+
+    int xs = xz.size();
+    OfflineMin seq(sequence, vertices, xs);
+    int s  = xs - 1;
+    seq.makeset();
+
+    int miny = 0;
+    for (int z = xs; z--; ) {     // forall y nodes
+      miny = y[z].min();
+      // creating the sequence of inserts and extractions from the queue
+      for ( ; s > -1 && xz[tau[s]][0].max() >= miny; s--) {
+        seq[tau[s]].iset = z;
+        seq[z].rank++;
+      }
+    }
+
+    // offline-min-procedure
+    for (int i = xs; i--; ) {
+      int perm = i;
+      int iter = seq[perm].iset;
+      if (iter < 0)
+        return false;
+      int j = 0;
+      j = seq.find_pc(iter);
+      if (j <= -1)
+        return false;
+      // if there is no intersection between the matching candidate
+      // and the y node then there exists NO perfect matching
+      if (xz[perm][0].min() > y[j].max())
+        return false;
+      phiprime[j]    = perm;
+      seq[perm].iset = -5;
+      int sqjsucc    = seq[j].pred;
+      if (sqjsucc >= 0) {
+        seq.unite(j, sqjsucc, sqjsucc);
+      } else {
+        seq[seq[j].root].name = sqjsucc; // end of sequence achieved
+      }
+
+      // adjust tree list
+      int pr = seq[j].succ;
+      if (pr != xs)
+        seq[pr].pred = sqjsucc;
+      if (sqjsucc != -1)
+        seq[sqjsucc].succ = pr;
+    }
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/sorted/narrowing.icc

@@ -0,0 +1,257 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-11-08 15:53:26 +0100 (Thu, 08 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5219 $
+ *
+ *  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 Int { namespace Sorted {
+
+  /**
+   *   \brief Compute the sccs of the oriented intersection-graph
+   *
+   *   An y-node \f$y_j\f$ and its corresponding matching mate
+   *   \f$x_{\phi(j)}\f$ form the smallest possible scc, since both
+   *   edges \f$e_1(y_j, x_{\phi(j)})\f$ and \f$e_2(x_{\phi(j)},y_j)\f$
+   *   are both contained in the oriented intersection graph.
+   *
+   *   Hence a scc containg more than two nodes is represented as an
+   *   array of SccComponent entries,
+   *   \f$[ y_{j_0},x_{\phi(j_0)},\dots,y_{j_k},x_{\phi(j_k)}]\f$.
+   *
+   *   Parameters
+   *   scclist ~ resulting sccs
+   */
+
+  template<class View, class Tuple>
+  inline void
+  computesccs(Space*,
+              ViewArray<Tuple>& xz,
+              ViewArray<View>& y,
+              int phi[],
+              SccComponent sinfo[],
+              int scclist[]) {
+
+    // number of sccs is bounded by xs (number of x-nodes)
+    int xs = xz.size();
+    Support::StaticStack<int> cs(xs);
+
+    //select an y node from the graph
+    for (int j = 0; j < xs; j++) {
+      int yjmin      = y[j].min();    // the processed min
+      while (!cs.empty() && xz[phi[sinfo[cs.top()].rightmost]][0].max() < yjmin) {
+        // the topmost scc cannot "reach" y_j or a node to the right of it
+        cs.pop();
+      }
+
+      // a component has the form C(y-Node, matching x-Node)
+      // C is a minimal scc in the oriented intersection graph
+      // we only store y_j-Node, since \phi(j) gives the matching X-node
+      int i     = phi[j];
+      int ximin = xz[i][0].min();
+      while (!cs.empty() && ximin <= y[sinfo[cs.top()].rightmost].max()) {
+        // y_j can "reach" cs.top() ,
+        // i.e. component c can reach component cs.top()
+        // merge c and cs.top() into new component
+        int top = cs.top();
+        // connecting
+        sinfo[sinfo[j].leftmost].left        = top;
+        sinfo[top].right                     = sinfo[j].leftmost;
+        // moving leftmost
+        sinfo[j].leftmost                    = sinfo[top].leftmost;
+        // moving rightmost
+        sinfo[sinfo[top].leftmost].rightmost = j;
+        cs.pop();
+      }
+      cs.push(j);
+    }
+    cs.reset();
+
+
+    // now we mark all components with the respective scc-number
+    // labeling is bound by O(k) which is bound by O(n)
+
+    for (int i = 0; i < xs; i++) {
+      if (sinfo[i].left == i) { // only label variables in sccs
+        int scc = sinfo[i].rightmost;
+        int z   = i;
+        //bound by the size of the largest scc = k
+        while (sinfo[z].right != z) {
+          sinfo[z].rightmost   = scc;
+          scclist[phi[z]]      = scc;
+          z                    = sinfo[z].right;
+        }
+        sinfo[z].rightmost     = scc;
+        scclist[phi[z]]        = scc;
+      }
+    }
+  }
+
+  /**
+   *   \brief Narrowing the domains of the x variables
+   *
+   *   Due to the correspondance between perfect matchings in the "reduced"
+   *   intersection graph of \a x and \a y views and feasible
+   *   assignments for the sorted constraint the new domain bounds for
+   *   views in \a x are computed as
+   *      - lower bounds:
+   *        \f$ S_i \geq E_l \f$
+   *        where \f$y_l\f$ is the leftmost neighbour of \f$x_i\f$
+   *      - upper bounds:
+   *        \f$ S_i \leq  E_h \f$
+   *        where \f$y_h\f$ is the rightmost neighbour of \f$x_i\f$
+   */
+
+  template<class View, class Tuple, bool Perm>
+  inline bool
+  narrow_domx(Space* home,
+              ViewArray<Tuple>& xz,
+              ViewArray<View>& y,
+              int tau[],
+              int[],
+              int scclist[],
+              SccComponent sinfo[],
+              bool& nofix) {
+
+    int xs        = xz.size();
+
+    // For every x node
+    for (int i = 0; i < xs; i++) {
+
+      int xmin = xz[i][0].min();
+      /*
+       * take the scc-list for the current x node
+       * start from the leftmost reachable y node of the scc
+       * and check which Y node in the scc is
+       * really the rightmost node intersecting x, i.e.
+       * search for the greatest lower bound of x
+       */
+      int start = sinfo[scclist[i]].leftmost;
+      while (y[start].max() < xmin) {
+        start = sinfo[start].right;
+      }
+        
+      if (Perm) {
+        // start is the leftmost-position for x_i
+        // that denotes the lower bound on p_i
+
+        ModEvent me_plb = xz[i][1].gq(home, start);
+        if (me_failed(me_plb)) {
+          return false;
+        }
+        nofix |= (me_modified(me_plb) && start != xz[i][1].min());
+      }
+
+      ModEvent me_lb = xz[i][0].gq(home, y[start].min());
+      if (me_failed(me_lb)) {
+        return false;
+      }
+      nofix |= (me_modified(me_lb) &&
+                y[start].min() != xz[i][0].min());
+        
+      int ptau = tau[xs - 1 - i];
+      int xmax = xz[ptau][0].max();
+      /*
+       * take the scc-list for the current x node
+       * start from the rightmost reachable node and check which
+       * y node in the scc is
+       * really the rightmost node intersecting x, i.e.
+       * search for the smallest upper bound of x
+       */
+      start = sinfo[scclist[ptau]].rightmost;
+      while (y[start].min() > xmax) {
+        start = sinfo[start].left;
+      }
+
+      if (Perm) {
+        //start is the rightmost-position for x_i
+        //that denotes the upper bound on p_i
+        ModEvent me_pub = xz[ptau][1].lq(home, start);
+        if (me_failed(me_pub)) {
+          return false;
+        }
+        nofix |= (me_modified(me_pub) && start != xz[ptau][1].max());
+      }
+
+      ModEvent me_ub = xz[ptau][0].lq(home, y[start].max());
+      if (me_failed(me_ub)) {
+        return false;
+      }
+      nofix |= (me_modified(me_ub) &&
+                y[start].max() != xz[ptau][0].max());
+    }
+    return true;
+  }
+
+  /**
+   * \brief Narrowing the domains of the y views
+   *
+   * analogously to the x views we take
+   *    - for the upper bounds the matching \f$\phi\f$ computed in  glover
+   *      and compute the new upper bound by \f$T_j=min(E_j, D_{\phi(j)})\f$
+   *    - for the lower bounds the matching \f$\phi'\f$ computed in  revglover
+   *      and update the new lower bound by \f$T_j=max(E_j, D_{\phi'(j)})\f$
+   */
+
+  template<class View, class Tuple, bool Perm>
+  inline bool
+  narrow_domy(Space* home,
+              ViewArray<Tuple>& xz,
+              ViewArray<View>& y,
+              int phi[],
+              int phiprime[],
+              bool& nofix) {
+
+    int xs = xz.size();
+    for (int i = xs; i--; ) {
+      ModEvent me_lb = y[i].gq(home, xz[phiprime[i]][0].min());
+      if (me_failed(me_lb)) {
+        return false;
+      }
+      nofix |= (me_modified(me_lb) &&
+                xz[phiprime[i]][0].min() != y[i].min());
+
+      ModEvent me_ub = y[i].lq(home, xz[phi[i]][0].max());
+      if (me_failed(me_ub)) {
+        return false;
+      }
+      nofix |= (me_modified(me_ub) &&
+                xz[phi[i]][0].max() != y[i].max());
+    }
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/sorted/order.icc

@@ -0,0 +1,208 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
+ *
+ *  Copyright:
+ *     Patrick Pekczynski, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-11-08 15:53:26 +0100 (Thu, 08 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5219 $
+ *
+ *  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 Int { namespace Sorted {
+
+  /**
+   *  \brief Build \f$\sigma\f$
+   *
+   *  Creates a sorting permutation \f$\sigma\f$ by sorting the
+   *  views in \a x according to their lower bounds
+   */
+
+  template <class View, class Tuple, bool Perm>
+  inline void
+  sort_sigma(ViewArray<Tuple>& xz, bool) {
+    int xs = xz.size();
+
+    // test for equal bounds
+    if (Perm) {
+      TupleMinIncExt<Tuple> min_inc;
+      Support::quicksort<Tuple, TupleMinIncExt<Tuple> >(&xz[0], xs, min_inc);
+    } else {
+      TupleMinInc<Tuple> min_inc;
+      Support::quicksort<Tuple, TupleMinInc<Tuple> >(&xz[0], xs, min_inc);
+    }
+  }
+
+  /**
+   *  \brief Build \f$\tau\f$
+   *
+   *  Creates a sorting permutation \f$\tau\f$ by sorting
+   *  a given array of indices in \a tau according to the upper bounds
+   *  of the views in \a x
+   */
+
+  template <class View, class Tuple, bool Perm>
+  inline void
+  sort_tau(ViewArray<Tuple>& xz, int tau[]) {
+    int xs = xz.size();
+
+    if (Perm) {
+      TupleMaxIncExt<Tuple> ltmax(xz);
+      Support::quicksort(&(*tau), xs, ltmax);
+    } else {
+      TupleMaxInc<Tuple> ltmax(xz);
+      Support::quicksort(&(*tau), xs, ltmax);
+    }
+  }
+
+  /**
+   * \brief Performing normalization on the views in \a y
+   *
+   * The views in \a y are called normalized if
+   * \f$\forall i\in\{0,\dots, n-1\}: min(y_0) \leq \dots \leq min(y_{n-1}) \wedge
+   *  max(y_0) \leq \dots \leq max(y_{n-1})\f$ holds.
+   */
+  template <class View, class Tuple>
+  inline bool
+  normalize(Space* home,
+            ViewArray<View>& y,
+            ViewArray<Tuple>& xz,
+            bool& nofix) {
+
+    int ys = y.size();
+    for (int i = 1; i < ys; i++) {
+      ModEvent me_lb = y[i].gq(home, y[i - 1].min());
+      if (me_failed(me_lb))
+        return false;
+      nofix |= (me_modified(me_lb) && y[i - 1].min() != y[i].min());
+    }
+
+    for (int i = ys - 1; i--; ) {
+      ModEvent me_ub = y[i].lq(home, y[i + 1].max());
+      if (me_failed(me_ub))
+        return false;
+      nofix |= (me_modified(me_ub) && y[i + 1].max() != y[i].max());
+    }
+
+    int xs = xz.size();
+    for (int i = xs; i--; ) {
+      ModEvent me = xz[i][0].gq(home, y[0].min());
+      if (me_failed(me))
+        return false;
+      nofix |= (me_modified(me) && xz[i][0].min() != y[0].min());
+
+      me = xz[i][0].lq(home, y[xs - 1].max());
+      if (me_failed(me))
+        return false;
+      nofix |= (me_modified(me) && xz[i][0].max() != y[xs - 1].max());
+    }
+    return true;
+  }
+
+  /**
+   *  \brief Bounds consistency on the permutation views
+   *
+   *  Check, whether the permutation view are bounds consistent.
+   *  This function tests, whether there are "crossing edges", i.e.
+   *  whether the current domains permit matchings between unsorted views
+   *  \a x and the sorted variables \a y violating the property
+   *  that \a y is sorted.
+   */
+
+  template<class View, class Tuple, bool Perm>
+  inline bool
+  perm_bc(Space* home, int tau[],
+          SccComponent sinfo[],        
+          int scclist[],
+          ViewArray<Tuple>& xz,
+          bool& crossingedge,
+          bool& nofix) {
+
+    int ps = xz.size();
+
+    for (int i = 1; i < ps; i++) {
+      // if there are "crossed edges"
+      if (xz[i - 1][0].min() < xz[i][0].min()) {
+        if (xz[i - 1][1].min() > xz[i][1].min()) {
+          if (xz[i][1].min() != sinfo[scclist[i]].leftmost) {
+            // edge does not take part in solution
+            if (xz[i][1].assigned()) { // vital edge do not remove it
+              if (xz[i - 1][0].max() < xz[i][0].min()) {
+                // invalid permutation
+                // the upper bound sorting cannot fix this
+                return false;
+              }
+            } else {
+              crossingedge = true;
+              // and the permutation can still be changed
+              // fix the permutation, i.e. modify z
+              ModEvent me_z = xz[i][1].gq(home, xz[i - 1][1].min());
+              if (me_failed(me_z)) {
+                return false;
+              }
+              nofix |= ( me_modified(me_z) &&
+                         xz[i - 1][1].min() != xz[i][1].min());
+            }
+          }
+        }
+      }
+    }
+
+    // the same check as above for the upper bounds
+    for (int i = ps - 1; i--; ) {
+      if (xz[tau[i]][0].max() < xz[tau[i + 1]][0].max()) {
+        if (xz[tau[i]][1].max() > xz[tau[i + 1]][1].max()) {
+          if (xz[tau[i]][1].max() != sinfo[scclist[tau[i]]].rightmost) {
+            // edge does not take part in solution
+            if (xz[tau[i]][1].assigned()) {
+              if (xz[tau[i + 1]][0].min() > xz[tau[i]][0].max()) {
+                // invalid permutation
+                return false;
+              }
+            } else {
+              crossingedge = true;
+              ModEvent me_z = xz[tau[i]][1].lq(home, xz[tau[i + 1]][1].max());
+              if (me_failed(me_z)) {
+                return false;
+              }
+              nofix |= (me_modified(me_z) &&
+                        xz[tau[i + 1]][1].max() != xz[tau[i]][1].max());
+            }
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+