gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,206 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     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.
+ *
+ */
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for computing the complement (described by template arguments)
+   *
+   * The complement is computed with respect to a given universe set
+   * provided as template arguments (\a UMIN ... \a UMAX). The universe
+   * must always be a superset!
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <int UMIN, int UMAX, class I>
+  class Compl : public MinMax {
+  protected:
+    /// Iterator to compute complement for
+    I i;
+    /// Initialize
+    void start(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Compl(void);
+    /// Initialize with iterator \a i
+    Compl(I& i);
+    /// Initialize with iterator \a i
+    void init(I& i);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  /**
+   * \brief Range iterator for computing the complement (described by values)
+   *
+   * The complement is computed with respect to a given universe set
+   * provided as arguments upon initialization. The universe
+   * must always be a superset!
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I>
+  class ComplVal : public MinMax {
+  protected:
+    /// Values describing the universe set
+    int UMIN, UMAX;
+    /// Iterator to compute complement for
+    I i;
+    /// Initialize
+    void start(void);
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ComplVal(void);
+    /// Initialize with iterator \a i
+    ComplVal(int umin, int umax, I& i);
+    /// Initialize with iterator \a i
+    void init(int umin, int umax, I& i);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  template <int UMIN, int UMAX, class I>
+  forceinline void
+  Compl<UMIN,UMAX,I>::start(void) {
+    if (i()) {
+      assert((i.min() >= UMIN) && (i.max() <= UMAX));
+      if (i.min() > UMIN) {
+	mi = UMIN;
+	ma = i.min()-1;
+      } else if (i.max() < UMAX) {
+	mi = i.max()+1;
+	++i;
+	ma = i() ? (i.min()-1) : UMAX;
+      } else {
+	finish();
+      }
+    } else {
+      mi = UMIN;
+      ma = UMAX;
+    }
+  }
+
+  template <int UMIN, int UMAX, class I>
+  forceinline
+  Compl<UMIN,UMAX,I>::Compl(void) {}
+
+  template <int UMIN, int UMAX, class I>
+  forceinline
+  Compl<UMIN,UMAX,I>::Compl(I& i0) : i(i0) {
+    start();
+  }
+
+  template <int UMIN, int UMAX, class I>
+  forceinline void
+  Compl<UMIN,UMAX,I>::init(I& i0) {
+    i=i0; start();
+  }
+
+  template <int UMIN, int UMAX, class I>
+  forceinline void
+  Compl<UMIN,UMAX,I>::operator++(void) {
+    assert(!i() || (i.max() <= UMAX));
+    if (i() && (i.max() < UMAX)) {
+      mi = i.max()+1;
+      ++i;
+      ma = i() ? (i.min()-1) : UMAX;
+    } else {
+      finish();
+    }
+  }
+
+  template <class I>
+  forceinline void
+  ComplVal<I>::start(void) {
+    if (i()) {
+      assert((i.min() >= UMIN) && (i.max() <= UMAX));
+      if (i.min() > UMIN) {
+	mi = UMIN;
+	ma = i.min()-1;
+      } else if (i.max() < UMAX) {
+	mi = i.max()+1;
+	++i;
+	ma = i() ? (i.min()-1) : UMAX;
+      } else {
+	finish();
+      }
+    } else {
+      mi = UMIN;
+      ma = UMAX;
+    }
+  }
+
+  template <class I>
+  forceinline
+  ComplVal<I>::ComplVal(void) {}
+
+  template <class I>
+  forceinline
+  ComplVal<I>::ComplVal(int umin, int umax, I& i0)
+    : UMIN(umin), UMAX(umax), i(i0) {
+    start();
+  }
+
+  template <class I>
+  forceinline void
+  ComplVal<I>::init(int umin, int umax, I& i0) {
+    UMIN=umin; UMAX=umax; i=i0; start();
+  }
+
+  template <class I>
+  forceinline void
+  ComplVal<I>::operator++(void) {
+    assert(!i() || (i.max() <= UMAX));
+    if (i() && (i.max() < UMAX)) {
+      mi = i.max()+1;
+      ++i;
+      ma = i() ? (i.min()-1) : UMAX;
+    } else {
+      finish();
+    }
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,127 @@
+/*
+ *  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 computing set difference
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  template <class I, class J>
+  class Diff : public MinMax {
+  protected:
+    /// Iterator from which to subtract
+    I i;
+    /// Iterator to be subtracted
+    J j;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Diff(void);
+    /// Initialize with iterator \a i and \a j
+    Diff(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);
+    //@}
+  };
+
+
+
+  template <class I, class J>
+  forceinline void
+  Diff<I,J>::operator++(void) {
+    // Precondition: mi <= ma
+    // Task: find next mi greater than ma
+  retry:
+    if (!i()) goto done;
+    mi = ma+1;
+    ma = i.max();
+    if (mi > i.max()) {
+      ++i;
+      if (!i()) goto done;
+      mi = i.min();
+      ma = i.max();
+    }
+    while (j() && (j.max() < mi))
+      ++j;
+    if (j() && (j.min() <= ma)) {
+      // Now the interval [mi ... ma] must be shrunken
+      // Is [mi ... ma] completely consumed?
+      if ((mi >= j.min()) && (ma <= j.max()))
+	goto retry;
+      // Does [mi ... ma] overlap on the left?
+      if (j.min() <= mi) {
+	mi = j.max()+1;
+	// Search for max!
+	++j;
+	if (j() && (j.min() <= ma))
+	  ma = j.min()-1;
+      } else {
+	ma = j.min()-1;
+      }
+    }
+    return;
+  done:
+    finish();
+  }
+
+  template <class I, class J>
+  forceinline
+  Diff<I,J>::Diff(void) {}
+
+  template <class I, class J>
+  forceinline
+  Diff<I,J>::Diff(I& i0, J& j0)
+    : i(i0), j(j0) {
+    if (!i()) {
+      finish();
+    } else {
+      mi = i.min()-1; ma = mi;
+      operator++();
+    }
+  }
+
+  template <class I, class J>
+  forceinline void
+  Diff<I,J>::init(I& i0, J& j0) {
+    i = i0; j = j0;
+    if (!i()) {
+      finish();
+    } else {
+      mi = i.min()-1; ma = mi;
+      operator++();
+    }
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,96 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-07-19 14:57:38 +0200 (Wed, 19 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3413 $
+ *
+ *  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 empty range
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+
+  class Empty {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Empty(void);
+    /// Initialize
+    void init(void);
+    //@}
+
+    /// \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;
+    //@}
+  };
+
+
+  forceinline
+  Empty::Empty(void) {}
+
+  forceinline void
+  Empty::init(void) {}
+
+  forceinline void
+  Empty::operator++(void) {
+    GECODE_NEVER;
+  }
+
+  forceinline bool
+  Empty::operator()(void) const {
+    return false;
+  }
+
+  forceinline int
+  Empty::min(void) const {
+    GECODE_NEVER;
+    return 0;
+  }
+  forceinline int
+  Empty::max(void) const {
+    GECODE_NEVER;
+    return 0;
+  }
+  forceinline unsigned int
+  Empty::width(void) const {
+    GECODE_NEVER;
+    return 0;
+  }
+
+}}}
+
+// STATISTICS: iter-any
+

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

@@ -0,0 +1,202 @@
+/*
+ *  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 <algorithm>
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for computing intersection (binary)
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I, class J>
+  class Inter : public MinMax {
+  protected:
+    /// First iterator
+    I i;
+    /// Second iterator
+    J j;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Inter(void);
+    /// Initialize with iterator \a i and \a j
+    Inter(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 intersection for any number of iterators
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class NaryInter : public MinMax {
+  protected:
+    /// Array of iterators
+    I* is;
+    /// Number of iterators
+    int n;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    NaryInter(void);
+    /// Initialize with \a n iterators in \a i
+    NaryInter(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 intersection
+   *
+   */
+
+  template <class I, class J>
+  inline void
+  Inter<I,J>::operator++(void) {
+    if (!i() || !j()) goto done;
+    do {
+      while (i() && (i.max() < j.min())) ++i;
+      if (!i()) goto done;
+      while (j() && (j.max() < i.min())) ++j;
+      if (!j()) goto done;
+    } while (i.max() < j.min());
+    // Now the intervals overlap: consume the smaller interval
+    ma = std::min(i.max(),j.max());
+    mi = std::max(i.min(),j.min());
+    if (i.max() < j.max()) ++i; else ++j;
+    return;
+  done:
+    finish();
+  }
+
+  template <class I, class J>
+  forceinline
+  Inter<I,J>::Inter(void) {}
+
+  template <class I, class J>
+  forceinline
+  Inter<I,J>::Inter(I& i0, J& j0)
+    : i(i0), j(j0) {
+    operator++();
+  }
+
+  template <class I, class J>
+  forceinline void
+  Inter<I,J>::init(I& i0, J& j0) {
+    i = i0; j = j0;
+    operator++();
+  }
+
+
+  /*
+   * Nary intersection
+   *
+   */
+
+  template <class I>
+  inline void
+  NaryInter<I>::operator++(void) {
+    // The next interval to be returned must have a hole
+    // between it and the previously returned range.
+    mi = ma+2;
+    ma = is[0].max();
+    // Intersect with all other intervals
+  restart:
+    for (int i = n; i--;) {
+      // Skip intervals that are too small
+      while (is[i]() && (is[i].max() < mi))
+	++is[i];
+      if (!is[i]())
+	goto done;
+
+      if (is[i].min() > ma) {
+        mi=is[i].min();
+        ma=is[i].max();
+        goto restart;
+      }
+      // Now the intervals overlap
+      if (mi < is[i].min())
+	mi = is[i].min();
+      if (ma > is[i].max()) {
+	ma = is[i].max();
+      }
+    }
+    return;
+  done:
+    finish();
+  }
+
+  template <class I>
+  forceinline
+  NaryInter<I>::NaryInter(void) {}
+
+  template <class I>
+  inline
+  NaryInter<I>::NaryInter(I* is0, int n0)
+    : is(is0), n(n0) {
+    if (!is[0]()) {
+      finish();
+    } else {
+      ma=is[0].min()-2;
+      operator++();
+    }
+  }
+
+  template <class I>
+  inline void
+  NaryInter<I>::init(I* is0, int n0) {
+    is = is0; n = n0;
+    if (!is[0]()) {
+      finish();
+    } else {
+      ma=is[0].min()-2;
+      operator++();
+    }
+  }
+
+}}}
+
+// STATISTICS: iter-any
+