gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -1,596 +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-12-17 16:45:17 +0100 (Mon, 17 Dec 2007) $ by $Author: schulte $
- *     $Revision: 5732 $
- *
- *  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 Storage class for mininmum and maximum of a variable.
-   */
-  class Rank {
-  public:
-    /// stores the mininmum of a variable
-    int min;
-    /// stores the mininmum of a variable
-    int max;
-  };
-
-  /**
-   *  \brief Representation of a strongly connected component
-   *
-   *  Used with the implicit array representation of the
-   *  bipartite oriented intersection graph.
-   */
-  class SccComponent {
-  public:
-    /// Leftmost y-node in a scc
-    int leftmost;
-    /// Direct left neighbour of an y-node in a scc
-    int left;
-    /// Direct right neighbour of an y-node in a scc
-    int right;
-    /// Rightmost reachable y-node in a scc
-    int rightmost;
-  };
-
-  /**
-   * \brief Subsumption test
-   *
-   * The propagator for sorted is subsumed if all
-   * variables of the ViewArrays
-   * \a x, \a y and \a z are determined and the constraint holds.
-   * In addition to the subsumption test check_subsumption
-   * determines, whether we can reduce the orginial problem
-   * to a smaller one, by dropping already matched variables.
-   */
-
-  template<class View, class Tuple, bool Perm>
-  inline bool
-  check_subsumption(Space*,
-                    ViewArray<Tuple>& xz,
-                    ViewArray<View>& y,
-                    bool& subsumed,
-                    int& dropfst) {
-
-    dropfst  = 0;
-    subsumed = true;
-    int  xs  = xz.size();
-    for (int i = 0; i < xs ; i++) {
-      if (Perm) {
-        subsumed &= (xz[i][0].assigned() &&
-                     xz[i][1].assigned() &&
-                     y[xz[i][1].val()].assigned());
-        if (subsumed) {
-          if (xz[i][0].val() != y[xz[i][1].val()].val()) {
-            return false;
-          } else {
-            if (xz[i][1].val() == i) {
-              dropfst++;
-            }
-          }
-        }
-      } else {
-        subsumed &= (xz[i][0].assigned() && y[i].assigned());
-        if (subsumed) {
-          if (xz[i][0].val() != y[i].val()) {
-            return false;
-          } else {
-            dropfst++;
-          }
-        }
-      }
-    }
-    return true;
-  }
-
-  /**
-   *   \brief Item used to construct the OfflineMin sequence
-   *
-   */
-
-  class OfflineMinItem {
-  public:
-    /// Root node representing the set the vertex belongs to
-    int root;
-    /// Predecessor in the tree representation of the set
-    int parent;
-    /// Ranking of the set given by its cardinality
-    int rank;
-    /// Name or label of a set
-    int name;
-    /**
-     *  \brief Initial set label
-     *
-     *   This label represents the iteration index \f$i\f$
-     *   and hence the index of an insert instruction
-     *   in the complete Offline-Min sequence
-     */
-    int iset;
-    /// Successor in the Offline-Min sequence
-    int succ;
-    /// Predecessor in the Offline-Min sequence
-    int pred;
-  };
-
-  /**
-   *  \brief Offline-Min datastructure
-   *  Used to compute the perfect matching between the unsorted views
-   *  \a x and the sorted views \a y.
-   */
-  class OfflineMin {
-  private:
-    OfflineMinItem* sequence;
-    int* vertices;
-    int  n;
-  public:
-    OfflineMin(void);
-    OfflineMin(OfflineMinItem[], int[], int);
-    /**
-     *  Find the set x belongs to
-     *  (wihtout path compression)
-     */
-    int  find(int x);
-    /**
-     *  Find the set x belongs to
-     *  (using path compression)
-     */
-    int  find_pc(int x);
-    /// Unite two sets \a a and \a b and label the union with \a c
-    void unite(int a, int b, int c);
-    /// Initialization of the datastructure
-    void makeset(void);
-    /// Return the size of the Offline-Min item
-    int  size(void);
-    OfflineMinItem& operator[](int);
-  };
-
-  OfflineMin::OfflineMin(void){
-    n = 0;
-    sequence = NULL;
-    vertices = NULL;
-  }
-
-  OfflineMin::OfflineMin(OfflineMinItem s[], int v[], int size){
-    n = size;
-    sequence = &s[0];
-    vertices = &v[0];
-  }
-
-  forceinline int
-  OfflineMin::find(int x) {
-    while (sequence[x].parent != x) {
-      x = sequence[x].parent;
-    }
-    // x is now the root of the tree
-    // return the set, x belongs to
-    return sequence[x].name;
-  }
-
-  forceinline int
-  OfflineMin::find_pc(int x){
-    int vsize = 0;
-    while (sequence[x].parent != x) {
-      vertices[x] = x;
-      x = sequence[x].parent;
-    }
-    // x is now the root of the tree
-    for (int i = vsize; i--; ) {
-      sequence[vertices[i]].parent = x;
-    }
-    // return the set, x belongs to
-    return sequence[x].name;
-  }
-
-  forceinline void
-  OfflineMin::unite(int a, int b, int c){
-    // c is the union of a and b
-    int ra = sequence[a].root;
-    int rb = sequence[b].root;
-    int large = rb;
-    int small = ra;
-    if (sequence[ra].rank > sequence[rb].rank) {
-      large = ra;
-      small = rb;
-    }
-    sequence[small].parent =  large;
-    sequence[large].rank   += sequence[small].rank;
-    sequence[large].name   =  c;
-    sequence[c].root       =  large;
-  }
-
-  forceinline void
-  OfflineMin::makeset(void){
-    for(int i = n; i--; ){
-      OfflineMinItem& cur = sequence[i];
-      cur.rank   = 0;     // initially each set is empty
-      cur.name   = i;     // it has its own name
-      cur.root   = i;     // it is the root node
-      cur.parent = i;     // it is its own parent
-      cur.pred   = i - 1;
-      cur.succ   = i + 1;
-      cur.iset   = -5;
-    }
-  }
-
-  forceinline int
-  OfflineMin::size(void){
-    return n;
-  }
-
-  forceinline OfflineMinItem&
-  OfflineMin::operator [](int i){
-    return sequence[i];
-  }
-
-  /**
-   *  \brief Index comparison for %ViewArray&lt;Tuple&gt;
-   *
-   *  Checks whether for two indices \a i and \a j
-   *  the first component of the corresponding viewtuples
-   *  \f$x_i\f$ and \f$x_j\f$ the upper domain bound of \f$x_j\f$
-   *  is larger than the upper domain bound of \f$x_i\f$
-   *
-   */
-  template <class Tuple>
-  class TupleMaxInc {
-  protected:
-    ViewArray<Tuple> x;
-  public:
-    TupleMaxInc(const ViewArray<Tuple>& x0) : x(x0) {}
-    bool operator()(const int i, const int j) {
-      if (x[i][0].max() == x[j][0].max()) {
-        return x[i][0].min() < x[j][0].min();
-      } else {
-        return x[i][0].max() < x[j][0].max();
-      }
-    }
-  };
-
-
-  /**
-   *  \brief Extended Index comparison for %ViewArray&lt;Tuple&gt;
-   *
-   *  Checks whether for two indices \a i and \a j
-   *  the first component of the corresponding viewtuples
-   *  \f$x_i\f$ and \f$x_j\f$ the upper domain bound of \f$x_j\f$
-   *  is larger than the upper domain bound of \f$x_i\f$
-   *
-   */
-  template <class Tuple>
-  class TupleMaxIncExt {
-  protected:
-    ViewArray<Tuple> x;
-  public:
-    TupleMaxIncExt(const ViewArray<Tuple>& x0) : x(x0) {}
-    bool operator()(const int i, const int j) {
-      if (x[i][0].max() == x[j][0].max()) {
-        if (x[i][0].min() == x[j][0].min()) {
-          if (x[i][1].max() == x[j][1].max()) {
-            return x[i][1].min() < x[j][1].min();
-          } else {
-            return x[i][1].max() < x[j][1].max();
-          }
-        } else {
-          return x[i][0].min() < x[j][0].min();
-        }
-      } else {
-        return x[i][0].max() < x[j][0].max();
-      }
-    }
-  };
-
-  /**
-   * \brief View comparison on ViewTuples
-   *
-   * Checks whether the lower domain bound of the
-   * first component of \a x (the variable itself)
-   * is smaller than the lower domain bound of the
-   * first component of \a y
-   */
-
-  template <class View>
-  class TupleMinInc {
-  public:
-    bool operator()(const View& x, const View& y) {
-      if (x[0].min() == y[0].min()) {
-        return x[0].max() < y[0].max();
-      } else {
-        return x[0].min() < y[0].min();
-      }
-    }
-  };
-
-  /**
-   * \brief Extended View comparison on ViewTuples
-   *
-   * Checks whether the lower domain bound of the
-   * first component of \a x (the variable itself)
-   * is smaller than the lower domain bound of the
-   * first component of \a y. If they are equal
-   * it checks their upper bounds. If they are also
-   * equal we sort the views by the permutation variables.
-   */
-
-  template <class View>
-  class TupleMinIncExt {
-  public:
-    bool operator()(const View& x, const View& y) {
-      if (x[0].min() == y[0].min()) {
-        if (x[0].max() == y[0].max()) {
-          if (x[1].min() == y[1].min()) {
-            return x[1].max() < y[1].max();
-          } else {
-            return x[1].min() < y[1].min();
-          }
-        } else {
-          return x[0].max() < y[0].max();
-        }
-      } else {
-        return x[0].min() < y[0].min();
-      }
-    }
-  };
-
-  /**
-   * \brief View comparison on ViewTuples
-   *
-   * Checks whether the lower domain bound of the second component
-   * of \a x (the lower bound on the permutation variable) is smaller
-   * than the lower domain bound of the second component of \a y.
-   */
-
-  template <class View>
-  class TupleMinIncPerm {
-  public:
-    bool operator()(const View& x, const View& y) {
-      if (x[1].min() == y[1].min()) {
-        return x[1].max() < y[1].max();
-      } else {
-        return x[1].min() < y[1].min();
-      }
-    }
-  };
-
-  /**
-   * \brief View comparison on ViewTuples
-   *
-   * Checks whether the upper domain bound of the second component
-   * of \a x (the upper bound on the permutation variable) is smaller
-   * than the upper domain bound of the second component of \a y.
-   */
-
-  template <class View>
-  class TupleMaxIncPerm {
-  public:
-    bool operator()(const View& x, const View& y) {
-      if (x[1].max() == y[1].max()) {
-        return x[1].min() < y[1].min();
-      } else {
-        return x[1].max() < y[1].max();
-      }
-    }
-  };
-
-  /**
-   * \brief Check for assignment of a variable array
-   *
-   * Check whether one of the argument arrays is completely assigned
-   * and udpates the other array respectively.
-   */
-
-  template<class View, class Tuple, bool Perm>
-  inline bool
-  array_assigned(Space* home,
-                 ViewArray<Tuple>& xz,
-                 ViewArray<View>& y,
-                 bool& subsumed,
-                 bool& match_fixed,
-                 bool&,
-                 bool& noperm_bc) {
-
-    bool x_complete = true;
-    bool y_complete = true;
-    bool z_complete = true;
-
-    for (int i = y.size(); i--; ) {
-      x_complete &= xz[i][0].assigned();
-      y_complete &= y[i].assigned();
-      if (Perm) {
-        z_complete &= xz[i][1].assigned();
-      }
-    }
-
-    if (x_complete) {
-      for (int i = xz.size(); i--; ) {
-        ModEvent me = y[i].eq(home, xz[i][0].val());
-        if (me_failed(me)) {
-          return false;
-        }
-      }
-      if (Perm) {
-        subsumed = false;
-      } else {
-        subsumed = true;
-      }
-    }
-
-    if (y_complete) {
-      bool y_equality = true;
-      for (int i = y.size() - 1; i--; ) {
-        y_equality &= (y[i].val() == y[i + 1].val());
-      }
-      if (y_equality) {
-        for (int i = xz.size(); i--; ) {
-          ModEvent me = xz[i][0].eq(home, y[i].val());
-          if (me_failed(me)) {
-            return false;
-          }
-        }
-        if (Perm) {
-          subsumed = false;
-        } else {
-          subsumed = true;
-        }
-        noperm_bc = true;
-      }
-    }
-
-    if (Perm) {
-      if (z_complete) {
-        if (x_complete) {
-          for (int i = xz.size(); i--; ) {
-            ModEvent me = y[xz[i][1].val()].eq(home, xz[i][0].val());
-            if (me_failed(me)) {
-              return false;
-            }
-          }
-          subsumed = true;
-          return subsumed;
-        }
-        if (y_complete) {
-          for (int i = xz.size(); i--; ) {
-            ModEvent me = xz[i][0].eq(home, y[xz[i][1].val()].val());
-            if (me_failed(me)) {
-              return false;
-            }
-          }
-          subsumed = true;
-          return subsumed;
-        }
-
-        // validate the permutation
-        int sum = 0;
-        for (int i = xz.size(); i--; ) {
-          int pi = xz[i][1].val();
-          if (xz[i][0].max() < y[pi].min() ||
-              xz[i][0].min() > y[pi].max()) {
-            return false;
-          }
-          sum += pi;
-        }
-        int n = xz.size();
-        int gauss = ( (n * (n + 1)) / 2);
-        // if the sum over all assigned permutation variables is not
-        // equal to the gaussian sum - n they are not distinct, hence invalid
-        if (sum != gauss - n) {
-          return false;
-        }
-        match_fixed = true;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * \brief Channel between \a x, \a y and \a z
-   *
-   * Keep variables consisting by channeling information
-   *
-   */
-
-  template<class View, class Tuple, bool Perm>
-  forceinline bool
-  channel(Space* home, ViewArray<Tuple>& xz, ViewArray<View>& y, bool& nofix) {
-    int n = xz.size();
-    for (int i = n; i--; ) {
-      if (xz[i][1].assigned()) {
-        // if the permutation variable is determined
-        int v = xz[i][1].val();
-        if (xz[i][0].assigned()) {
-          // channel equality from x to y
-          ModEvent me = y[v].eq(home, xz[i][0].val());
-          if (me_failed(me))
-            return false;
-          nofix |= me_modified(me);
-        } else {
-          if (y[v].assigned()) {
-            // channel equality from y to x
-            ModEvent me = xz[i][0].eq(home, y[v].val());
-            if (me_failed(me))
-              return false;
-            nofix |= me_modified(me);
-          } else {
-            // constrain upper bound
-            ModEvent me = xz[i][0].lq(home, y[v].max());
-            if (me_failed(me))
-              return false;
-            nofix |= me_modified(me);
-
-            // constrain lower bound
-            me = xz[i][0].gq(home, y[v].min());
-            if (me_failed(me))
-              return false;
-            nofix |= me_modified(me);
-
-            // constrain the sorted variable
-            // constrain upper bound
-            me = y[v].lq(home, xz[i][0].max());
-            if (me_failed(me))
-              return false;
-            nofix |= me_modified(me);
-
-            // constrain lower bound
-            me = y[v].gq(home, xz[i][0].min());
-            if (me_failed(me))
-              return false;
-            nofix |= me_modified(me);
-          }
-        }
-      } else {
-        // if the permutation variable is undetermined
-        int l = xz[i][1].min();
-        int r = xz[i][1].max();
-        // upper bound
-        ModEvent me = xz[i][0].lq(home, y[r].max());
-        if (me_failed(me))
-          return false;
-        nofix |= me_modified(me);
-
-        // lower bound
-        me = xz[i][0].gq(home, y[l].min());
-        if (me_failed(me))
-          return false;
-        nofix |= me_modified(me);
-      }
-    }
-    return true;
-  }
-
-
-}}}
-
-
-// STATISTICS: int-prop