gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/var-imp.vis

@@ -0,0 +1,198 @@
+#
+#  Main authors:
+#     Christian Schulte <schulte@gecode.org>
+#
+#  Copyright:
+#     Christian Schulte, 2006
+#
+#  Last modified:
+#     $Date: 2006-07-28 16:27:48 +0200 (Fri, 28 Jul 2006) $ by $Author: tack $
+#     $Revision: 3477 $
+#
+#  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.
+#
+
+##
+## Header of file to be generated
+##
+[Header]
+
+namespace Gecode { namespace Int {
+
+##
+## General settings
+##
+## Defines the name (Name) and the variable type identifier (VTI) of the
+## variable implementation to be generated.
+##
+## Export defines whether a special macro to be added in front
+## of a definition that needs external linkage (can be omitted)
+##
+## Forceinline defines whether a special macro for inlining should
+## be used. If it is omitted, inline will be used instead.
+##
+## Forcedispose defines whether this variable type provides a dispose
+## function that must be called for all variables in a space when the
+## space is destroyed. If it is omitted, false is assumed.
+[General]
+Name:		Int
+VTI:		INT
+Export:		GECODE_INT_EXPORT
+Forceinline:	forceinline
+
+##
+## Definition of modification events
+##
+##
+## ModEventHeader: give some text that precedes the definition
+## of the modification events.
+##
+## ModEventFooter: give some text that comes after the definition
+## of the modification events.
+##
+## ModEvent: defines a modification event
+## The definition must always contain a Name line, either in the form
+##	Name: <name>
+## or
+##	Name: <name> = <special>
+## where <special> must be one of
+##  - FAILED: this is the modification event used when an operation
+##    resulted in failure.
+##  - NONE: this is the modification event used when an operation
+##    does nothing.
+##  - ASSIGNED: when the operation assigned the variable.
+##  - SUBSCRIBE: when a propagator subscribes to a variable, the
+##    propagator will be processed with that event initially.
+##
+## Note that at least the special cases "FAILED", "NONE", and "ASSIGNED"
+## must be present. In case there are more events defined, then also
+## "SUBSCRIBE" must be present.
+##
+## Additionally, for all modfication events but the special cases
+## "FAILED" and "NONE" one needs to define the combination of
+## modification events by
+##	Combine: <me1>=<me2>, ... (repeated)
+## This means that the combination of the currently defined
+## modification event together with <me1> results in <me2>.
+##
+[ModEventHeader]
+  /**
+   * \defgroup TaskActorIntMEPC Integer modification events and propagation conditions
+   * \ingroup TaskActorInt
+   */
+  
+  //@{
+[ModEvent]
+Name:		FAILED=FAILED
+  /// Domain operation has resulted in failure
+[ModEvent]
+Name:		NONE=NONE
+  /// Domain operation has not changed domain
+[ModEvent]
+Name:		VAL=ASSIGNED
+Combine:	VAL=VAL, BND=VAL, DOM=VAL
+  /// Domain operation has resulted in a value (assigned variable)
+[ModEvent]
+Name:		BND=SUBSCRIBE
+Combine:	VAL=VAL, BND=BND, DOM=BND
+  /** 
+   * \brief Domain operation has changed the minimum or maximum of the domain
+   *
+   * Note that this implies that the domain has not resulted in a value.
+   *
+   * If a propagator subscribes to this variable, it will be processed
+   * assuming a ME_INT_BND modification event.
+   */
+[ModEvent]
+Name:		DOM
+Combine:	VAL=VAL, BND=BND, DOM=DOM
+  /** 
+   * \brief Domain operation has changed the domain
+   *
+   * Note that this implies that the domain has not resulted in a value
+   * and that also the minimum and maximum of the domain have not changed.
+   */
+# [ModEventFooter]: Nothing
+
+
+##
+## Definition of propagation conditions
+##
+##
+## PropCondHeader: give some text that precedes the definition
+## of the propagation conditions. One can rely on the fact that
+## the definitions of the propgation conditions come immediately
+## after the definitions of the modification events.
+##
+## PropCondFooter: give some text that comes after the definition
+## of the propagation conditions.
+##
+## PropCond: defines a propagation condition
+## The definition must always contain a Name line, either in the form
+##	Name: <name>
+## or
+##	Name: <name> = <special>
+## where <special> must be
+##  - ASSIGNED: the condition corresponding to executing a
+##    propagator when a variable becomes assigned.
+##
+## Note that this special case must be present!
+##
+## Additionally, for all propagation conditions one must define
+## the modification events that trigger execution of a propagator
+## with the defined propagation condition. This is done by:
+##	ModEvents: <me>, ... (repeeated)
+##
+# [PropCondHeader]: Nothing
+[PropCond]
+Name:		VAL=ASSIGNED
+ModEvents:	VAL
+  /**
+   * \brief Propagate when a view becomes assigned (single value)
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_INT_VAL, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_INT_VAL.
+   */
+[PropCond]
+Name:		BND
+ModEvents:	VAL, BND
+  /**
+   * \brief Propagate when minimum or maximum of a view changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_INT_BND, then \a p is propagated when a domain
+   * update operation on \a x returns the modification events ME_INT_VAL
+   * or ME_INT_BND.
+   */
+[PropCond]
+Name:		DOM
+ModEvents:	VAL, BND, DOM
+  /**
+   * \brief Propagate when domain changes
+   *
+   * If a propagator \a p depends on a view \a x with propagation
+   * condition PC_INT_DOM, then \a p is propagated when a domain
+   * update operation on \a x returns the modification event ME_INT_VAL,
+   * ME_INT_BND, or ME_INT_DOM.
+   */
+[PropCondFooter]
+  //@}
+##
+## Footer of file to be generated
+##
+[Footer]
+
+}}
+
+// STATISTICS: int-var
+##
+## At the end of the file there must be an [End] section.
+##
+[End]

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

@@ -0,0 +1,590 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  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.
+ *
+ */
+
+#include <cmath>
+
+#include "gecode/int/var/imp-hdr.icc"
+
+namespace Gecode { namespace Int {
+
+  class IntVarImpFwd;
+  class IntVarImpBwd;
+
+  /**
+   * \brief Integer variable implementation
+   *
+   * \ingroup Other
+   */
+  class IntVarImp : public IntVarImpBase {
+    friend class IntVarImpFwd;
+    friend class IntVarImpBwd;
+  protected:
+    /**
+     * \brief Lists of ranges (intervals)
+     *
+     * Range lists are doubly-linked storing the pointer to both
+     * the next and the previous element in a single pointer.
+     * That means that the next element is only available when
+     * the previous element is supplied as additional information.
+     * The same holds true for access to the previous element.
+     */
+    class RangeList : public FreeList {
+    protected:
+      /// Minimum of range
+      int _min;
+      /// Maximum of range
+      int _max;
+    public:
+      /// \name Constructors
+      //@{
+      /// Default constructor (noop)
+      RangeList(void);
+      /// Initialize with minimum \a min and maximum \a max
+      RangeList(int min, int max);
+      /// Initialize with minimum \a min and maximum \a max and predecessor \a p and successor \a n
+      RangeList(int min, int max, RangeList* p, RangeList* n);
+      //@}
+
+      /// \name Access
+      //@{
+      /// Return minimum
+      int min(void) const;
+      /// Return maximum
+      int max(void) const;
+      /// Return width (distance between maximum and minimum)
+      unsigned int width(void) const;
+
+      /// Return next element (from previous \a p)
+      RangeList* next(const RangeList* p) const;
+      /// Return previous element (from next \a n)
+      RangeList* prev(const RangeList* n) const;
+      //@}
+
+      /// \name Update
+      //@{
+      /// Set minimum to \a n
+      void min(int n);
+      /// Set maximum to \a n
+      void max(int n);
+
+      /// Set previous element to \a p and next element to \a n
+      void prevnext(RangeList* p, RangeList* n);
+      /// Set next element from \a o to \a n
+      void next(RangeList* o, RangeList* n);
+      /// Set previous element from \a o to \a n
+      void prev(RangeList* o, RangeList* n);
+      /// Restore simple link to next element (so that it becomes a true free list)
+      void fix(RangeList* n);
+      //@}
+
+      /// \name Memory management
+      //@{
+      /**
+       * \brief Free memory for all elements between this and \a l (inclusive)
+       *
+       * \a p must be the pointer to the previous element of \c this.
+       */
+      void dispose(Space* home, RangeList* p, RangeList* l);
+      /**
+       * \brief Free memory for all elements between this and \a l (inclusive)
+       *
+       * This routine assumes that the list has already been fixed.
+       */
+      void dispose(Space* home, RangeList* l);
+      /// Free memory for this element
+      void dispose(Space* home);
+
+      /// Allocate memory from space
+      static void* operator new(size_t s, Space* home);
+      /// No-op (for exceptions)
+      static void  operator delete(void*);
+      /// No-op (use dispose instead)
+      static void  operator delete(void*, Space*);
+      //@}
+    };
+
+    /**
+     * \brief Domain information
+     *
+     * Provides fast access to minimum and maximum of the
+     * entire domain and links to the first element
+     * of a RangeList defining the domain.
+     */
+    RangeList dom;
+    /// Link the last element
+    RangeList* _lst;
+    /// Return first element of rangelist
+    RangeList* fst(void) const;
+    /// Set first element of rangelist
+    void fst(RangeList* f);
+    /// Return last element of rangelist
+    RangeList* lst(void) const;
+    /// Set last element of rangelist
+    void lst(RangeList* l);
+    /// Size of holes in the domain
+    unsigned int holes;
+
+  protected:
+    /// Constructor for cloning \a x (\a is_bool whether this is a Boolean variable)
+    IntVarImp(Space* home, bool share, IntVarImp& x, bool is_bool);
+  public:
+    /// Initialize with range domain
+    IntVarImp(Space* home, int min, int max);
+    /// Initialize with domain specified by \a d
+    IntVarImp(Space* home, const IntSet& d);
+
+    /// \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;
+    /// Return median of domain
+    GECODE_INT_EXPORT int med(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;
+    //@}
+
+  private:
+    /// Test whether \a n is contained in domain (full domain)
+    GECODE_INT_EXPORT bool in_full(int n) const;
+
+  public:
+    /// \name Domain tests
+    //@{
+    /// Test whether domain is a range
+    bool range(void) const;
+    /// Test whether variable 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;
+    //@}
+
+  protected:
+    /// \name Range list access for iteration
+    //@{
+    /// Return range list for forward iteration
+    const RangeList* ranges_fwd(void) const;
+    /// Return range list for backward iteration
+    const RangeList* ranges_bwd(void) const;
+    //@}
+
+  private:
+    /// Test whether \a n is closer to the minimum or maximum
+    bool closer_min(int b) const;
+    /// \name Domain update by value (full domain)
+    //@{
+    /// Restrict domain values to be less or equal than \a n
+    GECODE_INT_EXPORT void lq_full(Space* home, int n);
+    /// Restrict domain values to be greater or equal than \a n
+    GECODE_INT_EXPORT void gq_full(Space* home, int n);
+    /// Restrict domain values to be equal to \a n
+    GECODE_INT_EXPORT void eq_full(Space* home, int n);
+    /// Restrict domain values to be different from \a n
+    GECODE_INT_EXPORT ModEvent nq_full(Space* home, int n);
+    //@}
+  public:
+    /// \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 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 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 Boolean update operations
+    //@{
+    /// Assign unassigned variable to zero
+    void t_zero_none(Space* home);
+    /// Assign unassigned variable to one
+    void t_one_none(Space* home);
+    //@}
+
+  public:
+    /// \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);
+    //@}
+
+  private:
+    /// Return copy of not-yet copied variable
+    GECODE_INT_EXPORT IntVarImp* perform_copy(Space* home, bool share);
+    /// Return copy of not-yet copied variable (Boolean)
+    GECODE_INT_EXPORT IntVarImp* perform_copy_bool(Space* home, bool share);
+  public:
+    /// \name Cloning
+    //@{
+    /// Return copy of this variable
+    IntVarImp* copy(Space* home, bool share);
+    /// Return copy of this variable (Boolean)
+    IntVarImp* copy_bool(Space* home, bool share);
+    //@}
+  };
+
+
+  /**
+   * \brief Range iterator for ranges of integer variable implementation
+   *
+   */
+  class IntVarImpFwd {
+  private:
+    /// Previous range
+    const IntVarImp::RangeList* p;
+    /// Current range
+    const IntVarImp::RangeList* c;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    IntVarImpFwd(void);
+    /// Initialize with ranges from variable implementation \a x
+    IntVarImpFwd(const IntVarImp* x);
+    /// Initialize with ranges from variable implementation \a x
+    void init(const IntVarImp* 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 Backward iterator for ranges of integer variable implementations
+   *
+   * Note that this iterator is not a range iterator as the ranges
+   * are not iterated in increasing but in decreasing order.
+   *
+   */
+  class IntVarImpBwd {
+  private:
+    /// Next range
+    const IntVarImp::RangeList* n;
+    /// Current range
+    const IntVarImp::RangeList* c;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    IntVarImpBwd(void);
+    /// Initialize with ranges from variable implementation \a x
+    IntVarImpBwd(const IntVarImp* x);
+    /// Initialize with ranges from variable implementation \a x
+    void init(const IntVarImp* x);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Test whether iterator is still at a range or done
+    bool operator()(void) const;
+    /// Move iterator to previous 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;
+    //@}
+  };
+
+
+  class IntView;
+  class BoolView;
+
+}}
+
+#include "gecode/int/var/imp.icc"
+
+
+namespace Gecode {
+
+  /**
+   * \brief Integer variables
+   *
+   * \ingroup TaskIntIntVars
+   */
+  class IntVar {
+  protected:
+    /// Integer variable implementation used
+    Int::IntVarImp* var;
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    IntVar(void);
+    /// Initialize from integer variable \a x
+    IntVar(const IntVar& x);
+    /// Initialize from integer view \a x
+    IntVar(const Int::IntView& x);
+    /**
+     * \brief Initialize variable with range domain
+     *
+     * The variable is created with a domain ranging from \a min
+     * to \a max. The following exceptions might be thrown:
+     *  - If \a min is greater than \a max, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a min or \a max exceed the limits for integers as defined
+     *    in Gecode::Limits::Int, an exception of type
+     *    Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    GECODE_INT_EXPORT IntVar(Space* home, int min ,int max);
+    /**
+     * \brief Initialize variable with arbitrary domain
+     *
+     * The variable is created with a domain described by \a d.
+     * The following exceptions might be thrown:
+     *  - If \a d is empty, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a d contains values that exceed the limits for integers
+     *    as defined in Gecode::Limits::Int, an exception of type
+     *    Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    GECODE_INT_EXPORT IntVar(Space* home, const IntSet& d);
+    /**
+     * \brief Initialize variable with range domain
+     *
+     * The variable is created with a domain ranging from \a min
+     * to \a max. The following exceptions might be thrown:
+     *  - If \a min is greater than \a max, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a min or \a max exceed the limits for integers as defined
+     *    in Gecode::Limits::Int, an exception of type
+     *    Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    GECODE_INT_EXPORT void init(Space* home, int min, int max);
+    /**
+     * \brief Initialize variable with arbitrary domain
+     *
+     * The variable is created with a domain described by \a d.
+     * The following exceptions might be thrown:
+     *  - If \a d is empty, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a d contains values that exceed the limits for integers
+     *    as defined in Gecode::Limits::Int, an exception of type
+     *    Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    GECODE_INT_EXPORT void init(Space* home, const IntSet& d);
+    //@}
+
+    /// \name Variable implementation access
+    //@{
+    /// Return integer variable implementation
+    Int::IntVarImp* variable(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 degree (number of subscribed propagators)
+    unsigned int degree(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;
+    //@}
+
+    /// \name Cloning
+    //@{
+    /// Update this variable to be a clone of variable \a x
+    void update(Space* home, bool share, IntVar& x);
+    //@}
+  };
+
+
+  /**
+   * \brief %Range iterator for integer variables
+   * \ingroup TaskIntIntVars
+   */
+  class IntVarRanges : public Int::IntVarImpFwd {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    IntVarRanges(void);
+    /// Initialize with ranges for integer variable \a x
+    IntVarRanges(const IntVar& x);
+    /// Initialize with ranges for integer variable \a x
+    void init(const IntVar& x);
+    //@}
+  };
+
+  /**
+   * \brief Value iterator for integer variables
+   * \ingroup TaskIntIntVars
+   */
+  class IntVarValues
+    : public Iter::Ranges::ToValues<IntVarRanges> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    IntVarValues(void);
+    /// Initialize with values for \a x
+    IntVarValues(const IntVar& x);
+    /// Initialize with values \a x
+    void init(const IntVar& x);
+    //@}
+  };
+
+  /**
+   * \brief Boolean integer variables
+   *
+   * \ingroup TaskIntIntVars
+   */
+  class BoolVar : public IntVar {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    BoolVar(void);
+    /// Initialize from Boolean View \a x
+    BoolVar(const Int::BoolView& x);
+    /**
+     * \brief Initialize Boolean variable with range domain
+     *
+     * The variable is created with a domain ranging from \a min
+     * to \a max. The following exceptions might be thrown:
+     *  - If \a min is greater than \a max, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a min is less than 0 or \a max is greater than 1,
+     *    an exception of type
+     *    Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    BoolVar(Space* home, int min, int max);
+    /**
+     * \brief Initialize Boolean variable from integer variable
+     *
+     * If \a x.min() is less than 0 or \a x.max() is greater than 1,
+     * an exception of type Gecode::Int::VariableOutOfDomain is thrown.
+     */
+    explicit BoolVar(const IntVar& x);
+    //@}
+
+    /// \name Cloning
+    //@{
+    /// Update this variable to be a clone of variable \a x
+    void update(Space* home, bool share, BoolVar& x);
+    //@}
+  };
+
+}
+
+/**
+ * \brief Print integer variable \a x
+ * \relates Gecode::IntVar
+ */
+std::ostream&
+operator<<(std::ostream&, const Gecode::IntVar& x);
+
+/*
+ * For initialization, IntVar and IntView are mutually dependent.
+ * Therefore, the inclusion of the variable definition is in view.hh
+ *
+ */
+
+// STATISTICS: int-var
+