gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/view/scale.icc

@@ -0,0 +1,373 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-24 11:25:05 +0200 (Thu, 24 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3559 $
+ *
+ *  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 Int {
+
+    /*
+     * Support functions for division
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::floor_div(double x) const {
+      return static_cast<int>(floor(x / a));
+    }
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::ceil_div(double x) const {
+      return static_cast<int>(ceil(x / a));
+    }
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::exact_div(double x, bool& exact) const {
+      double xa = x / a;
+      if (ceil(xa) == xa) {
+	exact = true;  return static_cast<int>(xa);
+      } else {
+	exact = false; return 0;
+      }
+    }
+
+#if GECODE_INT_RND_TWDS_ZERO
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::floor_div(int x) const {
+      return ((x >= 0) ? x : (x-a+1))/a;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::ceil_div(int x) const {
+      return ((x >= 0) ? (x+a-1) : x)/a;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::exact_div(int x, bool& exact) const {
+      int xa = x / a;
+      if (a * xa == x) {
+	exact = true;  return xa;
+      } else {
+	exact = false; return 0;
+      }
+    }
+
+#endif
+
+
+    /*
+     * Constructors and initialization
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline
+    ScaleView<Val,UnsVal>::ScaleView(void) {}
+
+    template <class Val, class UnsVal>
+    forceinline
+    ScaleView<Val,UnsVal>::ScaleView(int b, const IntView& x)
+      : DerivedViewBase<IntView>(x), a(b) {}
+
+    template <class Val, class UnsVal>
+    forceinline void
+    ScaleView<Val,UnsVal>::init(int b, const IntView& x) {
+      view=x; a=b;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline int
+    ScaleView<Val,UnsVal>::scale(void) const {
+      return a;
+    }
+
+
+
+    /*
+     * Value access
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline Val
+    ScaleView<Val,UnsVal>::min(void) const {
+      Val c = view.min(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline Val
+    ScaleView<Val,UnsVal>::max(void) const {
+      Val c = view.max(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline Val
+    ScaleView<Val,UnsVal>::med(void) const {
+      Val c = view.med(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline Val
+    ScaleView<Val,UnsVal>::val(void) const {
+      Val c = view.val(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline UnsVal
+    ScaleView<Val,UnsVal>::size(void) const {
+      return static_cast<UnsVal>(view.size());
+    }
+
+    template <class Val, class UnsVal>
+    forceinline UnsVal
+    ScaleView<Val,UnsVal>::width(void) const {
+      UnsVal c = view.width(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline UnsVal
+    ScaleView<Val,UnsVal>::regret_min(void) const {
+      UnsVal c = view.regret_min(); c *= a; return c;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline UnsVal
+    ScaleView<Val,UnsVal>::regret_max(void) const {
+      UnsVal c = view.regret_max(); c *= a; return c;
+    }
+
+
+    /*
+     * Domain tests
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline bool
+    ScaleView<Val,UnsVal>::range(void) const {
+      return view.range();
+    }
+
+    template <class Val, class UnsVal>
+    forceinline bool
+    ScaleView<Val,UnsVal>::assigned(void) const {
+      return view.assigned();
+    }
+
+    template <class Val, class UnsVal>
+    forceinline bool
+    ScaleView<Val,UnsVal>::in(Val n) const {
+      bool exact;
+      int nda = exact_div(n, exact);
+      return exact && view.in(nda);
+    }
+
+
+
+
+    /*
+     * Domain update by value
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::lq(Space* home, Val n) {
+      return (n >= max()) ? ME_INT_NONE : view.lq(home,floor_div(n));
+    }
+
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::le(Space* home, Val n) {
+      return (n > max()) ? ME_INT_NONE : view.le(home,floor_div(n));
+    }
+
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::gq(Space* home, Val n) {
+      return (n <= min()) ? ME_INT_NONE : view.gq(home,ceil_div(n));
+    }
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::gr(Space* home, Val n) {
+      return (n < min()) ? ME_INT_NONE : view.gr(home,ceil_div(n));
+    }
+
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::nq(Space* home, Val n) {
+      bool exact;
+      int nda = exact_div(n,exact);
+      return exact ? view.nq(home,nda) :  ME_INT_NONE;
+    }
+
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::eq(Space* home, Val n) {
+      bool exact;
+      int nda = exact_div(n,exact);
+      return exact ? view.eq(home,nda) : ME_INT_FAILED;
+    }
+
+
+    /*
+     * Propagator modification events
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline ModEvent
+    ScaleView<Val,UnsVal>::pme(const Propagator* p) {
+      return IntView::pme(p);
+    }
+
+    template <class Val, class UnsVal>
+    forceinline PropModEvent
+    ScaleView<Val,UnsVal>::pme(ModEvent me) {
+      return IntView::pme(me);
+    }
+
+
+
+    /*
+     * Dependencies
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline void
+    ScaleView<Val,UnsVal>::subscribe(Space* home, Propagator* p, PropCond pc,
+				     bool process) {
+      view.subscribe(home,p,pc,process);
+    }
+    template <class Val, class UnsVal>
+    forceinline void
+    ScaleView<Val,UnsVal>::cancel(Space* home, Propagator* p, PropCond pc) {
+      view.cancel(home,p,pc);
+    }
+
+
+    /*
+     * Cloning
+     *
+     */
+    template <class Val, class UnsVal>
+    forceinline void
+    ScaleView<Val,UnsVal>::update(Space* home, bool share,
+				  ScaleView<Val,UnsVal>& x) {
+      a=x.a; view.update(home,share,x.view);
+    }
+
+
+    /**
+     * \brief %Range iterator for integer-precision scale integer views
+     * \ingroup TaskActorIntView
+     */
+    template <>
+    class ViewRanges<IntScaleView>
+      : public Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> > {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ViewRanges(void);
+      /// Initialize with ranges for view \a x
+      ViewRanges(const IntScaleView& x);
+      /// Initialize with ranges for view \a x
+      void init(const IntScaleView& x);
+      //@}
+    };
+
+    forceinline
+    ViewRanges<IntScaleView>::ViewRanges(void) {}
+    forceinline
+    ViewRanges<IntScaleView>::ViewRanges(const IntScaleView& x) {
+      ViewRanges<IntView> xi(x.base());
+      Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
+	(xi,x.scale());
+    }
+    forceinline void
+    ViewRanges<IntScaleView>::init(const IntScaleView& x) {
+      ViewRanges<IntView> xi(x.base());
+      Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
+	(xi,x.scale());
+    }
+
+
+    /**
+     * \brief %Range iterator for double-precision scale integer views
+     * \ingroup TaskActorIntView
+     */
+    template <>
+    class ViewRanges<DoubleScaleView>
+      : public Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> > {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ViewRanges(void);
+      /// Initialize with ranges for view \a x
+      ViewRanges(const DoubleScaleView& x);
+      /// Initialize with ranges for view \a x
+      void init(const DoubleScaleView& x);
+      //@}
+    };
+
+    forceinline
+    ViewRanges<DoubleScaleView>::ViewRanges(void) {}
+    forceinline
+    ViewRanges<DoubleScaleView>::ViewRanges(const DoubleScaleView& x) {
+      ViewRanges<IntView> xi(x.base());
+      Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> >::init
+	(xi,x.scale());
+    }
+    forceinline void
+    ViewRanges<DoubleScaleView>::init(const DoubleScaleView& x) {
+      ViewRanges<IntView> xi(x.base());
+      Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> >::init
+	(xi,x.scale());
+    }
+
+  }
+
+
+
+  /*
+   * View comparison
+   *
+   */
+  template <class Val, class UnsVal>
+  forceinline bool
+  same(const Int::ScaleView<Val,UnsVal>& x,
+       const Int::ScaleView<Val,UnsVal>& y) {
+    return same(x.base(),y.base()) && (x.scale() == y.scale());
+  }
+  template <class Val, class UnsVal>
+  forceinline bool
+  before(const Int::ScaleView<Val,UnsVal>& x,
+	 const Int::ScaleView<Val,UnsVal>& y) {
+    return before(x.base(),y.base())
+      || (same(x.base(),y.base()) && (x.scale() < y.scale()));
+  }
+
+}
+
+// STATISTICS: int-var
+

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

@@ -0,0 +1,65 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-07-07 10:08:10 +0200 (Fri, 07 Jul 2006) $ by $Author: tack $
+ *     $Revision: 3339 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_ITER_HH__
+#define __GECODE_ITER_HH__
+
+namespace Gecode {
+  /// Range and value iterators
+  namespace Iter {
+     /// Range iterators
+     namespace Ranges {}
+     /// 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-minus.icc"
+#include "gecode/iter/ranges-offset.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-size.icc"
+
+#include "gecode/iter/values-ranges.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-1.3.1/gecode/iter/ranges-add.icc

@@ -0,0 +1,130 @@
+/*
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Iter { namespace Ranges {
+
+  /**
+   * \brief Range iterator for adding a single range to a range iterator
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class AddRange : public MinMax {
+  protected:
+    /// Iterator to which the range is to be added
+    I i;
+    /// Minimum of range to be added
+    int r_min;
+    /// Maximum of range to be added
+    int r_max;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    AddRange(void);
+    /// Initialize with ranges \a i and range \a min to \a max
+    AddRange(I& i, int min, int max);
+    /// Initialize with ranges \a i and range \a min to \a max
+    void init(I& i, int min, int max);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    void operator++(void);
+    //@}
+  };
+
+
+  /**
+   * \brief Range iterator for subtracting a single range from a range iterator
+   *
+   * Requires \code #include "gecode/iter.hh" \endcode
+   * \ingroup FuncIterRanges
+   */
+  template <class I>
+  class SubRange : public AddRange<I> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    SubRange(void);
+    /// Initialize with ranges \a i and range \a min to \a max
+    SubRange(I& i, int min, int max);
+    /// Initialize with ranges \a i and range \a min to \a max
+    void init(I& i, int min, int max);
+    //@}
+  };
+
+  template <class I>
+  forceinline
+  AddRange<I>::AddRange(void) {}
+
+  template <class I>
+  forceinline void
+  AddRange<I>::operator++(void) {
+    if (i()) {
+      mi = r_min + i.min();
+      ma = r_max + i.max();
+      ++i;
+      while (i() && (ma+1 >= r_min+i.min())) {
+	ma = r_max + i.max(); ++i;
+      }
+    } else {
+      finish();
+    }
+  }
+
+  template <class I>
+  forceinline
+  AddRange<I>::AddRange(I& i0, int r_min0, int r_max0)
+    : i(i0), r_min(r_min0), r_max(r_max0) {
+    operator++();
+  }
+
+  template <class I>
+  forceinline void
+  AddRange<I>::init(I& i0, int r_min0, int r_max0) {
+    i = i0; r_min = r_min0; r_max = r_max0;
+    operator++();
+  }
+
+
+  template <class I>
+  forceinline
+  SubRange<I>::SubRange(void) {}
+
+  template <class I>
+  forceinline
+  SubRange<I>::SubRange(I& i, int r_min, int r_max)
+    : AddRange<I>(i,-r_max,-r_min) {}
+
+  template <class I>
+  forceinline void
+  SubRange<I>::init(I& i, int r_min, int r_max) {
+    AddRange<I>::init(i,-r_max,-r_min);
+  }
+
+}}}
+
+// STATISTICS: iter-any
+