gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/iter/ranges-minmax.icc

@@ -0,0 +1,103 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:50 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3515 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Base for range iterators with explicit min and max
+   *
+   * The iterator provides members \a mi and \a ma for storing the
+   * limits of the currently iterated range. The iterator
+   * continues until \a mi becomes greater than \a ma. The member function
+   * finish does exactly that.
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  class MinMax {
+  protected:
+    /// Minimum of current range
+    int mi;
+    /// Maximum of current range
+    int ma;
+    /// %Set range such that iteration stops
+    void finish(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    MinMax(void);
+    /// Initialize with range \a min to \a max
+    MinMax(int min, int max);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  forceinline void
+  MinMax::finish(void) {
+    mi = 1; ma = 0;
+  }
+
+  forceinline
+  MinMax::MinMax(void) {}
+
+  forceinline
+  MinMax::MinMax(int min, int max)
+    : mi(min), ma(max) {}
+
+  forceinline bool
+  MinMax::operator()(void) const {
+    return mi <= ma;
+  }
+
+  forceinline int
+  MinMax::min(void) const {
+    return mi;
+  }
+  forceinline int
+  MinMax::max(void) const {
+    return ma;
+  }
+  forceinline unsigned int
+  MinMax::width(void) const {
+    return ma-mi+1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

data/ext/gecode-1.3.1/gecode/iter/ranges-minus.icc

@@ -0,0 +1,138 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:50 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3515 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/support/shared-array.hh"
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for pointwise minus of a range iterator
+   *
+   * This iterator in effect changes the order of how ranges
+   * are iterated: the first range of the input iterator defines
+   * the last range of the Minus iterator. Upon initialization
+   * all ranges of the input iterator are stored in an array
+   * which later allows iteration in inverse direction.
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I>
+  class Minus  {
+  private:
+    /// %Range for storage in array
+    class Range {
+    public:
+      int min; int max;
+    };
+    /// %Ranges stored
+    Support::SharedArray<Range> r;
+    /// Current range
+    int c;
+    /// Number of ranges
+    int n;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Minus(void);
+    /// Initialize with ranges from \a i
+    Minus(I& i);
+    /// Initialize with ranges from \a i
+    void init(I& i);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+
+  template <class I>
+  forceinline
+  Minus<I>::Minus(void)
+    : r(8) {}
+
+  template <class I>
+  inline void
+  Minus<I>::init(I& i) {
+    int j = 0;
+    while (i()) {
+      r.ensure(j);
+      r[j].min = -i.max(); r[j].max = -i.min();
+      ++j; ++i;
+    }
+    n = j;
+    c = n-1;
+  }
+
+  template <class I>
+  inline
+  Minus<I>::Minus(I& i) : r(8) {
+    init(i);
+  }
+
+  template <class I>
+  forceinline void
+  Minus<I>::operator++(void) {
+    c--;
+  }
+  template <class I>
+  forceinline bool
+  Minus<I>::operator()(void) const {
+    return c >= 0;
+  }
+
+  template <class I>
+  forceinline int
+  Minus<I>::min(void) const {
+    return r[c].min;
+  }
+  template <class I>
+  forceinline int
+  Minus<I>::max(void) const {
+    return r[c].max;
+  }
+  template <class I>
+  forceinline unsigned int
+  Minus<I>::width(void) const {
+    return r[c].max-r[c].min+1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

data/ext/gecode-1.3.1/gecode/iter/ranges-offset.icc

@@ -0,0 +1,112 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:50 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3515 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for pointwise offset (by some constant)
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class Offset {
+  protected:
+    /// Input range
+    I i;
+    /// Offset for ranges
+    int c;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Offset(void);
+    /// Initialize with ranges from \a i and offset \a c
+    Offset(I& i, int c);
+    /// Initialize with ranges from \a i and offset \a c
+    void init(I& i, int c);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Range access
+    //@{
+    /// Return smallest value of range
+    int min(void) const;
+    /// Return largest value of range
+    int max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+
+  template <class I>
+  forceinline
+  Offset<I>::Offset(void) {}
+
+  template <class I>
+  inline void
+  Offset<I>::init(I& i0, int c0) {
+    i = i0; c = c0;
+  }
+
+  template <class I>
+  inline
+  Offset<I>::Offset(I& i0, int c0) : i(i0), c(c0) {}
+
+  template <class I>
+  forceinline void
+  Offset<I>::operator++(void) {
+    ++i;
+  }
+  template <class I>
+  forceinline bool
+  Offset<I>::operator()(void) const {
+    return i();
+  }
+
+  template <class I>
+  forceinline int
+  Offset<I>::min(void) const {
+    return i.min()+c;
+  }
+  template <class I>
+  forceinline int
+  Offset<I>::max(void) const {
+    return i.max()+c;
+  }
+  template <class I>
+  forceinline unsigned int
+  Offset<I>::width(void) const {
+    return i.width();
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

data/ext/gecode-1.3.1/gecode/iter/ranges-operations.icc

@@ -0,0 +1,142 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \defgroup FuncIterRangesOp Operations on range iterators
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  //@{
+  /// Size of all ranges of range iterator \a i
+  template <class I>
+  unsigned int size(I& i);
+
+  /// Check whether range iterators \a i and \a j are equal
+  template <class I, class J>
+  bool equal(I& i, J& j);
+
+  /// Check whether range iterator \a i is subset of range iterator \a j
+  template <class I, class J>
+  bool subset(I& i, J& j);
+
+  /// Check whether range iterators \a i and \a j are disjoint
+  template <class I, class J>
+  bool disjoint(I& i, J& j);
+
+  /// Is one iterator subsumed by another, or is the intersection empty?
+  enum SubsumtionStatus {
+    SS_SUBSUMED, ///< Subsumed (subset)
+    SS_EMPTY,    ///< Intersection is empty
+    SS_NONE      ///< Neither of the above
+  };
+
+  /// Check whether range iterator \a i subsumes \a j, or whether intersection is empty
+  template <class I, class J>
+  SubsumtionStatus subsumes(I& i, J& j);
+  //@}
+
+
+  template <class I>
+  inline unsigned int
+  size(I& i) {
+    unsigned int s = 0;
+    while (i()) {
+      s += i.width(); ++i;
+    }
+    return s;
+  }
+
+  template <class I, class J>
+  forceinline bool
+  equal(I& i, J& j) {
+    // Are i and j equal?
+    while (i() && j())
+      if ((i.min() == j.min()) && (i.max() == j.max())) {
+	++i; ++j;
+      } else {
+	return false;
+      }
+    return !i() && !j();
+  }
+
+  template <class I, class J>
+  forceinline bool
+  subset(I& i, J& j) {
+    // Is i subset of j?
+    while (i() && j())
+      if (j.max() < i.min()) {
+	++j;
+      } else if ((i.min() >= j.min()) && (i.max() <= j.max())) {
+	++i;
+      } else {
+	return false;
+      }
+    return !i();
+  }
+
+  template <class I, class J>
+  forceinline bool
+  disjoint(I& i, J& j) {
+    // Are i and j disjoint?
+    while (i() && j())
+      if (j.max() < i.min()) {
+	++j;
+      } else if (i.max() < j.min()) {
+	++i;
+      } else {
+	return false;
+      }
+    return true;
+  }
+
+  template <class I, class J>
+  inline SubsumtionStatus
+  subsumes(I& i, J& j) {
+    bool subsumed = true;
+    bool empty    = true;
+    while (i() && j()) {
+      if (i.max() < j.min()) {
+	++i;
+      } else if (j.max() < i.min()) {
+	++j; subsumed = false;
+      } else if ((j.min() >= i.min()) && (j.max() <= i.max())) {
+	++j; empty = false;
+      } else if (j.max() <= i.max()) {
+	++j; empty = false; subsumed = false;
+      } else if (i.max() <= j.max()) {
+	++i; empty = false; subsumed = false;
+      }
+    }
+    if (j())
+      subsumed = false;
+    if (subsumed)
+      return SS_SUBSUMED;
+    return empty ? SS_EMPTY : SS_NONE;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+