gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/gecode/int/sorted.cc

@@ -1,91 +0,0 @@
-/* -*- 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-09-11 21:43:38 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
- *     $Revision: 4982 $
- *
- *  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/int/sorted.hh"
-
-namespace Gecode {
-
-  void 
-  sorted(Space* home, const IntVarArgs& x, const IntVarArgs& y,
-         IntConLevel, PropKind) {
-    using namespace Int;
-    if (x.size() != y.size())
-      throw ArgumentSizeMismatch("Int::Sorted");
-    if (x.same(y))
-      throw ArgumentSame("Int::Sorted");
-      
-    if (home->failed()) return;
-
-    // construct single tuple for propagation without permutation variables
-    ViewArray<ViewTuple<IntView,1> > x0(home, x.size());
-    for (int i = x.size(); i--; )
-      x0[i][0] = x[i];
-    ViewArray<IntView> y0(home, y);
-
-    GECODE_ES_FAIL(home,
-                   (Sorted::
-                    Sorted<IntView, ViewTuple<IntView,1>, false>::
-                    post(home, x0, y0)));
-  }
-
-  void 
-  sorted(Space* home, const IntVarArgs& x, const IntVarArgs& y, 
-         const IntVarArgs& z, IntConLevel, PropKind) {
-    using namespace Int;
-    if ((x.size() != y.size()) || (x.size() != z.size()))
-      throw ArgumentSizeMismatch("Int::Sorted");
-    if (x.same(y) || x.same(z) || y.same(z))
-      throw ArgumentSame("Int::Sorted");
-    
-    if (home->failed()) return;
-
-    ViewArray<ViewTuple<IntView, 2> > xz0(home, x.size());
-
-    // assert that permutation variables encode a permutation
-    ViewArray<IntView> y0(home, y);
-    for (int i = x.size(); i--; ) {
-      xz0[i][0]=x[i]; xz0[i][1] = z[i];
-    }
-
-    GECODE_ES_FAIL(home,
-                   (Sorted::
-                    Sorted<IntView, ViewTuple<IntView,2>, true>::
-                    post(home, xz0, y0)));
-  }
-}
-
-// STATISTICS: int-post

data/ext/gecode-2.1.1/gecode/int/sorted.hh

@@ -1,117 +0,0 @@
-/* -*- 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: 2008-01-13 15:02:42 +0100 (Sun, 13 Jan 2008) $ by $Author: schulte $
- *     $Revision: 5862 $
- *
- *  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_INT_SORTED_HH__
-#define __GECODE_INT_SORTED_HH__
-
-#include "gecode/int.hh"
-
-/**
- * \namespace Gecode::Int::Sorted
- * \brief %Sorted propagators
- */
-
-namespace Gecode { namespace Int { namespace Sorted {
-
-  /**
-   * \brief Bounds-consistent sortedness propagator
-   *
-   * The algorithm is taken from: Sven Thiel, Efficient Algorithms 
-   * for Constraint Propagation and for Processing Tree Descriptions,
-   * PhD thesis, Universit�t des Saarlandes, Germany, 2004, pages 39-59.
-   *
-   * Requires \code #include "gecode/int/sorted.hh" \endcode
-   * \ingroup FuncIntProp
-   */
-
-  template<class View, class Tuple, bool Perm>
-  class Sorted : public Propagator {
-  protected:
-
-    /**
-     *  \brief Views to be sorted
-     *
-     *   If Tuple is instantiated to ViewTuple<View,2>,
-     *   \f$xz_i\f$ is a pair \f$(x_i, z_i)\f$, where
-     *   \f$x_i\f$ denotes an unsorted view
-     *   and \f$z_i\f$ is the explicit
-     *   permutation view mapping \f$x_i\f$ to its unsorted counterpart
-     *   \f$y_{z_i}\f$.
-     *   If Tuple is instantiated to ViewTuple<View,1>,
-     *   \f$xz_i\f$ is the unsorted view \f$x_i\f$ lifted to a ViewTuple.
-     */
-    ViewArray<Tuple> xz;
-
-    /// Views denoting the sorted version of \a x
-    ViewArray<View> y;
-    /// original y array
-    ViewArray<View> w;
-    /// connection to dropped view
-    int reachable;
-    /// Constructor for posting
-    Sorted(Space*, ViewArray<Tuple>&, ViewArray<View>&);
-    /// Constructor for cloning
-    Sorted(Space* home, bool share, Sorted<View, Tuple, Perm>& p);
-
-  public:
-    /// Delete propagator and return its size
-    virtual size_t dispose(Space* home);
-    /// Copy propagator during cloning
-    virtual Actor* copy(Space* home, bool share);
-    /// Cost function returning PC_LINEAR_HI
-    virtual PropCost cost(ModEventDelta med) const;
-    /// Perform propagation
-    virtual ExecStatus propagate(Space* home, ModEventDelta med);
-    /// Post propagator for the views \a xz and \a y
-    static  ExecStatus post(Space*, ViewArray<Tuple>&, ViewArray<View>&);
-  };
-
-
-}}}
-
-#include "gecode/int/sorted/sortsup.icc"
-#include "gecode/int/sorted/order.icc"
-#include "gecode/int/sorted/matching.icc"
-#include "gecode/int/sorted/narrowing.icc"
-#include "gecode/int/sorted/propagate.icc"
-
-#endif
-
-
-// STATISTICS: int-prop
-

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

@@ -1,182 +0,0 @@
-/* -*- 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

@@ -1,257 +0,0 @@
-/* -*- 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
-