gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/iter/ranges-positive.icc

@@ -0,0 +1,139 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:47:36 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7308 $
+ *
+ *  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 <algorithm>
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for positive part of a range iterator
+   *
+   * If \a strict is true, zero is excluded.
+   *
+   * \ingroup FuncIterRanges
+   */
+  template <class I, bool strict=false>
+  class Positive  {
+  private:
+    /// Input iterator
+    I i;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Positive(void);
+    /// Initialize with ranges from \a i
+    Positive(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, bool strict>
+  forceinline
+  Positive<I,strict>::Positive(void) {}
+
+  template <class I, bool strict>
+  forceinline void
+  Positive<I,strict>::init(I& i0) {
+    i=i0;
+    if (strict) {
+      while (i() && (i.max() < 0)) ++i;
+    } else {
+      while (i() && (i.max() <= 0)) ++i;
+    }
+  }
+
+  template <class I, bool strict>
+  forceinline
+  Positive<I,strict>::Positive(I& i) {
+    init(i);
+  }
+
+  template <class I, bool strict>
+  forceinline void
+  Positive<I,strict>::operator++(void) {
+    ++i;
+  }
+  template <class I, bool strict>
+  forceinline bool
+  Positive<I,strict>::operator()(void) const {
+    return i();
+  }
+
+  template <class I, bool strict>
+  forceinline int
+  Positive<I,strict>::min(void) const {
+    if (strict) {
+      return std::max(i.min(),1);
+    } else {
+      return std::max(i.min(),0);
+    }
+  }
+  template <class I, bool strict>
+  forceinline int
+  Positive<I,strict>::max(void) const {
+    return i.max();
+  }
+  template <class I, bool strict>
+  forceinline unsigned int
+  Positive<I,strict>::width(void) const {
+    return static_cast<unsigned int>(max()-min()+1);
+  }
+
+}}}
+
+// STATISTICS: iter-any

data/ext/gecode-2.2.0/gecode/iter/values-inter.icc

@@ -0,0 +1,130 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:47:36 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7308 $
+ *
+ *  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 Values {
+
+  /**
+   * \brief Value iterator for the intersection of two value iterators
+   *
+   * \ingroup FuncIterValues
+   */
+
+  template <class I, class J>
+  class Inter  {
+  private:
+    /// First iterator
+    I i;
+    /// Second iterator
+    J j;
+    /// Find next element from intersection
+    void next(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Inter(void);
+    /// Initialize with values from \a i and \a j
+    Inter(I& i, J& j);
+    /// Initialize with values from \a i and \a j
+    void init(I& i, J& j);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int val(void) const;
+    //@}
+  };
+
+
+  template <class I, class J>
+  forceinline
+  Inter<I,J>::Inter(void) {}
+
+  template <class I, class J>
+  forceinline void
+  Inter<I,J>::next(void) {
+    do {
+      while (i() && j() && (i.val() < j.val()))
+        ++i;
+      while (i() && j() && (j.val() < i.val()))
+        ++j;
+    } while (i() && j() && (i.val() != j.val()));
+  }
+
+  template <class I, class J>
+  inline void
+  Inter<I,J>::init(I& i0, J& j0) {
+    i=i0; j=j0; next();
+  }
+
+  template <class I, class J>
+  forceinline
+  Inter<I,J>::Inter(I& i0, J& j0) : i(i0), j(j0) {
+    next();
+  }
+
+  template <class I, class J>
+  forceinline void
+  Inter<I,J>::operator++(void) {
+    ++i; ++j; next();
+  }
+
+  template <class I, class J>
+  forceinline bool
+  Inter<I,J>::operator()(void) const {
+    return i() && j();
+  }
+
+  template <class I, class J>
+  forceinline int
+  Inter<I,J>::val(void) const {
+    assert(i.val() == j.val());
+    return i.val();
+  }
+
+}}}
+
+// STATISTICS: iter-any

data/ext/gecode-2.2.0/gecode/iter/values-map.icc

@@ -0,0 +1,136 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:29:47 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7286 $
+ *
+ *  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 Values {
+
+  /**
+   * \brief Value iterator for mapping values of a value iterator
+   *
+   * If \a strict is true, the values obtained by mapping must be
+   * strictly increasing (that is, no duplicates).
+   *
+   * \ingroup FuncIterValues
+   */
+  template <class I, class M, bool strict=false>
+  class Map  {
+  private:
+    /// Input iterator
+    I i;
+    /// Mapping object
+    M m;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Map(void);
+    /// Initialize with values from \a i
+    Map(I& i);
+    /// Initialize with values from \a i and map \a m
+    Map(I& i, const M& m);
+    /// Initialize with values from \a i
+    void init(I& i);
+    /// Initialize with values from \a i and map \a m
+    void init(I& i, const M& m);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int val(void) const;
+    //@}
+  };
+
+
+  template <class I, class M, bool strict>
+  forceinline
+  Map<I,M,strict>::Map(void) {}
+
+  template <class I, class M, bool strict>
+  forceinline
+  Map<I,M,strict>::Map(I& i0) : i(i0) {}
+
+  template <class I, class M, bool strict>
+  forceinline
+  Map<I,M,strict>::Map(I& i0, const M& m0) : i(i0), m(m0) {}
+
+  template <class I, class M, bool strict>
+  forceinline void
+  Map<I,M,strict>::init(I& i0) {
+    i=i0;
+  }
+
+  template <class I, class M, bool strict>
+  forceinline void
+  Map<I,M,strict>::init(I& i0, const M& m0) {
+    i=i0; m=m0;
+  }
+
+  template <class I, class M, bool strict>
+  forceinline void
+  Map<I,M,strict>::operator++(void) {
+    if (strict) {
+      ++i;
+    } else {
+      int n=m.val(i.val());
+      do {
+        ++i;
+      } while (i() && (n == m.val(i.val())));
+    }
+  }
+  template <class I, class M, bool strict>
+  forceinline bool
+  Map<I,M,strict>::operator()(void) const {
+    return i();
+  }
+
+  template <class I, class M, bool strict>
+  forceinline int
+  Map<I,M,strict>::val(void) const {
+    return m.val(i.val());
+  }
+
+}}}
+
+// STATISTICS: iter-any

data/ext/gecode-2.2.0/gecode/iter/values-minus.icc

@@ -0,0 +1,130 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:47:36 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7308 $
+ *
+ *  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 Values {
+
+  /**
+   * \brief Value iterator for pointwise minus of a value iterator
+   *
+   * This iterator in effect changes the order of how values
+   * are iterated: the first values of the input iterator defines
+   * the last value of the Minus iterator. Upon initialization
+   * all values of the input iterator are stored in an array
+   * which later allows iteration in inverse direction.
+   *
+   * \ingroup FuncIterValues
+   */
+
+  template <class I>
+  class Minus  {
+  private:
+    /// %Values stored
+    SharedArray<int> v;
+    /// Current value position
+    int c;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Minus(void);
+    /// Initialize with values from \a i
+    Minus(I& i);
+    /// Initialize with values from \a i
+    void init(I& i);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a value or done
+    bool operator()(void) const;
+    /// Move iterator to next value (if possible)
+    void operator++(void);
+    //@}
+
+    /// \name Value access
+    //@{
+    /// Return current value
+    int val(void) const;
+    //@}
+  };
+
+
+  template <class I>
+  forceinline
+  Minus<I>::Minus(void) {}
+
+  template <class I>
+  inline void
+  Minus<I>::init(I& i) {
+    Support::DynamicArray<int> d;
+    int n=0;
+    while (i()) {
+      d[n] = -i.val();
+      ++n; ++i;
+    }
+    v.init(n);
+    for (int j=n; j--; )
+      v[j]=d[j];
+    c = n-1;
+  }
+
+  template <class I>
+  forceinline
+  Minus<I>::Minus(I& i) {
+    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>::val(void) const {
+    return v[c];
+  }
+
+}}}
+
+// STATISTICS: iter-any