gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -1,208 +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 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
-

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

@@ -1,669 +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.
- *
- */        
-
-#include "gecode/int/rel.hh"
-#include "gecode/int/distinct.hh"
-
-namespace Gecode { namespace Int { namespace Sorted {
-
-
-  /*
-   * Summary of the propagation algorithm as implemented in the
-   * propagate method below:
-   *
-   * STEP 1: Normalize the domains of the y variables
-   * STEP 2: Sort the domains of the x variables according to their lower
-   *         and upper endpoints
-   * STEP 3: Compute the matchings phi and phiprime with
-   *         Glover's matching algorithm
-   * STEP 4: Compute the strongly connected components in
-   *         the oriented intersection graph
-   * STEP 5: Narrow the domains of the variables
-   *
-   */
-
-  /**
-   * \brief Perform bounds consistent sortedness propagation
-   *
-   * Implements the propagation algorithm for Sorted::Sorted
-   * and is provided as seperate function, because a second pass of
-   * the propagation algorithm is needed in order to achieve idempotency
-   * in case explicit permutation variables are provided.
-   *
-   * If \a Perm is true, permutation variables form the
-   * third argument which implies additional inferences,
-   * consistency check on the permutation variables and eventually a
-   * second pass of the propagation algorithm.
-   * Otherwise, the algorithm does not take care of the permutation
-   * variables resulting in a better performance.
-   */
-
-  template<class View, class Tuple, bool Perm>
-  ExecStatus
-  bounds_propagation(Space* home,
-                     Propagator* p,
-                     ViewArray<Tuple>& xz,
-                     ViewArray<View>& y,
-                     bool& repairpass,
-                     bool& nofix,
-                     bool& match_fixed){
-
-    int n = xz.size();
-
-    GECODE_AUTOARRAY(int, tau,      n);
-    GECODE_AUTOARRAY(int, phi,      n);
-    GECODE_AUTOARRAY(int, phiprime, n);
-    GECODE_AUTOARRAY(OfflineMinItem, sequence, n);
-    GECODE_AUTOARRAY(int, vertices, n);
-
-    if (match_fixed) {
-      // sorting is determined
-      // sigma and tau coincide
-      for (int i = xz.size(); i--; )
-        tau[xz[i][1].val()] = i;
-    } else {
-      for (int i = n; i--; )
-        tau[i] = i;
-    }
-
-    if (Perm) {
-      // normalized and sorted
-      // collect all bounds
-
-      // minimum bound
-      int mib = y[0].min();
-      // maximum bound
-      int mab = y[n - 1].max();
-      // interval size
-      int ivs = (mab - mib + 1);
-      GECODE_AUTOARRAY(Rank, allbnd, ivs);
-      int iter = mib;
-      int idx = 0;
-      while(iter <= mab && idx < n) {
-        if (y[idx].min() > iter) {
-          // idx cannot be zero because consisteny in posting
-          assert(idx > 0);
-          allbnd[iter - mib].min = idx;
-          allbnd[iter - mib].max = idx - 1;
-          iter++;
-        } else {
-          if (y[idx].min() <= iter && iter <= y[idx].max() ) {
-            allbnd[iter - mib].min = idx;
-            allbnd[iter - mib].max = idx;
-            iter++;
-          } else {
-            idx++;
-          }
-        }
-      }
-
-      iter = mab;
-      idx = n -1;
-      while(iter >= mib && idx >= 0) {
-        if (y[idx].min() > iter) {
-          // idx cannot be zero because consisteny in posting
-          assert(idx > 0);
-          allbnd[iter - mib].max = idx - 1;
-          iter--;
-        } else {
-          if (y[idx].min() <= iter && iter <= y[idx].max() ) {
-            allbnd[iter - mib].max = idx;
-            iter--;
-          } else {
-            idx--;
-          }
-        }
-      }
-
-      for (int i = n; i--; ) {
-        // minimum reachable y-variable
-        int minr = allbnd[xz[i][0].min() - mib].min;
-        int maxr = allbnd[xz[i][0].max() - mib].max;
-
-        ModEvent me = xz[i][0].gq(home, y[minr].min());
-        if (me_failed(me))
-          return ES_FAILED;
-        nofix |= (me_modified(me) && (xz[i][0].min() != y[minr].min()));
-
-        me = xz[i][0].lq(home, y[maxr].max());
-        if (me_failed(me))
-          return ES_FAILED;
-        nofix |= (me_modified(me) && (xz[i][0].min() != y[maxr].max()));
-
-        me = xz[i][1].gq(home, minr);
-        if (me_failed(me))
-          return ES_FAILED;
-        nofix |= (me_modified(me) &&  (xz[i][1].min() != minr));
-
-        me = xz[i][1].lq(home, maxr);
-        if (me_failed(me))
-          return ES_FAILED;
-        nofix |= (me_modified(me) &&  (xz[i][1].max() != maxr));
-      }
-
-      // channel information from x to y through permutation variables in z
-      if (!channel<View, Tuple, Perm>(home, xz, y, nofix))
-        return ES_FAILED;
-      if (nofix)
-        return ES_NOFIX;
-    }
-
-    /*
-     * STEP 1:
-     *  normalization is implemented in "sortedness/order.icc"
-     *    o  setting the lower bounds of the y_i domains (\lb E_i)
-     *       to max(\lb E_{i-1},\lb E_i)
-     *    o  setting the upper bounds of the y_i domains (\ub E_i)
-     *       to min(\ub E_i,\ub E_{i+1})
-     */
-
-    if (!normalize<View, Tuple>(home, y, xz, nofix))
-      return ES_FAILED;
-
-    if (Perm) {
-      // check consistency of channeling after normalization
-      if (!channel<View, Tuple, Perm>(home, xz, y, nofix))
-        return ES_FAILED;
-      if (nofix)
-        return ES_NOFIX;
-    }
-
-
-    // if bounds have changed we have to recreate sigma to restore
-    // optimized dropping of variables
-
-    sort_sigma<View, Tuple, Perm>(xz, match_fixed);
-
-    bool subsumed   = true;
-    bool array_subs = false;
-    int  dropfst  = 0;
-    bool noperm_bc = false;
-
-    if (!(check_subsumption<View, Tuple, Perm>
-          (home, xz, y, subsumed, dropfst)) ||
-        !(array_assigned<View, Tuple, Perm>
-          (home, xz, y, array_subs, match_fixed, nofix, noperm_bc)))
-      return ES_FAILED;
-
-    if (subsumed || array_subs)
-      return ES_SUBSUMED(p,home);
-
-    /*
-     * STEP 2: creating tau
-     * Sort the domains of the x variables according
-     * to their lower bounds, where we use an
-     * intermediate array of integers for sorting
-     */
-    sort_tau<View, Tuple, Perm>(xz, tau);
-
-    /*
-     * STEP 3:
-     *  Compute the matchings \phi and \phi' between
-     *  the x and the y variables
-     *  with Glover's matching algorithm.
-     *        o  phi is computed with the glover function
-     *        o  phiprime is computed with the revglover function
-     *  glover and revglover are implemented in "sortedness/matching.icc"
-     */
-
-    if (!match_fixed) {
-      if (!glover<View, Tuple, Perm>
-          (home, xz, y, tau, phi, sequence, vertices)) {
-        return ES_FAILED;
-      }
-    } else {
-      for (int i = xz.size(); i--; ) {
-        phi[i]      = xz[i][1].val();
-        phiprime[i] = phi[i];
-      }
-    }
-
-    for (int i = n; i--; )
-      if (!y[i].assigned()) {
-        // phiprime is not needed to narrow the domains of the x-variables
-        if (!match_fixed && !(revglover<View,Tuple,Perm>
-                              (home,xz,y,tau,phiprime,sequence,vertices)))
-          return ES_FAILED;
-        
-        if (!narrow_domy<View,Tuple,Perm>(home,xz, y, phi, phiprime, nofix))
-          return ES_FAILED;
-        
-        if (nofix && !match_fixed) {
-          // data structures (matching) destroyed by domains with holes
-          
-          for (int i = y.size(); i--; )
-            phi[i]=phiprime[i]=0;
-
-          if (!glover<View, Tuple, Perm>
-              (home, xz, y, tau, phi, sequence, vertices))
-            return ES_FAILED;
-          
-          if (!revglover<View, Tuple, Perm>
-              (home, xz, y, tau, phiprime, sequence, vertices))
-            return ES_FAILED;
-          
-          if (!narrow_domy<View, Tuple, Perm>
-              (home, xz, y, phi, phiprime, nofix))
-            return ES_FAILED;
-        }
-        break;
-      }
-
-    /*
-     * STEP 4:
-     *  Compute the strongly connected components in
-     *  the oriented intersection graph
-     *  the computation of the sccs is implemented in
-     *  "sortedness/narrowing.icc" in the function narrow_domx
-     */
-
-    GECODE_AUTOARRAY(int,          scclist, n);
-    GECODE_AUTOARRAY(SccComponent, sinfo  , n);
-
-    for(int i = n; i--; )
-      sinfo[i].left=sinfo[i].right=sinfo[i].rightmost=sinfo[i].leftmost= i;
-
-    computesccs<View>(home, xz, y, phi, sinfo, scclist);
-
-    /*
-     * STEP 5:
-     *  Narrow the domains of the variables
-     *  Also implemented in "sortedness/narrowing.icc"
-     *  in the functions narrow_domx and narrow_domy
-     */
-
-    if (!narrow_domx<View, Tuple, Perm>
-        (home, xz, y, tau, phi, scclist, sinfo, nofix))
-      return ES_FAILED;
-
-    if (Perm) {
-      if (!noperm_bc && 
-          !perm_bc<View, Tuple, Perm>
-          (home, tau, sinfo, scclist, xz, repairpass, nofix))
-          return ES_FAILED;
-      
-      // channeling also needed after normal propagation steps
-      // in order to ensure consistency after possible modification in perm_bc
-      if (!channel<View, Tuple, Perm>(home, xz, y, nofix))
-        return ES_FAILED;
-      if (nofix)
-        return ES_NOFIX;
-    }
-
-    sort_tau<View, Tuple, Perm>(xz, tau);
-
-    if (Perm) {
-      // special case of sccs of size 2 denoted by permutation variables
-      // used to enforce consistency from x to y
-      // case of the upper bound ordering tau
-      for (int i = xz.size() - 1; i--; ) {
-        // two x variables are in the same scc of size 2
-        if (xz[tau[i]][1].min() == xz[tau[i+1]][1].min() &&
-            xz[tau[i]][1].max() == xz[tau[i+1]][1].max() &&
-            xz[tau[i]][1].size() == 2 && xz[tau[i]][1].range()) {
-          // if bounds are strictly smaller
-          if (xz[tau[i]][0].max() < xz[tau[i+1]][0].max()) {
-            ModEvent me = y[xz[tau[i]][1].min()].lq(home, xz[tau[i]][0].max());
-            if (me_failed(me)) 
-              return ES_FAILED;
-            nofix |= (me_modified(me) &&
-                      y[xz[tau[i]][1].min()].max() != xz[tau[i]][0].max());
-        
-            me = y[xz[tau[i+1]][1].max()].lq(home, xz[tau[i+1]][0].max());
-            if (me_failed(me))
-              return ES_FAILED;
-            nofix |= (me_modified(me) &&
-                      y[xz[tau[i+1]][1].max()].max() != xz[tau[i+1]][0].max());
-          }
-        }
-      }
-    }
-    return nofix ? ES_NOFIX : ES_FIX;
-  }
-
-  template<class View, class Tuple, bool Perm>
-  forceinline Sorted<View, Tuple, Perm>::
-  Sorted(Space* home, bool share, Sorted<View, Tuple, Perm>& p):
-    Propagator(home, share, p),
-    reachable(p.reachable) {
-    xz.update(home, share, p.xz);
-    y.update(home, share, p.y);
-    w.update(home, share, p.w);
-  }
-
-  template<class View, class Tuple, bool Perm>
-  Sorted<View, Tuple, Perm>::
-  Sorted(Space* home, ViewArray<Tuple>& xz0, ViewArray<View>& y0):
-    Propagator(home), xz(xz0), y(y0), w(home, y0), reachable(-1) {
-    xz.subscribe(home, this, PC_INT_BND);
-    y.subscribe(home, this, PC_INT_BND);
-
-  }
-
-  template<class View, class Tuple, bool Perm>
-  size_t
-  Sorted<View, Tuple, Perm>::dispose(Space* home) {
-    assert(!home->failed());
-    xz.cancel(home,this, PC_INT_BND);
-    y.cancel(home,this, PC_INT_BND);
-    (void) Propagator::dispose(home);
-    return sizeof(*this);
-  }
-
-  template<class View, class Tuple, bool Perm>
-  Actor* Sorted<View, Tuple, Perm>::copy(Space* home, bool share) {
-    return new (home) Sorted<View, Tuple, Perm>(home, share, *this);
-  }
-
-  template<class View, class Tuple, bool Perm>
-  PropCost Sorted<View, Tuple, Perm>::cost(ModEventDelta) const {
-    return cost_hi(xz.size(), PC_LINEAR_HI);
-  }
-
-  template<class View, class Tuple, bool Perm>
-  ExecStatus
-  Sorted<View, Tuple, Perm>::propagate(Space* home, ModEventDelta) {
-    int  n           = xz.size();
-    bool secondpass  = false;
-    bool nofix       = false;
-    int  dropfst     = 0;
-
-    bool subsumed    = false;
-    bool array_subs  = false;
-    bool match_fixed = false;
-
-    // normalization of x and y
-    if (!normalize<View, Tuple>(home, y, xz, nofix))
-      return ES_FAILED;
-
-    // create sigma sorting
-    sort_sigma<View, Tuple, Perm>(xz, match_fixed);
-
-    bool noperm_bc = false;
-    if (!array_assigned<View, Tuple, Perm>
-        (home, xz, y, array_subs, match_fixed, nofix, noperm_bc))
-      return ES_FAILED;
-
-    if (array_subs)
-      return ES_SUBSUMED(this,home);
-
-    sort_sigma<View, Tuple, Perm>(xz, match_fixed);
-
-    // in this case check_subsumptions is guaranteed to find
-    // the xs ordered by sigma
-
-    if (!check_subsumption<View, Tuple, Perm>
-        (home, xz, y, subsumed, dropfst))
-      return ES_FAILED;
-
-    if (subsumed)
-      return ES_SUBSUMED(this,home);
-
-    if (Perm) {
-      // dropping possibly yields inconsistent indices on permutation variables
-      if (dropfst) {
-        reachable = w[dropfst - 1].max();
-        bool unreachable = true;
-        for (int i = xz.size(); unreachable && i-- ; ) {
-          unreachable &= (reachable < xz[i][0].min());
-        }
-
-        if (unreachable) {
-          xz.drop_fst(dropfst, home, this, PC_INT_BND);
-          y.drop_fst (dropfst, home, this, PC_INT_BND);
-        } else {
-          dropfst = 0;
-        }
-      }
-
-      n = xz.size();
-
-      if (n < 2) {
-        if (xz[0][0].max() < y[0].min() || y[0].max() < xz[0][0].min())
-          return ES_FAILED;
-        if (Perm) {
-          GECODE_ME_CHECK(xz[0][1].eq(home, w.size() - 1));
-        }
-        GECODE_REWRITE(this,(Rel::EqBnd<View,View>::post(home, xz[0][0], y[0])));
-      }
-
-      // check whether shifting the permutation variables
-      // is necessary after dropping x and y vars
-      // highest reachable index
-      int  valid = n - 1;
-      int  index = 0;
-      int  shift = 0;
-
-      for (int i = n; i--; ){
-        if (xz[i][1].max() > index)
-          index = xz[i][1].max();
-        if (index > valid)
-          shift = index - valid;
-      }
-
-      if (shift) {
-        ViewArray<ViewTuple<OffsetView,2> > oxz(home, n);
-        ViewArray<OffsetView> oy(home, n);
-
-        for (int i = n; i--; ) {
-          GECODE_ME_CHECK(xz[i][1].gq(home, shift));
-
-          oxz[i][1] = OffsetView(xz[i][1], -shift);
-          oxz[i][0] = OffsetView(xz[i][0], 0);
-          oy[i] = OffsetView(y[i], 0);
-        }
-
-        GECODE_ES_CHECK((bounds_propagation<OffsetView,
-                         ViewTuple<OffsetView,2>, Perm>
-                         (home, this,oxz, oy, secondpass, nofix, match_fixed)));
-
-        if (secondpass) {
-          GECODE_ES_CHECK((bounds_propagation<OffsetView,
-                           ViewTuple<OffsetView,2>, Perm>
-                           (home,this,oxz, oy, secondpass, nofix, match_fixed)));
-        }
-      } else {
-        GECODE_ES_CHECK((bounds_propagation<View, Tuple, Perm>
-                         (home,this,xz, y, secondpass, nofix, match_fixed)));
-
-        if (secondpass) {
-          GECODE_ES_CHECK((bounds_propagation<View, Tuple, Perm>
-                           (home,this,xz, y, secondpass, nofix, match_fixed)));
-        }
-      }
-    } else {
-      // dropping has no consequences
-      if (dropfst) {
-        xz.drop_fst(dropfst, home, this, PC_INT_BND);
-        y.drop_fst (dropfst, home, this, PC_INT_BND);
-      }
-
-      n = xz.size();
-
-      if (n < 2) {
-        if (xz[0][0].max() < y[0].min() || y[0].max() < xz[0][0].min())
-          return ES_FAILED;
-        GECODE_REWRITE(this,(Rel::EqBnd<View,View>::post(home, xz[0][0], y[0])));
-      }
-
-      GECODE_ES_CHECK((bounds_propagation<View, Tuple, Perm>
-                       (home, this, xz, y, secondpass, nofix, match_fixed)));
-      // no second pass possible if there are no permvars
-    }
-
-    if (!normalize<View, Tuple>(home, y, xz, nofix))
-      return ES_FAILED;
-
-    GECODE_AUTOARRAY(int, tau, n);
-    if (match_fixed) {
-      // sorting is determined
-      // sigma and tau coincide
-      for (int i = xz.size(); i--; ) {
-        int pi = xz[i][1].val();
-        tau[pi] = i;
-      }
-    } else {
-      for (int i = n; i--; ) {
-        tau[i] = i;
-      }
-    }
-
-    sort_tau<View, Tuple, Perm>(xz, tau);
-    // recreate consistency for already assigned subparts
-    // in order of the upper bounds starting at the end of the array
-    bool xbassigned = true;
-    for (int i = xz.size(); i--; ) {
-      if (xz[tau[i]][0].assigned() && xbassigned) {
-        GECODE_ME_CHECK(y[i].eq(home, xz[tau[i]][0].val()));
-      } else {
-        xbassigned = false;
-      }
-    }
-
-    subsumed   = true;
-    array_subs = false;
-    noperm_bc  = false;
-
-    // creating sorting anew
-    sort_sigma<View, Tuple, Perm>(xz, match_fixed);
-
-    if (Perm) {
-      for (int i = 0; i < xz.size() - 1; i++) {
-        // special case of subsccs of size2 for the lower bounds
-        // two x variables are in the same scc of size 2
-        if (xz[i][1].min() == xz[i+1][1].min() &&
-            xz[i][1].max() == xz[i+1][1].max() &&
-            xz[i][1].size() == 2 && xz[i][1].range()) {
-          if (xz[i][0].min() < xz[i+1][0].min()) {
-            ModEvent me = y[xz[i][1].min()].gq(home, xz[i][0].min());
-            GECODE_ME_CHECK(me);
-            nofix |= (me_modified(me) &&
-                      y[xz[i][1].min()].min() != xz[i][0].min());
-
-            me = y[xz[i+1][1].max()].gq(home, xz[i+1][0].min());
-            GECODE_ME_CHECK(me);
-            nofix |= (me_modified(me) &&
-                      y[xz[i+1][1].max()].min() != xz[i+1][0].min());
-          }
-        }
-      }
-    }
-
-    // check assigned
-    // should be sorted
-    bool xassigned = true;
-    for (int i = 0; i < xz.size(); i++) {
-      if (xz[i][0].assigned() && xassigned) {
-        GECODE_ME_CHECK(y[i].eq(home, xz[i][0].val()));
-      } else {
-        xassigned = false;
-      }
-    }
-
-    // sorted check bounds
-    // final check that variables are consitent with least and greatest possible
-    // values
-    int tlb = std::min(xz[0][0].min(), y[0].min());
-    int tub = std::max(xz[xz.size() - 1][0].max(), y[y.size() - 1].max());
-    for (int i = xz.size(); i--; ) {
-      ModEvent me = y[i].lq(home, tub);
-      GECODE_ME_CHECK(me);
-      nofix |= me_modified(me) && (y[i].max() != tub);
-
-      me = y[i].gq(home, tlb);
-      GECODE_ME_CHECK(me);
-      nofix |= me_modified(me) && (y[i].min() != tlb);
-
-      me = xz[i][0].lq(home, tub);
-      GECODE_ME_CHECK(me);
-      nofix |= me_modified(me) && (xz[i][0].max() != tub);
-
-      me = xz[i][0].gq(home, tlb);
-      GECODE_ME_CHECK(me);
-      nofix |= me_modified(me) && (xz[i][0].min() != tlb);
-    }
-
-    if (!array_assigned<View, Tuple, Perm>
-        (home, xz, y, array_subs, match_fixed, nofix, noperm_bc))
-      return ES_FAILED;
-
-    if (array_subs)
-      return ES_SUBSUMED(this,home);
-
-    if (!check_subsumption<View, Tuple, Perm>
-        (home, xz, y, subsumed, dropfst))
-      return ES_FAILED;
-
-    if (subsumed)
-      return ES_SUBSUMED(this,home);
-
-    return nofix ? ES_NOFIX : ES_FIX;
-  }
-
-  template<class View, class Tuple, bool Perm>
-  ExecStatus
-  Sorted<View, Tuple, Perm>::
-  post(Space* home, ViewArray<Tuple>& xz0, ViewArray<View>& y0) {
-    int n = xz0.size();
-    if (n < 2) {
-      if ((xz0[0][0].max() < y0[0].min()) || (y0[0].max() < xz0[0][0].min()))
-        return ES_FAILED;
-      Rel::EqBnd<View,View>::post(home, xz0[0][0], y0[0]);
-      if (Perm) {
-        GECODE_ME_CHECK(xz0[0][1].eq(home, 0));
-      }
-    } else {
-      if (Perm) {
-        ViewArray<View> z(home,n);
-        for (int i=n; i--; ) {
-          z[i]=xz0[i][1];
-          GECODE_ME_CHECK(z[i].gq(home,0));
-          GECODE_ME_CHECK(z[i].lq(home,n-1));
-        }
-        GECODE_ES_CHECK(Distinct::Bnd<View>::post(home,z));
-      }
-      new (home) Sorted<View, Tuple, Perm>(home, xz0, y0);
-    }
-    return ES_OK;
-  }
-
-}}}
-
-// STATISTICS: int-prop
-
-
-