gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,224 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  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 <cmath>
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for pointwise product with a positive integer
+   *
+   * Note that this iterator has a different interface as it can be used
+   * for both integer precision as well as souble precision (depending
+   * on the type \a Val (\c int or \c double) and
+   * on the type \a UnsVal (\c unsigned \c int or \c double).
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class Val, class UnsVal, class I>
+  class ScaleUp {
+  protected:
+    /// Iterator to be scaled
+    I i;
+    /// Scale-factor
+    int a;
+    /// Current value of range
+    Val cur;
+    /// Last value of scaled range of \a i
+    Val end;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ScaleUp(void);
+    /// Initialize with ranges from \a i and scale factor \a a
+    ScaleUp(I& i, int a);
+    /// Initialize with ranges from \a i and scale factor \a a
+    void init(I& i, int a);
+    //@}
+
+    /// \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
+    Val min(void) const;
+    /// Return largest value of range
+    Val max(void) const;
+    /// Return width of range (distance between minimum and maximum)
+    UnsVal width(void) const;
+    //@}
+  };
+
+  /**
+   * \brief Range iterator for pointwise division by a positive integer
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class ScaleDown : public MinMax {
+  protected:
+    /// Iterator to be scaled down
+    I i;
+    /// Divide by this factor
+    int a;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ScaleDown(void);
+    /// Initialize with ranges from \a i and scale factor \a a
+    ScaleDown(I& i, int a);
+    /// Initialize with ranges from \a i and scale factor \a a
+    void init(I& i, int a);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+
+  template <class Val, class UnsVal, class I>
+  forceinline
+  ScaleUp<Val,UnsVal,I>::ScaleUp(void) {}
+
+  template <class Val, class UnsVal, class I>
+  inline void
+  ScaleUp<Val,UnsVal,I>::init(I& i0, int a0) {
+    i = i0; a = a0;
+    if (i()) {
+      cur = a * i.min();
+      end = a * i.max();
+    } else {
+      cur = 1;
+      end = 0;
+    }
+  }
+
+  template <class Val, class UnsVal, class I>
+  inline
+  ScaleUp<Val,UnsVal,I>::ScaleUp(I& i0, int a0) : i(i0), a(a0) {
+    if (i()) {
+      cur = a * i.min();
+      end = a * i.max();
+    } else {
+      cur = 1;
+      end = 0;
+    }
+  }
+
+  template <class Val, class UnsVal, class I>
+  forceinline void
+  ScaleUp<Val,UnsVal,I>::operator++(void) {
+    if (a == 1) {
+      ++i;
+    } else {
+      cur += a;
+      if (cur > end) {
+	++i;
+	if (i()) {
+	  cur = a * i.min();
+	  end = a * i.max();
+	}
+      }
+    }
+  }
+  template <class Val, class UnsVal, class I>
+  forceinline bool
+  ScaleUp<Val,UnsVal,I>::operator()(void) const {
+    return (a == 1) ? i() : (cur <= end);
+  }
+
+  template <class Val, class UnsVal, class I>
+  forceinline Val
+  ScaleUp<Val,UnsVal,I>::min(void) const {
+    return (a == 1) ? static_cast<Val>(i.min()) : cur;
+  }
+  template <class Val, class UnsVal, class I>
+  forceinline Val
+  ScaleUp<Val,UnsVal,I>::max(void) const {
+    return (a == 1) ? static_cast<Val>(i.max()) : cur;
+  }
+  template <class Val, class UnsVal, class I>
+  forceinline UnsVal
+  ScaleUp<Val,UnsVal,I>::width(void) const {
+    return (a == 1) ?
+      static_cast<UnsVal>(i.width()) :
+      static_cast<UnsVal>(max - min + 1);
+  }
+
+
+
+  template <class I>
+  forceinline void
+  ScaleDown<I>::operator++(void) {
+    finish();
+    while ((mi > ma) && i()) {
+      mi = static_cast<int>(ceil(static_cast<double>(i.min())/a));
+      ma = static_cast<int>(floor(static_cast<double>(i.max())/a));
+      ++i;
+    }
+    while (i()) {
+      int n_mi = static_cast<int>(ceil(static_cast<double>(i.min())/a));
+      if (n_mi-ma > 1)
+	break;
+      int n_ma = static_cast<int>(floor(static_cast<double>(i.max())/a));
+      if (n_mi <= n_ma) {
+	ma = n_ma;
+      }
+      ++i;
+    }
+  }
+
+  template <class I>
+  forceinline
+  ScaleDown<I>::ScaleDown(void) {}
+
+  template <class I>
+  inline void
+  ScaleDown<I>::init(I& i0, int a0) {
+    i = i0; a = a0;
+    operator++();
+  }
+
+  template <class I>
+  inline
+  ScaleDown<I>::ScaleDown(I& i0, int a0) : i(i0), a(a0) {
+    i = i0; a = a0;
+    operator++();
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,71 @@
+/*
+ *  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 {
+
+  /**
+   * \brief Range iterator for singleton range
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  class Singleton : public MinMax {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Singleton(void);
+    /// Initialize with range \a min to \a max
+    Singleton(int min, int max);
+    /// Initialize with range \a min to \a max
+    void init(int min, int max);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  forceinline
+  Singleton::Singleton(void) {}
+
+  forceinline
+  Singleton::Singleton(int min, int max)
+    : MinMax(min,max) {}
+
+  forceinline void
+  Singleton::init(int min, int max) {
+    mi = min; ma = max;
+  }
+
+  forceinline void
+  Singleton::operator++(void) {
+    mi=1; ma=0;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,131 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-07-12 15:53:12 +0200 (Wed, 12 Jul 2006) $ by $Author: tack $
+ *     $Revision: 3349 $
+ *
+ *  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 with size counting
+   *
+   * Allows to iterate the ranges as defined by the input iterator
+   * and access the size of the set already iterated. After complete
+   * iteration, the reported size is thus the size of the set.
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class Size  {
+  protected:
+    /// Iterator to compute size of
+    I i;
+    /// Accumulated size
+    unsigned int _size;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Size(void);
+    /// Initialize with ranges from \a i
+    Size(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);
+    /// 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;
+    //@}
+
+    /// \name %Size access
+    //@{
+    /// Return accumulated size
+    unsigned int size(void) const;
+    //@}
+  };
+
+
+  template <class I>
+  forceinline
+  Size<I>::Size(void)
+    : _size(0) {}
+
+  template <class I>
+  inline void
+  Size<I>::init(I& i0) {
+    i.init(i0);
+    _size = 0;
+  }
+
+  template <class I>
+  inline
+  Size<I>::Size(I& i0) : i(i0), _size(0) {}
+
+  template <class I>
+  forceinline void
+  Size<I>::operator++(void) {
+    _size += i.width();
+    ++i;
+  }
+  template <class I>
+  forceinline bool
+  Size<I>::operator()(void) {
+    return i();
+  }
+
+  template <class I>
+  forceinline int
+  Size<I>::min(void) const {
+    return i.min();
+  }
+  template <class I>
+  forceinline int
+  Size<I>::max(void) const {
+    return i.max();
+  }
+  template <class I>
+  forceinline unsigned int
+  Size<I>::width(void) const {
+    return i.width();
+  }
+
+  template <class I>
+  forceinline unsigned int
+  Size<I>::size(void) const {
+    return _size;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,211 @@
+/*
+ *  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/static-pqueue.hh"
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for computing union (binary)
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I, class J>
+  class Union : public MinMax {
+    /// First iterator
+    I i;
+    /// Second iterator
+    J j;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Union(void);
+    /// Initialize with iterator \a i and \a j
+    Union(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 union for any number of iterators
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I>
+  class NaryUnion : public MinMax {
+  protected:
+    /// Order for iterators: by increasing minimum of next range
+    class RangeUnionOrder {
+    public:
+      bool operator()(const I&, const I&) const;
+    };
+    /// Instance for order
+    RangeUnionOrder order;
+    /// Priority queue to give access to next range
+    Support::PQueue<I,RangeUnionOrder> r;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    NaryUnion(void);
+    /// Initialize with \a n iterators in \a i
+    NaryUnion(I* i, int n);
+    /// Initialize with \a n iterators in \a i
+    void init(I* i, int n);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+
+  /*
+   * Binary union
+   *
+   */
+
+  template <class I, class J>
+  inline void
+  Union<I,J>::operator++(void) {
+    if (!i() && !j()) {
+      finish(); return;
+    }
+    if (!i()) {
+      mi = j.min(); ma = j.max(); ++j; return;
+    }
+    if (!j()) {
+      mi = i.min(); ma = i.max(); ++i; return;
+    }
+    if (i.min() < j.min()) {
+      mi = i.min(); ma = i.max(); ++i;
+    } else {
+      mi = j.min(); ma = j.max(); ++j;
+    }
+    bool goOn;
+    do {
+      goOn = false;
+      if (i() && (i.min() <= ma+1)) {
+	ma = std::max(ma,i.max()); ++i; goOn=true;
+      }
+      if (j() && (j.min() <= ma+1)) {
+	ma = std::max(ma,j.max()); ++j; goOn=true;
+      }
+    } while (goOn);
+  }
+
+
+  template <class I, class J>
+  forceinline
+  Union<I,J>::Union(void) {}
+
+  template <class I, class J>
+  forceinline
+  Union<I,J>::Union(I& i0, J& j0)
+    : i(i0), j(j0) {
+    operator++();
+  }
+
+  template <class I, class J>
+  forceinline void
+  Union<I,J>::init(I& i0, J& j0) {
+    i = i0; j = j0;
+    operator++();
+  }
+
+
+
+  /*
+   * Nary Union
+   *
+   */
+
+  template <class I>
+  forceinline bool
+  NaryUnion<I>::RangeUnionOrder::operator()(const I& a, const I& b) const {
+    return a.min() > b.min();
+  }
+
+  template <class I>
+  inline void
+  NaryUnion<I>::operator++(void) {
+    if (r.empty()) {
+      finish(); return;
+    }
+    mi = r.top().min();
+    ma = r.top().max();
+    do {
+      if (ma < r.top().max())
+	ma = r.top().max();
+      ++(r.top());
+      if (!(r.top())()) {
+	r.remove();
+	if (r.empty())
+	  return;
+      } else {
+	r.fix();
+      }
+    } while (ma+1 >= r.top().min());
+  }
+
+
+  template <class I>
+  forceinline
+  NaryUnion<I>::NaryUnion(void) {}
+
+  template <class I>
+  inline
+  NaryUnion<I>::NaryUnion(I* r0, int n)
+    : order(), r(n,order) {
+    for (int i = n; i--; )
+      if (r0[i]())
+	r.insert(r0[i]);
+    operator++();
+  }
+
+  template <class I>
+  inline void
+  NaryUnion<I>::init(I* r0, int n) {
+    r.init(n,order);
+    for (int i = n; i--; )
+      if (r0[i]())
+	r.insert(r0[i]);
+    operator++();
+  }
+
+}}}
+
+// STATISTICS: iter-any
+