gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,208 @@
+/*
+ *  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 appending two range iterators
+   *
+   * The iterators are allowed to be adjacent but not to
+   * overlap (in this case, use Gecode::Iter::Union).
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I, class J>
+  class Append : public MinMax {
+  protected:
+    /// First iterator
+    I i;
+    /// Iterator to be appended
+    J j;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Append(void);
+    /// Initialize with iterator \a i and \a j
+    Append(I& i, J& j);
+    /// Initialize with iterator \a i and \a j
+    void init(I& i, J& j);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  /**
+   * \brief Range iterator for appending arbitrarily many iterators
+   *
+   * The iterators are allowed to be adjacent but not to
+   * overlap (in this case, use Gecode::Iter::NaryUnion)
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I>
+  class NaryAppend  :  public MinMax {
+  protected:
+    /// The array of iterators to be appended
+    I* r;
+    /// Number of iterators
+    unsigned int n;
+    /// Number of current iterator being processed
+    unsigned int active;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    NaryAppend(void);
+    /// Initialize with \a n iterators in \a i
+    NaryAppend(I* i, unsigned int n);
+    /// Initialize with \a n iterators in \a i
+    void init(I* i, unsigned int n);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  /*
+   * Binary Append
+   *
+   */
+
+  template <class I, class J>
+  inline void
+  Append<I,J>::operator++(void) {
+    if (i()) {
+      mi = i.min(); ma = i.max();
+      ++i;
+      if (!i() && j() && (j.min() == ma+1)) {
+	ma = j.max();
+	++j;
+      }
+    } else if (j()) {
+      mi = j.min();  ma = j.max();
+      ++j;
+    } else {
+      finish();
+    }
+  }
+
+
+  template <class I, class J>
+  forceinline
+  Append<I,J>::Append(void) {}
+
+  template <class I, class J>
+  forceinline
+  Append<I,J>::Append(I& i0, J& j0)
+    : i(i0), j(j0) {
+    if (i() || j())
+      operator++();
+    else
+      finish();
+  }
+
+  template <class I, class J>
+  forceinline void
+  Append<I,J>::init(I& i0, J& j0) {
+    i = i0; j = j0;
+    if (i() || j())
+      operator++();
+    else
+      finish();
+  }
+
+
+  /*
+   * Nary Append
+   *
+   */
+
+  template <class I>
+  inline void
+  NaryAppend<I>::operator++(void) {
+    mi = r[active].min();
+    ma = r[active].max();
+    ++r[active];
+    while (!r[active]()) {
+      //Skip empty iterators:
+      do {
+	active++;
+	if (active >= n) {
+	  finish(); return;
+	}
+      } while (!r[active]());
+      if (r[active].min() == ma+1){
+	ma = r[active].max();
+	++r[active];
+      } else {
+	return;
+      }
+    }
+  }
+
+  template <class I>
+  forceinline
+  NaryAppend<I>::NaryAppend(void) {}
+
+  template <class I>
+  inline
+  NaryAppend<I>::NaryAppend(I* r0, unsigned int n0)
+    : r(r0), n(n0), active(0) {
+    while (active < n && !r[active]())
+      active++;
+    if (active < n){
+      operator++();
+    } else {
+      finish();
+    }
+  }
+
+  template <class I>
+  inline void
+  NaryAppend<I>::init(I* r0, unsigned int n0) {
+    r = r0; n = n0; active = 0;
+    while (active < n && !r[active]())
+      active++;
+    if (active < n){
+      operator++();
+    } else {
+      finish();
+    }
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,123 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  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 array of ranges
+   *
+   * Allows to iterate the ranges as defined by an array.
+   * The ranges can be iterated several times provided the iterator
+   * is %reset by the reset member function.
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  class Array  {
+  public:
+    /// %Ranges for array
+    class Range {
+    public:
+      int min; int max;
+    };
+  protected:
+    /// Array for ranges
+    Range* r;
+    /// Current range
+    int c;
+    /// Number of ranges in array
+    int n;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Array(void);
+    /// Initialize with \a n ranges from \a r
+    Array(Range* r, int n);
+    /// Initialize with \a n ranges from \a r
+    void init(Range* r, int n);
+    //@}
+
+    /// \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);
+    /// Reset iterator to start from beginning
+    void reset(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;
+    //@}
+  };
+
+
+  forceinline
+  Array::Array(void) {}
+
+  forceinline
+  Array::Array(Range* r0, int n0)
+    : r(r0), c(0), n(n0) {}
+
+  forceinline void
+  Array::init(Range* r0, int n0) {
+    r=r0; c=0; n=n0;
+  }
+
+  forceinline void
+  Array::operator++(void) {
+    c++;
+  }
+  forceinline bool
+  Array::operator()(void) const {
+    return c < n;
+  }
+
+  forceinline void
+  Array::reset(void) {
+    c=0;
+  }
+
+  forceinline int
+  Array::min(void) const {
+    return r[c].min;
+  }
+  forceinline int
+  Array::max(void) const {
+    return r[c].max;
+  }
+  forceinline unsigned int
+  Array::width(void) const {
+    return r[c].max-r[c].min+1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,143 @@
+/*
+ *  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.
+ *
+ */
+
+#include "gecode/support/shared-array.hh"
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief %Range iterator cache
+   *
+   * Allows to iterate the ranges as defined by the input iterator
+   * several times provided the Cache is %reset by the reset member
+   * function.
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class Cache  {
+  protected:
+    /// %Ranges stored in cache
+    class Range {
+    public:
+      int min; int max;
+    };
+    /// Array for ranges
+    Support::SharedArray<Range> r;
+    /// Current range
+    int c;
+    /// Number of ranges in cache
+    int n;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Cache(void);
+    /// Initialize with ranges from \a i
+    Cache(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);
+    /// Reset iterator to start from beginning
+    void reset(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
+  Cache<I>::Cache(void)
+    : r(8) {}
+
+  template <class I>
+  inline void
+  Cache<I>::init(I& i) {
+    int j = 0;
+    while (i()) {
+      r.ensure(j);
+      r[j].min = i.min(); r[j].max = i.max();
+      ++j; ++i;
+    }
+    c = 0;
+    n = j;
+  }
+
+  template <class I>
+  inline
+  Cache<I>::Cache(I& i) : r(8) {
+    init(i);
+  }
+
+  template <class I>
+  forceinline void
+  Cache<I>::operator++(void) {
+    c++;
+  }
+  template <class I>
+  forceinline bool
+  Cache<I>::operator()(void) const {
+    return c < n;
+  }
+
+  template <class I>
+  forceinline void
+  Cache<I>::reset(void) {
+    c = 0;
+  }
+
+  template <class I>
+  forceinline int
+  Cache<I>::min(void) const {
+    return r[c].min;
+  }
+  template <class I>
+  forceinline int
+  Cache<I>::max(void) const {
+    return r[c].max;
+  }
+  template <class I>
+  forceinline unsigned int
+  Cache<I>::width(void) const {
+    return r[c].max-r[c].min+1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+