gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/var/int.cc

@@ -0,0 +1,63 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-09-26 13:46:01 +0200 (Tue, 26 Sep 2006) $ by $Author: tack $
+ *     $Revision: 3703 $
+ *
+ *  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 "gecode/int.hh"
+
+namespace Gecode {
+
+  IntVar::IntVar(Space* home, int min, int max)
+    : var(new (home) Int::IntVarImp(home,min,max)) {
+    if ((min < Limits::Int::int_min) || (max > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVar::IntVar");
+    if (min > max)
+      throw Int::VariableEmptyDomain("IntVar::IntVar");
+  }
+
+  IntVar::IntVar(Space* home, const IntSet& ds)
+    : var(new (home) Int::IntVarImp(home,ds)) {
+    if ((ds.min() < Limits::Int::int_min) || (ds.max() > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVar::IntVar");
+    if (ds.size() == 0)
+      throw Int::VariableEmptyDomain("IntVar::IntVar");
+  }
+
+  void
+  IntVar::init(Space* home, int min, int max) {
+    if ((min < Limits::Int::int_min) || (max > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVar::init");
+    if (min > max)
+      throw Int::VariableEmptyDomain("IntVar::init");
+    var = new (home) Int::IntVarImp(home,min,max);
+  }
+
+  void
+  IntVar::init(Space* home, const IntSet& ds) {
+    if ((ds.min() < Limits::Int::int_min) || (ds.max() > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVar::init");
+    if (ds.size() == 0)
+      throw Int::VariableEmptyDomain("IntVar::init");
+    var = new (home) Int::IntVarImp(home,ds);
+  }
+
+}
+
+// STATISTICS: int-var
+

data/ext/gecode-1.3.1/gecode/int/var/int.icc

@@ -0,0 +1,135 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-09-21 11:35:18 +0200 (Thu, 21 Sep 2006) $ by $Author: schulte $
+ *     $Revision: 3686 $
+ *
+ *  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 {
+
+  forceinline
+  IntVar::IntVar(void) {}
+
+
+  inline
+  IntVar::IntVar(const IntVar& x)
+    : var(x.var) {}
+  inline
+  IntVar::IntVar(const Int::IntView& x)
+    : var(x.variable()) {}
+
+
+
+  forceinline Int::IntVarImp*
+  IntVar::variable(void) const {
+    return var;
+  }
+
+
+  forceinline int
+  IntVar::val(void) const {
+    return var->val();
+  }
+  forceinline int
+  IntVar::min(void) const {
+    return var->min();
+  }
+  forceinline int
+  IntVar::med(void) const {
+    return var->med();
+  }
+  forceinline int
+  IntVar::max(void) const {
+    return var->max();
+  }
+
+
+  forceinline unsigned int
+  IntVar::degree(void) const {
+    return var->degree();
+  }
+  forceinline unsigned int
+  IntVar::width(void) const {
+    return var->width();
+  }
+  forceinline unsigned int
+  IntVar::size(void) const {
+    return var->size();
+  }
+
+
+
+  forceinline bool
+  IntVar::assigned(void) const {
+    return var->assigned();
+  }
+  forceinline bool
+  IntVar::range(void) const {
+    return var->range();
+  }
+  forceinline bool
+  IntVar::in(int n) const {
+    return var->in(n);
+  }
+
+
+  forceinline void
+  IntVar::update(Space* home, bool share, IntVar& x) {
+    var = x.var->copy(home,share);
+  }
+
+  /*
+   * Range iterator
+   *
+   */
+  forceinline
+  IntVarRanges::IntVarRanges(void) {}
+
+  forceinline
+  IntVarRanges::IntVarRanges(const IntVar& x)
+    : Int::IntVarImpFwd(x.variable()) {}
+
+  forceinline void
+  IntVarRanges::init(const IntVar& x) {
+    Int::IntVarImpFwd::init(x.variable());
+  }
+
+
+  /*
+   * Value iterator
+   *
+   */
+
+  forceinline
+  IntVarValues::IntVarValues(void) {}
+
+  forceinline
+  IntVarValues::IntVarValues(const IntVar& x) {
+    IntVarRanges r(x);
+    Iter::Ranges::ToValues<IntVarRanges>::init(r);
+  }
+
+  forceinline void
+  IntVarValues::init(const IntVar& x) {
+    IntVarRanges r(x);
+    Iter::Ranges::ToValues<IntVarRanges>::init(r);
+  }
+
+}
+
+// STATISTICS: int-var
+

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

@@ -0,0 +1,1219 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  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.
+ *
+ */
+
+#include "gecode/iter.hh"
+
+#include <iostream>
+
+#if (-17 / 7) == -2
+#define GECODE_INT_RND_TWDS_ZERO 1
+#else
+#define GECODE_INT_RND_TWDS_ZERO 0
+#endif
+
+namespace Gecode { namespace Int {
+
+  /**
+   * \brief Range iterator for integer views
+   *
+   * This class provides (by specialization) a range iterator
+   * for all integer views.
+   *
+   * Note that this template class serves only as a specification
+   * of the interface of the various specializations.
+   *
+   * \ingroup TaskActorInt
+   */
+  template <class View>
+  class ViewRanges {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ViewRanges(void);
+    /// Initialize with ranges for view \a x
+    ViewRanges(const View& x);
+    /// Initialize with ranges for view \a x
+    void init(const View& x);
+    //@}
+
+    /// \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;
+    //@}
+  };
+
+  /**
+   * \brief Value iterator for integer views
+   *
+   * This class provides a value iterator for all
+   * integer views.
+   *
+   * \ingroup TaskActorInt
+   */
+  template <class View>
+  class ViewValues
+    : public Iter::Ranges::ToValues<ViewRanges<View> > {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ViewValues(void);
+    /// Initialize with values for \a x
+    ViewValues(const View& x);
+    /// Initialize with values \a x
+    void init(const View& x);
+    //@}
+  };
+
+}}
+
+#include "gecode/int/view/iter.icc"
+
+namespace Gecode {
+
+  namespace Int {
+
+    /**
+     * \defgroup TaskActorIntView Integer views
+     *
+     * Integer propagators and branchings compute with integer views.
+     * Integer views provide views on integer variable implementations,
+     * integer constants, and also allow to scale, translate, and negate
+     * variables. Additionally, a special Boolean view is provided that
+     * offers convenient and efficient operations for Boolean (0/1)
+     * views.
+     * \ingroup TaskActorInt
+     */
+
+    /**
+     * \brief Integer view for integer variables
+     * \ingroup TaskActorIntView
+     */
+    class IntView : public VariableViewBase<IntVarImp> {
+    protected:
+      using VariableViewBase<IntVarImp>::var;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      IntView(void);
+      /// Initialize from integer variable \a x
+      IntView(const IntVar& x);
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const;
+      /// Return maximum of domain
+      int max(void) const;
+      /// Return median of domain
+      int med(void) const;
+      /// Return assigned value (only if assigned)
+      int val(void) const;
+
+      /// Return size (cardinality) of domain
+      unsigned int size(void) const;
+      /// Return width of domain (distance between maximum and minimum)
+      unsigned int width(void) const;
+      /// Return regret of domain minimum (distance to next larger value)
+      unsigned int regret_min(void) const;
+      /// Return regret of domain maximum (distance to next smaller value)
+      unsigned int regret_max(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const;
+      /// Test whether view is assigned
+      bool assigned(void) const;
+
+      /// Test whether \a n is contained in domain
+      bool in(int n) const;
+      /// Test whether \a n is contained in domain
+      bool in(double n) const;
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, int n);
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, double n);
+
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, int n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, double n);
+
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, int n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, double n);
+
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, int n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, double n);
+
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, int n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, double n);
+
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, int n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, double n);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+      /// Replace domain by range sequence described by \a i
+      template <class I> ModEvent narrow(Space* home, I& i);
+      /// Intersect domain with range sequence described by \a i
+      template <class I> ModEvent inter(Space* home, I& i);
+      /// Remove from domain the range sequence described by \a i
+      template <class I> ModEvent minus(Space* home, I& i);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, IntView& x);
+      //@}
+    };
+
+  }
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for IntView
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::IntView> {
+  public:
+    /// The variable type of an IntView
+    typedef Int::IntVarImp Var;
+  };
+
+  namespace Int {
+
+    /**
+     * \brief Minus integer view
+     *
+     * A minus integer view \f$m\f$ for an integer view \f$x\f$ provides
+     * operations such that \f$m\f$ behaves as \f$-x\f$.
+     * \ingroup TaskActorIntView
+     */
+    class MinusView : public DerivedViewBase<IntView> {
+    protected:
+      using DerivedViewBase<IntView>::view;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      MinusView(void);
+      /// Initialize with integer view \a x
+      MinusView(const IntView& x);
+      /// Initialize with integer view \a x
+      void init(const IntView& x);
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const;
+      /// Return maximum of domain
+      int max(void) const;
+      /// Return median of domain
+      int med(void) const;
+      /// Return assigned value (only if assigned)
+      int val(void) const;
+
+      /// Return size (cardinality) of domain
+      unsigned int size(void) const;
+      /// Return width of domain (distance between maximum and minimum)
+      unsigned int width(void) const;
+      /// Return regret of domain minimum (distance to next larger value)
+      unsigned int regret_min(void) const;
+      /// Return regret of domain maximum (distance to next smaller value)
+      unsigned int regret_max(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const;
+      /// Test whether view is assigned
+      bool assigned(void) const;
+
+      /// Test whether \a n is contained in domain
+      bool in(int n) const;
+      /// Test whether \a n is contained in domain
+      bool in(double n) const;
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, int n);
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, double n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, int n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, double n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, int n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, double n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, int n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, double n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, int n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, double n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, int n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, double n);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+      /// Replace domain by range sequence described by \a i
+      template <class I> ModEvent narrow(Space* home, I& i);
+      /// Intersect domain with range sequence described by \a i
+      template <class I> ModEvent inter(Space* home, I& i);
+      /// Remove from domain the range sequence described by \a i
+      template <class I> ModEvent minus(Space* home, I& i);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent me);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, MinusView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Int::MinusView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Int::MinusView& x, const Int::MinusView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Int::MinusView& x, const Int::MinusView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for MinusView.
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::MinusView> {
+  public:
+    /// The variable type of a MinusView
+    typedef Int::IntVarImp Var;
+  };
+
+
+  namespace Int {
+
+    /**
+     * \brief Offset integer view
+     *
+     * An offset integer view \f$o\f$ for an integer view \f$x\f$ and
+     * an integer \f$c\f$ provides operations such that \f$o\f$
+     * behaves as \f$x+c\f$.
+     * \ingroup TaskActorIntView
+     */
+    class OffsetView : public DerivedViewBase<IntView> {
+    protected:
+      /// Offset
+      int c;
+      using DerivedViewBase<IntView>::view;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      OffsetView(void);
+      /// Initialize with integer view \a x and offset \a c
+      OffsetView(const IntView& x, int c);
+      /// Initialize with integer view \a x and offset \a c
+      void init(const IntView& x, int c);
+      /// Return offset
+      int offset(void) const;
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const;
+      /// Return maximum of domain
+      int max(void) const;
+      /// Return median of domain
+      int med(void) const;
+      /// Return assigned value (only if assigned)
+      int val(void) const;
+
+      /// Return size (cardinality) of domain
+      unsigned int size(void) const;
+      /// Return width of domain (distance between maximum and minimum)
+      unsigned int width(void) const;
+      /// Return regret of domain minimum (distance to next larger value)
+      unsigned int regret_min(void) const;
+      /// Return regret of domain maximum (distance to next smaller value)
+      unsigned int regret_max(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const;
+      /// Test whether view is assigned
+      bool assigned(void) const;
+
+      /// Test whether \a n is contained in domain
+      bool in(int n) const;
+      /// Test whether \a n is contained in domain
+      bool in(double n) const;
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, int n);
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, double n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, int n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, double n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, int n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, double n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, int n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, double n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, int n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, double n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, int n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, double n);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+      /// Replace domain by range sequence described by \a i
+      template <class I> ModEvent narrow(Space* home, I& i);
+      /// Intersect domain with range sequence described by \a i
+      template <class I> ModEvent inter(Space* home, I& i);
+      /// Remove from domain the range sequence described by \a i
+      template <class I> ModEvent minus(Space* home, I& i);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent me);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, OffsetView& x);
+      //@}
+    };
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Int::OffsetView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Int::OffsetView& x, const Int::OffsetView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Int::OffsetView& x, const Int::OffsetView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for OffsetView.
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::OffsetView> {
+  public:
+    /// The variable type of an OffsetView
+    typedef Int::IntVarImp Var;
+  };
+
+
+
+  namespace Int {
+
+    /**
+     * \brief Scale integer view (template)
+     *
+     * A scale integer view \f$s\f$ for an integer view \f$x\f$ and
+     * a non-negative integer \f$a\f$ provides operations such that \f$s\f$
+     * behaves as \f$a\cdot x\f$.
+     *
+     * The precision of a scale integer view is defined by the value types
+     * \a Val and \a UnsVal. \a Val can be either \c int or \c double where
+     * \a UnsVal must be the unsigned variant of \a Val (that is, if \a Val
+     * is \c int, then \a UnsVal must be \c unsigned \c int; if \a Val is
+     * \c double, then \a UnsVal must be \c double as well). The range which is
+     * allowed for the two types is defined by the values in
+     * Gecode::Limits.
+     *
+     * Note that scale integer views currently do not provide operations
+     * for updating domains by range iterators.
+     *
+     * The template is not to be used directly (as it is very clumsy). Use
+     * the following instead:
+     *  - IntScaleView for scale views with integer precision
+     *  - DoubleScaleView for scale views with double precision
+     *
+     * \ingroup TaskActorIntView
+     */
+    template <class Val, class UnsVal>
+    class ScaleView : public DerivedViewBase<IntView> {
+    protected:
+      /// Scale factor
+      int a;
+      using DerivedViewBase<IntView>::view;
+
+      /// \name Support functions for division
+      //@{
+      /// Return \f$\lfloor x/a\rfloor\f$
+      int floor_div(double x) const;
+      /// Return \f$\lceil x/a\rceil\f$
+      int ceil_div(double x) const;
+      /// Return \f$x/a\f$ and set \a exact to true if \a x is multiple of \a a
+      int exact_div(double x, bool& exact) const;
+#if GECODE_INT_RND_TWDS_ZERO
+      /// Return \f$\lfloor x/a\rfloor\f$
+      int floor_div(int) const;
+      /// Return \f$\lceil x/a\rceil\f$
+      int ceil_div(int) const;
+      /// Return \f$x/a\f$ and set \a exact to true if \a x is multiple of \a a
+      int exact_div(int, bool&) const;
+#endif
+      //@}
+
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ScaleView(void);
+      /// Initialize as \f$b\cdot y\f$
+      ScaleView(int b, const IntView& y);
+      /// Initialize as \f$b\cdot y\f$
+      void init(int b, const IntView& y);
+      /// Return scale factor of scale view
+      int scale(void) const;
+      //@}
+
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      Val min(void) const;
+      /// Return maximum of domain
+      Val max(void) const;
+      /// Return median of domain
+      Val med(void) const;
+      /// Return assigned value (only if assigned)
+      Val val(void) const;
+
+      /// Return size (cardinality) of domain
+      UnsVal size(void) const;
+      /// Return width of domain (distance between maximum and minimum)
+      UnsVal width(void) const;
+      /// Return regret of domain minimum (distance to next larger value)
+      UnsVal regret_min(void) const;
+      /// Return regret of domain maximum (distance to next smaller value)
+      UnsVal regret_max(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const;
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      /// Test whether \a n is contained in domain
+      bool in(Val n) const;
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, Val n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, Val n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, Val n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, Val n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, Val n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, Val n);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent me);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, ScaleView<Val,UnsVal>& x);
+      //@}
+    };
+
+    /**
+     * \brief Integer-precision integer scale view
+     * \ingroup TaskActorIntView
+     */
+    typedef ScaleView<int,unsigned int> IntScaleView;
+
+    /**
+     * \brief Double-precision integer scale view
+     * \ingroup TaskActorIntView
+     */
+    typedef ScaleView<double,double> DoubleScaleView;
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Int::ScaleView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  template <class Val, class UnsVal>
+  bool same(const Int::ScaleView<Val,UnsVal>& x,
+	    const Int::ScaleView<Val,UnsVal>& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  template <class Val, class UnsVal>
+  bool before(const Int::ScaleView<Val,UnsVal>& x,
+	      const Int::ScaleView<Val,UnsVal>& y);
+  //@}
+
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for ScaleView.
+   * \ingroup TaskActorIntView
+   */
+  template <class Val, class UnsVal>
+  class ViewVarTraits<Int::ScaleView<Val,UnsVal> > {
+  public:
+    /// The variable type of a ScaleView
+    typedef Int::IntVarImp Var;
+  };
+
+
+
+  namespace Int {
+
+    /**
+     * \brief Constant integer view
+     *
+     * An constant integer view \f$x\f$ for an integer \f$c\f$ provides
+     * operations such that \f$x\f$ behaves as a view assigned to \f$c\f$.
+     * \ingroup TaskActorIntView
+     */
+    class ConstIntView : public ConstantViewBase {
+    protected:
+      int x;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ConstIntView(void);
+      /// Initialize with integer value \a n
+      ConstIntView(int n);
+      /// Initialize with integer value \a n
+      void init(int n);
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const;
+      /// Return maximum of domain
+      int max(void) const;
+      /// Return median of domain
+      int med(void) const;
+      /// Return assigned value (only if assigned)
+      int val(void) const;
+
+      /// Return size (cardinality) of domain
+      unsigned int size(void) const;
+      /// Return width of domain (distance between maximum and minimum)
+      unsigned int width(void) const;
+      /// Return regret of domain minimum (distance to next larger value)
+      unsigned int regret_min(void) const;
+      /// Return regret of domain maximum (distance to next smaller value)
+      unsigned int regret_max(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether domain is a range
+      bool range(void) const;
+      /// Test whether view is assigned
+      bool assigned(void) const;
+
+      /// Test whether \a n is contained in domain
+      bool in(int n) const;
+      /// Test whether \a n is contained in domain
+      bool in(double n) const;
+      //@}
+
+      /// \name Domain update by value
+      //@{
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, int n);
+      /// Restrict domain values to be less or equal than \a n
+      ModEvent lq(Space* home, double n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, int n);
+      /// Restrict domain values to be less than \a n
+      ModEvent le(Space* home, double n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, int n);
+      /// Restrict domain values to be greater or equal than \a n
+      ModEvent gq(Space* home, double n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, int n);
+      /// Restrict domain values to be greater than \a n
+      ModEvent gr(Space* home, double n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, int n);
+      /// Restrict domain values to be different from \a n
+      ModEvent nq(Space* home, double n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, int n);
+      /// Restrict domain values to be equal to \a n
+      ModEvent eq(Space* home, double n);
+      //@}
+
+      /// \name Domain update by range iterator
+      //@{
+      /// Replace domain by range sequence described by \a i
+      template <class I> ModEvent narrow(Space* home, I& i);
+      /// Intersect domain with range sequence described by \a i
+      template <class I> ModEvent inter(Space* home, I& i);
+      /// Remove from domain the range sequence described by \a i
+      template <class I> ModEvent minus(Space* home, I& i);
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent me);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, ConstIntView& x);
+      //@}
+    };
+
+  }
+
+  /**
+   * \name View comparison
+   * \relates Gecode::Int::ConstIntView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Int::ConstIntView& x, const Int::ConstIntView& y);
+  /// Test whether view \a x is before \a y (arbitrary order)
+  template <class View, unsigned int n>
+  bool before(const Int::ConstIntView& x, const Int::ConstIntView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for ConstIntView.
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::ConstIntView> {
+  public:
+    /// The variable type of a ConstIntView
+    typedef VarBase Var;
+  };
+
+  namespace Int {
+
+    /**
+     * \brief Boolean view for integer variables
+     *
+     * Provides convenient and efficient operations for Boolean views.
+     * \ingroup TaskActorIntView
+     */
+    class BoolView : public IntView {
+      /// For initialization from IntVar (see below)
+      friend class ViewArray<BoolView>;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      BoolView(void);
+      /// Initialize from Boolean variable \a b
+      BoolView(const BoolVar& b);
+    private:
+      /** \brief Initialize from integer variable \a x
+       *
+       * This is odd, but is required to go from an VarArgArray to
+       * a ViewArray.
+       */
+      BoolView(const IntVar& b);
+    public:
+      /// Initialize from integer variable \a x
+      explicit BoolView(const IntView& x);
+      //@}
+
+      /// \name Boolean domain tests
+      //@{
+      /// Test whether view is assigned to be zero
+      bool zero(void) const;
+      /// Test whether view is assigned to be one
+      bool one(void) const;
+      /// Test whether view is not yet assigned
+      bool none(void) const;
+      //@}
+
+      /// \name Boolean assignment operations
+      //@{
+      /// Try to assign view to one
+      ModEvent t_one(Space* home);
+      /// Try to assign view to zero
+      ModEvent t_zero(Space* home);
+      /// Assign not yet assigned view to one
+      void t_one_none(Space* home);
+      /// Assign not yet assigned view to zero
+      void t_zero_none(Space* home);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, BoolView& x);
+      //@}
+    };
+
+  }
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for BoolView
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::BoolView> {
+  public:
+    /// The variable type of a BoolView
+    typedef Int::IntVarImp Var;
+  };
+
+  namespace Int {
+
+    /**
+     * \brief Negated Boolean view
+     *
+     * A negated Boolean view \f$n\f$ for a Boolean view \f$b\f$
+     * provides operations such that \f$n\f$
+     * behaves as \f$\neg b\f$.
+     * \ingroup TaskActorIntView
+     */
+    class NegBoolView : public DerivedViewBase<BoolView> {
+    protected:
+      using DerivedViewBase<BoolView>::view;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      NegBoolView(void);
+      /// Initialize with Boolean view \a b
+      NegBoolView(const BoolView& b);
+      /// Initialize with Boolean view \a b
+      void init(const BoolView& b);
+      //@}
+
+      /// \name Boolean domain tests
+      //@{
+      /// Test whether view is assigned to be zero
+      bool zero(void) const;
+      /// Test whether view is assigned to be one
+      bool one(void) const;
+      /// Test whether view is not yet assigned
+      bool none(void) const;
+      //@}
+
+      /// \name Boolean assignment operations
+      //@{
+      /// Try to assign view to one
+      ModEvent t_one(Space* home);
+      /// Try to assign view to zero
+      ModEvent t_zero(Space* home);
+      /// Assign not yet assigned view to one
+      void t_one_none(Space* home);
+      /// Assign not yet assigned view to zero
+      void t_zero_none(Space* home);
+      //@}
+
+      /// \name Value access
+      //@{
+      /// Return minimum of domain
+      int min(void) const;
+      /// Return maximum of domain
+      int max(void) const;
+      /// Return assigned value (only if assigned)
+      int val(void) const;
+      //@}
+
+      /// \name Domain tests
+      //@{
+      /// Test whether view is assigned
+      bool assigned(void) const;
+      //@}
+
+      /// \name Propagator modification events
+      //@{
+      /// Return modification event of propagator \a p for view
+      static ModEvent     pme(const Propagator* p);
+      /// Translate modification event \a me to propagator modification event for view
+      static PropModEvent pme(ModEvent me);
+      //@}
+
+      /// \name Dependencies
+      //@{
+      /**
+       * \brief Subscribe propagator \a p with propagation condition \a pc to variable
+       *
+       * In case \a process is false, the propagator is just subscribed but
+       * not processed for execution (this must be used when creating
+       * subscriptions during propagation).
+       */
+      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
+      /// Cancel subscription of propagator \a p with propagation condition \a pc to view
+      void cancel(Space* home, Propagator* p, PropCond pc);
+      //@}
+
+      /// \name Cloning
+      //@{
+      /// Update this view to be a clone of view \a x
+      void update(Space* home, bool share, NegBoolView& x);
+      //@}
+    };
+
+    /**
+     * \brief Boolean tests
+     *
+     */
+    enum BoolTest {
+      BT_NONE, ///< No sharing
+      BT_SAME, ///< Same variable
+      BT_COMP  ///< Same variable but complement
+    };
+
+    /**
+     * \name Test sharing between Boolean and negated Boolean views
+     * \relates BoolView NegBoolView
+     */
+    //@{
+    /// Test whether views \a b0 and \a b1 are the same
+    BoolTest bool_test(const BoolView& b0, const BoolView& b1);
+    /// Test whether views \a b0 and \a b1 are complementary
+    BoolTest bool_test(const BoolView& b0, const NegBoolView& b1);
+    /// Test whether views \a b0 and \a b1 are complementary
+    BoolTest bool_test(const NegBoolView& b0, const BoolView& b1);
+    /// Test whether views \a b0 and \a b1 are the same
+    BoolTest bool_test(const NegBoolView& b0, const NegBoolView& b1);
+    //@}
+
+  }
+
+  /** \name View comparison
+   *  \relates Gecode::Int::NegBoolView
+   */
+  //@{
+  /// Test whether views \a x and \a y are the same
+  bool same(const Int::NegBoolView& x, const Int::NegBoolView& y);
+  /// Test whether view \a x comes before \a y (arbitrary order)
+  bool before(const Int::NegBoolView& x, const Int::NegBoolView& y);
+  //@}
+
+  /**
+   * \brief Traits class for views and variable implementations
+   *
+   * This class specializes the ViewVarTraits for NegBoolView.
+   * \ingroup TaskActorIntView
+   */
+  template<>
+  class ViewVarTraits<Int::NegBoolView> {
+  public:
+    /// The variable type of a NegBoolView
+    typedef Int::IntVarImp Var;
+  };
+
+}
+
+#include "gecode/int/var/int.icc"
+#include "gecode/int/var/bool.icc"
+
+#include "gecode/int/view/int.icc"
+#include "gecode/int/view/bool.icc"
+
+#include "gecode/int/view/constint.icc"
+
+#include "gecode/int/view/minus.icc"
+#include "gecode/int/view/offset.icc"
+#include "gecode/int/view/scale.icc"
+
+/**
+ * \brief Print integer variable view
+ * \relates Gecode::Int::IntView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::IntView&);
+/**
+ * \brief Print minus integer view
+ * \relates Gecode::Int::MinusView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::MinusView&);
+/**
+ * \brief Print offset integer view
+ * \relates Gecode::Int::OffsetView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::OffsetView&);
+/**
+ * \brief Print constant integer view
+ * \relates Gecode::Int::ConstIntView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::ConstIntView&);
+/**
+ * \brief Print integer-precision scale integer view
+ * \relates Gecode::Int::ScaleView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::IntScaleView&);
+/**
+ * \brief Print double-precision scale integer view
+ * \relates Gecode::Int::ScaleView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::DoubleScaleView&);
+/**
+ * \brief Print negated Boolean view
+ * \relates Gecode::Int::NegBoolView
+ */
+GECODE_INT_EXPORT std::ostream&
+operator<<(std::ostream&, const Gecode::Int::NegBoolView&);
+
+
+inline std::ostream&
+operator<<(std::ostream& os, const Gecode::IntVar& x) {
+  Gecode::Int::IntView vx(x);
+  return os << vx;
+}
+
+namespace Gecode {
+
+  namespace Int {
+
+    /**
+     * \defgroup TaskActorIntTest Testing relations between integer views
+     * \ingroup TaskActorInt
+     */
+
+    //@{
+    /// Result of testing relation
+    enum RelTest {
+      RT_FALSE = 0, ///< Relation does not hold
+      RT_MAYBE = 1, ///< Relation may hold or not
+      RT_TRUE  = 2   ///< Relation does hold
+    };
+
+    /// Test whether views \a x and \a y are equal (use bounds information)
+    template <class View> RelTest rtest_eq_bnd(View x, View y);
+    /// Test whether views \a x and \a y are equal (use full domain information)
+    template <class View> RelTest rtest_eq_dom(View x, View y);
+    /// Test whether view \a x and integer \a n are equal (use bounds information)
+    template <class View> RelTest rtest_eq_bnd(View x, int n);
+    /// Test whether view \a x and integer \a n are equal (use full domain information)
+    template <class View> RelTest rtest_eq_dom(View x, int n);
+
+    /// Test whether views \a x and \a y are different (use bounds information)
+    template <class View> RelTest rtest_nq_bnd(View x, View y);
+    /// Test whether views \a x and \a y are different (use full domain information)
+    template <class View> RelTest rtest_nq_dom(View x, View y);
+    /// Test whether view \a x and integer \a n are different (use bounds information)
+    template <class View> RelTest rtest_nq_bnd(View x, int n);
+    /// Test whether view \a x and integer \a n are different (use full domain information)
+    template <class View> RelTest rtest_nq_dom(View x, int n);
+
+    /// Test whether view \a x is less or equal than view \a y
+    template <class View> RelTest rtest_lq(View x, View y);
+    /// Test whether view \a x is less or equal than integer \a n
+    template <class View> RelTest rtest_lq(View x, int n);
+
+    /// Test whether view \a x is less than view \a y
+    template <class View> RelTest rtest_le(View x, View y);
+    /// Test whether view \a x is less than integer \a n
+    template <class View> RelTest rtest_le(View x, int n);
+
+    /// Test whether view \a x is greater or equal than view \a y
+    template <class View> RelTest rtest_gq(View x, View y);
+    /// Test whether view \a x is greater or equal than integer \a n
+    template <class View> RelTest rtest_gq(View x, int n);
+
+    /// Test whether view \a x is greater than view \a y
+    template <class View> RelTest rtest_gr(View x, View y);
+    /// Test whether view \a x is greater than integer \a n
+    template <class View> RelTest rtest_gr(View x, int n);
+    //@}
+
+  }
+
+}
+
+#include "gecode/int/view/rtest.icc"
+
+// STATISTICS: int-var