gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,238 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2007-09-11 15:58:22 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 4973 $
+ *
+ *  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 <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 double 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).
+   *
+   * \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
+   *
+   * \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-2.1.1/gecode/iter/ranges-singleton-append.icc

@@ -0,0 +1,111 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *    Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-09-11 15:58:22 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 4973 $
+ *
+ *  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 Iter { namespace Ranges {
+
+  /**
+   * \brief %Range iterator for appending a singleton with a range iterator
+   *
+   * The singleton is not allowed to be adjacent to the iterator.
+   *
+   * \ingroup FuncIterRanges
+   */
+
+  template <class J>
+  class SingletonAppend : public MinMax {
+  protected:
+    /// Iterator to be appended
+    J j;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SingletonAppend(void);
+    /// Initialize with singleton (\a i0, \a i1) and iterator \a j
+    SingletonAppend(int i0, int i1, J& j);
+    /// Initialize with singleton (\a i0, \a i1) and iterator \a j
+    void init(int i0, int i1, J& j);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  /*
+   * Binary SingletonAppend
+   *
+   */
+
+  template <class J>
+  inline void
+  SingletonAppend<J>::operator++(void) {
+    if (j()) {
+      mi = j.min();  ma = j.max();
+      ++j;
+    } else {
+      finish();
+    }
+  }
+
+
+  template <class J>
+  forceinline
+  SingletonAppend<J>::SingletonAppend(void) {}
+
+  template <class J>
+  forceinline
+  SingletonAppend<J>::SingletonAppend(int i0, int i1, J& j0)
+    : j(j0) {
+    mi = i0; ma=i1;
+  }
+
+  template <class J>
+  forceinline void
+  SingletonAppend<J>::init(int i0, int i1, J& j0) {
+    mi = i0; ma=i1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,86 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2007-09-11 15:58:22 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 4973 $
+ *
+ *  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 Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for singleton range
+   *
+   * \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-2.1.1/gecode/iter/ranges-size.icc

@@ -0,0 +1,146 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2007-09-11 15:58:22 +0200 (Tue, 11 Sep 2007) $ by $Author: schulte $
+ *     $Revision: 4973 $
+ *
+ *  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 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.
+   *
+   * \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
+