gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/iter.hh

@@ -0,0 +1,98 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_ITER_HH__
+#define __GECODE_ITER_HH__
+
+namespace Gecode {
+  /// Range and value iterators
+  namespace Iter {
+     /// Range iterators
+     namespace Ranges {
+       /// Range iterators with virtual member functions
+       namespace Virt {}
+     }
+     /// Value iterators
+     namespace Values {}
+  }
+}
+
+#include "gecode/iter/ranges-operations.icc"
+#include "gecode/iter/ranges-minmax.icc"
+
+#include "gecode/iter/ranges-append.icc"
+#include "gecode/iter/ranges-array.icc"
+#include "gecode/iter/ranges-cache.icc"
+#include "gecode/iter/ranges-compl.icc"
+#include "gecode/iter/ranges-diff.icc"
+#include "gecode/iter/ranges-empty.icc"
+#include "gecode/iter/ranges-inter.icc"
+#include "gecode/iter/ranges-map.icc"
+#include "gecode/iter/ranges-minus.icc"
+#include "gecode/iter/ranges-negative.icc"
+#include "gecode/iter/ranges-offset.icc"
+#include "gecode/iter/ranges-positive.icc"
+#include "gecode/iter/ranges-scale.icc"
+#include "gecode/iter/ranges-singleton.icc"
+#include "gecode/iter/ranges-union.icc"
+#include "gecode/iter/ranges-values.icc"
+#include "gecode/iter/ranges-add.icc"
+#include "gecode/iter/ranges-singleton-append.icc"
+
+#include "gecode/iter/values-array.icc"
+#include "gecode/iter/values-map.icc"
+#include "gecode/iter/values-inter.icc"
+#include "gecode/iter/values-minus.icc"
+#include "gecode/iter/values-negative.icc"
+#include "gecode/iter/values-offset.icc"
+#include "gecode/iter/values-positive.icc"
+#include "gecode/iter/values-ranges.icc"
+#include "gecode/iter/values-singleton.icc"
+#include "gecode/iter/values-union.icc"
+#include "gecode/iter/values-unique.icc"
+
+#include "gecode/iter/ranges-size.icc"
+
+#include "gecode/iter/virtual-ranges.icc"
+#include "gecode/iter/virtual-ranges-union.icc"
+#include "gecode/iter/virtual-ranges-inter.icc"
+#include "gecode/iter/virtual-ranges-compl.icc"
+
+#endif
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,260 @@
+/* -*- 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:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  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 mapping ranges
+   *
+   * If \a strict is true, then mapped ranges are not allowed to
+   * be adjacent or overlap.
+   *
+   * \ingroup FuncIterRanges
+   */
+  template <class I, class M, bool strict=true>
+  class Map {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Map(void);
+    /// Initialize with ranges from \a i
+    Map(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    Map(I& i, const M& m);
+    /// Initialize with ranges from \a i
+    void init(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    void init(I& i, const M& m);
+    //@}
+
+    /// \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;
+    //@}
+  };
+
+  /// Specialized mapping of ranges for non-strict maps
+  template <class I, class M>
+  class Map<I,M,false> : public MinMax {
+  protected:
+    /// Input range
+    I i;
+    /// Map for ranges
+    M m;
+    /// Find next mapped range
+    void next(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Map(void);
+    /// Initialize with ranges from \a i
+    Map(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    Map(I& i, const M& m);
+    /// Initialize with ranges from \a i
+    void init(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    void init(I& i, const M& m);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+  /// Specialized mapping of ranges for strict maps
+  template <class I, class M>
+  class Map<I,M,true> {
+  protected:
+    /// Input range iterator
+    I i;
+    /// Map object
+    M m;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Map(void);
+    /// Initialize with ranges from \a i
+    Map(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    Map(I& i, const M& m);
+    /// Initialize with ranges from \a i
+    void init(I& i);
+    /// Initialize with ranges from \a i and map \a m
+    void init(I& i, const M& m);
+    //@}
+
+    /// \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, class M>
+  forceinline
+  Map<I,M,false>::Map(void) {}
+
+  template <class I, class M>
+  forceinline void
+  Map<I,M,false>::next(void) {
+    if (i()) {
+      mi = m.min(i.min());
+      ma = m.max(i.max());
+      ++i;
+      while (i() && (ma+1 >= m.min(i.min()))) {
+        ma = m.max(i.max()); ++i;
+      }
+    } else {
+      finish();
+    }
+  }
+
+  template <class I, class M>
+  forceinline void
+  Map<I,M,false>::init(I& i0) {
+    i=i0; next();
+  }
+  template <class I, class M>
+  forceinline void
+  Map<I,M,false>::init(I& i0, const M& m0) {
+    i=i0; m=m0; next();
+  }
+
+  template <class I, class M>
+  forceinline
+  Map<I,M,false>::Map(I& i0) : i(i0) {
+    next();
+  }
+  template <class I, class M>
+  forceinline
+  Map<I,M,false>::Map(I& i0, const M& m0) : i(i0), m(m0) {
+    next();
+  }
+
+  template <class I, class M>
+  forceinline void
+  Map<I,M,false>::operator++(void) {
+    next();
+  }
+
+
+
+  template <class I, class M>
+  forceinline
+  Map<I,M,true>::Map(void) {}
+
+  template <class I, class M>
+  forceinline void
+  Map<I,M,true>::init(I& i0) {
+    i=i0;
+  }
+  template <class I, class M>
+  forceinline void
+  Map<I,M,true>::init(I& i0, const M& m0) {
+    i=i0; m=m0;
+  }
+
+  template <class I, class M>
+  forceinline
+  Map<I,M,true>::Map(I& i0) : i(i0) {}
+  template <class I, class M>
+  forceinline
+  Map<I,M,true>::Map(I& i0, const M& m0) : i(i0), m(m0) {}
+
+  template <class I, class M>
+  forceinline bool
+  Map<I,M,true>::operator()(void) const {
+    return i();
+  }
+  template <class I, class M>
+  forceinline void
+  Map<I,M,true>::operator++(void) {
+    ++i;
+  }
+
+  template <class I, class M>
+  forceinline int
+  Map<I,M,true>::min(void) const {
+    return m.min(i.min());
+  }
+  template <class I, class M>
+  forceinline int
+  Map<I,M,true>::max(void) const {
+    return m.max(i.max());
+  }
+  template <class I, class M>
+  forceinline unsigned int
+  Map<I,M,true>::width(void) const {
+    return static_cast<unsigned int>(max()-min())+1;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,137 @@
+/* -*- 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 negative part of a range iterator
+   *
+   * If \a strict is true, zero is excluded.
+   *
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I, bool strict=false>
+  class Negative  {
+  private:
+    /// Input iterator
+    I i;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Negative(void);
+    /// Initialize with ranges from \a i
+    Negative(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
+  Negative<I,strict>::Negative(void) {}
+
+  template <class I, bool strict>
+  forceinline void
+  Negative<I,strict>::init(I& i0) {
+    i=i0;
+  }
+
+  template <class I, bool strict>
+  forceinline
+  Negative<I,strict>::Negative(I& i0) : i(i0) {}
+
+  template <class I, bool strict>
+  forceinline void
+  Negative<I,strict>::operator++(void) {
+    ++i;
+  }
+  template <class I, bool strict>
+  forceinline bool
+  Negative<I,strict>::operator()(void) const {
+    if (strict) {
+      return i() && (i.min() < 0);
+    } else {
+      return i() && (i.min() <= 0);
+    }
+  }
+
+  template <class I, bool strict>
+  forceinline int
+  Negative<I,strict>::min(void) const {
+    return i.min();
+  }
+  template <class I, bool strict>
+  forceinline int
+  Negative<I,strict>::max(void) const {
+    if (strict) {
+      return std::min(i.max(),-1);
+    } else {
+      return std::min(i.max(),0);
+    }
+  }
+  template <class I, bool strict>
+  forceinline unsigned int
+  Negative<I,strict>::width(void) const {
+    return static_cast<unsigned int>(max()-min()+1);
+  }
+
+}}}
+
+// STATISTICS: iter-any