gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,61 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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 {
+
+  IntVarArray::IntVarArray(Space* home, int n, int min, int max)
+    : VarArray<IntVar>(home,n) {
+    if ((min < Limits::Int::int_min) || (max > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVarArray");
+    if (min > max)
+      throw Int::VariableEmptyDomain("IntVarArray");
+    for (int i = size(); i--; )
+      x[i].init(home,min,max);
+  }
+
+  IntVarArray::IntVarArray(Space* home, int n, const IntSet& s)
+    : VarArray<IntVar>(home,n) {
+    if ((s.min() < Limits::Int::int_min) || (s.max() > Limits::Int::int_max))
+      throw Int::VariableOutOfRangeDomain("IntVarArray");
+    if (s.size() == 0)
+      throw Int::VariableEmptyDomain("IntVarArray");
+    for (int i = size(); i--; )
+      x[i].init(home,s);
+  }
+
+  BoolVarArray::BoolVarArray(Space* home, int n, int min, int max)
+    : IntVarArray(home, n) {
+    if ((min < 0) || (max > 1))
+      throw Int::VariableOutOfRangeDomain("BoolVarArray");
+    if (min > max)
+      throw Int::VariableEmptyDomain("BoolVarArray");
+    for (int i = size(); i--; )
+      x[i].init(home,min,max);
+  }
+
+
+}
+
+
+// STATISTICS: int-post
+

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

@@ -0,0 +1,264 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 {
+
+  // Forward declaration.
+  class BoolVarArray;
+
+  /**
+   * \defgroup TaskIntIntArgs Argument arrays
+   *
+   * Argument arrays are just good enough for passing arguments
+   * with automatic memory management.
+   * \ingroup TaskIntInt
+   */
+
+  //@{
+  /// Passing integer arguments
+  typedef PrimArgArray<int>    IntArgs;
+  /// Passing integer variables
+  typedef VarArgArray<IntVar>  IntVarArgs;
+  /// Passing Boolean variables
+  class BoolVarArgs : public IntVarArgs {
+  public:
+    /// \name Creation and initialization
+    //@{
+    /// Allocate argument array for \a n Boolean variables
+    BoolVarArgs(int n);
+    /// Initialize from Boolean variable array \a a (copy elements)
+    BoolVarArgs(const BoolVarArgs& a);
+    /// Initialize from Boolean variable array \a a (copy elements)
+    explicit BoolVarArgs(const BoolVarArray& a);
+    //@}
+
+    /// \name Array elements
+    //@{
+    /// Return variable at position \a i
+    BoolVar& operator[](int i);
+    /// Return variable at position \a i
+    const BoolVar& operator[](int i) const;
+    //@}
+  };
+
+  //@}
+
+  /**
+   * \defgroup TaskIntIntVarArrays Variable arrays
+   *
+   * Variable arrays can store variables. They are typically used
+   * for storing the variables being part of a solution (script). However,
+   * they can also be used for temporary purposes (even though
+   * memory is not reclaimed until the space it is created for
+   * is deleted).
+   * \ingroup TaskIntInt
+   */
+
+  /**
+   * \brief Integer variable array
+   * \ingroup TaskIntIntVarArrays
+   */
+  class IntVarArray : public VarArray<IntVar> {
+  public:
+    /// \name Creation and initialization
+    //@{
+    /// Default constructor (array of size 0)
+    IntVarArray(void);
+    /// Allocate array for \a n integer variables (variables are uninitialized)
+    IntVarArray(Space* home, int n);
+    /// Initialize from integer variable array \a a (share elements)
+    IntVarArray(const IntVarArray& a);
+    /**
+     * \brief Initialize array with \a n new variables
+     *
+     * The variables are created with a domain ranging from \a min
+     * to \a max. The following execptions 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
+    IntVarArray(Space* home, int n, int min, int max);
+    /**
+     * \brief Initialize array with \a n new variables
+     *
+     * The variables are created with a domain described by \a s.
+     * The following execptions might be thrown:
+     *  - If \a s is empty, an exception of type
+     *    Gecode::Int::VariableEmptyDomain is thrown.
+     *  - If \a s 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
+    IntVarArray(Space* home, int n, const IntSet& s);
+    //@}
+  };
+  /**
+   * \brief Boolean variable array
+   * \ingroup TaskIntIntVarArrays
+   */
+  class BoolVarArray : public IntVarArray {
+  public:
+    /// \name Creation and initialization
+    //@{
+    /// Default constructor (array of size 0)
+    BoolVarArray(void);
+    /// Allocate array for \a n Boolean variables (variables are uninitialized)
+    BoolVarArray(Space* home, int n);
+    /// Initialize from Boolean variable array \a a (share elements)
+    BoolVarArray(const BoolVarArray& a);
+    /**
+     * \brief Initialize array with \a n new variables
+     *
+     * The variables are created with a domain ranging from \a min
+     * to \a max. The following execptions 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.
+     */
+    GECODE_INT_EXPORT
+    BoolVarArray(Space* home, int n, int min, int max);
+    //@}
+
+    /// \name Array elements
+    //@{
+    /// Return variable at position \a i
+    BoolVar& operator[](int i);
+    /// Return variable at position \a i
+    const BoolVar& operator[](int i) const;
+    //@}
+  };
+
+  /// Traits of IntVarArray
+  template <>
+  class ArrayTraits<IntVarArray> {
+  public:
+    typedef IntVarArgs   storage_type;
+    typedef IntVar       value_type;
+    typedef IntVarArgs   args_type;
+  };
+  /// Traits of IntVarArgs
+  template <>
+  class ArrayTraits<IntVarArgs> {
+  public:
+    typedef IntVarArgs storage_type;
+    typedef IntVar     value_type;
+    typedef IntVarArgs args_type;
+  };
+  /// Traits of IntArgs
+  template <>
+  class ArrayTraits<IntArgs> {
+  public:
+    typedef IntArgs storage_type;
+    typedef int     value_type;
+    typedef IntArgs args_type;
+  };
+  /// Traits of BoolVarArray
+  template <>
+  class ArrayTraits<BoolVarArray> {
+  public:
+    typedef BoolVarArgs   storage_type;
+    typedef BoolVar       value_type;
+    typedef BoolVarArgs   args_type;
+  };
+  /// Traits of BoolVarArgs
+  template <>
+  class ArrayTraits<BoolVarArgs> {
+  public:
+    typedef BoolVarArgs storage_type;
+    typedef BoolVar     value_type;
+    typedef BoolVarArgs args_type;
+  };
+
+  /*
+   * Implementation
+   *
+   */
+
+  forceinline
+  BoolVarArgs::BoolVarArgs(const BoolVarArgs& a)
+    : IntVarArgs(a) {}
+
+  forceinline
+  BoolVarArgs::BoolVarArgs(const BoolVarArray& a)
+    : IntVarArgs(a) {}
+
+  forceinline
+  BoolVarArgs::BoolVarArgs(int n)
+    : IntVarArgs(n) {}
+
+
+  forceinline BoolVar&
+  BoolVarArgs::operator[](int i) {
+    BoolVar* b = static_cast<BoolVar*>(&a[i]);
+    return *b;
+  }
+
+  forceinline const BoolVar&
+  BoolVarArgs::operator[](int i) const {
+    const BoolVar* b = static_cast<BoolVar*>(&a[i]);
+    return *b;
+  }
+
+  forceinline
+  IntVarArray::IntVarArray(void) {}
+
+  forceinline
+  IntVarArray::IntVarArray(Space* home, int n)
+    : VarArray<IntVar>(home,n) {}
+
+  forceinline
+  IntVarArray::IntVarArray(const IntVarArray& a)
+    : VarArray<IntVar>(a) {}
+
+
+  forceinline
+  BoolVarArray::BoolVarArray(void) {}
+
+  forceinline
+  BoolVarArray::BoolVarArray(const BoolVarArray& a)
+    : IntVarArray(a) {}
+
+  forceinline
+  BoolVarArray::BoolVarArray(Space* home, int n)
+    : IntVarArray(home,n) {}
+
+
+  forceinline BoolVar&
+  BoolVarArray::operator[](int i) {
+    BoolVar* b = static_cast<BoolVar*>(&x[i]);
+    return *b;
+  }
+
+  forceinline const BoolVar&
+  BoolVarArray::operator[](int i) const {
+    const BoolVar* b = static_cast<BoolVar*>(&x[i]);
+    return *b;
+  }
+
+}
+
+// STATISTICS: int-other

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

@@ -0,0 +1,187 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-07-17 11:15:04 +0200 (Mon, 17 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3367 $
+ *
+ *  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/bool.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  bool_not(Space* home, BoolVar b0, BoolVar b1, IntConLevel) {
+    if (home->failed()) return;
+    NegBoolView n0(b0);
+    GECODE_ES_FAIL(home,(Bool::Eq<NegBoolView,BoolView>::post(home,n0,b1)));
+  }
+
+  void
+  bool_eq(Space* home, BoolVar b0, BoolVar b1, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,(Bool::Eq<BoolView,BoolView>::post(home,b0,b1)));
+  }
+
+  void
+  bool_and(Space* home, BoolVar b0, BoolVar b1, BoolVar b2, IntConLevel) {
+    if (home->failed()) return;
+    NegBoolView n0(b0); NegBoolView n1(b1); NegBoolView n2(b2);
+    GECODE_ES_FAIL(home,(Bool::Or<NegBoolView,NegBoolView,NegBoolView>
+			 ::post(home,n0,n1,n2)));
+  }
+  void
+  bool_and(Space* home, BoolVar b0, BoolVar b1, bool b2, IntConLevel) {
+    if (home->failed()) return;
+    if (b2) {
+      BoolView bv0(b0); BoolView bv1(b1);
+      GECODE_ME_FAIL(home,bv0.t_one(home));
+      GECODE_ME_FAIL(home,bv1.t_one(home));
+    } else {
+      NegBoolView n0(b0); NegBoolView n1(b1);
+      GECODE_ES_FAIL(home,(Bool::OrTrue<NegBoolView,NegBoolView>
+			   ::post(home,n0,n1)));
+    }
+  }
+  void
+  bool_and(Space* home, const BoolVarArgs& b, BoolVar c, IntConLevel) {
+    if (home->failed()) return;
+    ViewArray<NegBoolView> x(home,b.size());
+    for (int i=b.size(); i--; ) {
+      NegBoolView nb(b[i]); x[i]=nb;
+    }
+    NegBoolView nc(c);
+    GECODE_ES_FAIL(home,Bool::NaryOr<NegBoolView>::post(home,x,nc));
+  }
+  void
+  bool_and(Space* home, const BoolVarArgs& b, bool c, IntConLevel) {
+    if (home->failed()) return;
+    if (c) {
+      for (int i=b.size(); i--; ) {
+	BoolView bvi(b[i]); GECODE_ME_FAIL(home,bvi.t_one(home));
+      }
+    } else {
+      ViewArray<NegBoolView> x(home,b.size());
+      for (int i=b.size(); i--; ) {
+	NegBoolView nb(b[i]); x[i]=nb;
+      }
+      GECODE_ES_FAIL(home,Bool::NaryOrTrue<NegBoolView>::post(home,x));
+    }
+  }
+
+  void
+  bool_or(Space* home, BoolVar b0, BoolVar b1, BoolVar b2, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,
+		   (Bool::Or<BoolView,BoolView,BoolView>
+		    ::post(home,b0,b1,b2)));
+  }
+  void
+  bool_or(Space* home, BoolVar b0, BoolVar b1, bool b2, IntConLevel) {
+    if (home->failed()) return;
+    if (b2) {
+      GECODE_ES_FAIL(home,
+		     (Bool::OrTrue<BoolView,BoolView>::post(home,b0,b1)));
+    } else {
+      BoolView bv0(b0);
+      BoolView bv1(b1);
+      GECODE_ME_FAIL(home,bv0.t_zero(home));
+      GECODE_ME_FAIL(home,bv1.t_zero(home));
+    }
+  }
+  void
+  bool_or(Space* home, const BoolVarArgs& b, BoolVar c, IntConLevel) {
+    if (home->failed()) return;
+    ViewArray<BoolView> x(home,b);
+    GECODE_ES_FAIL(home,Bool::NaryOr<BoolView>::post(home,x,c));
+  }
+  void
+  bool_or(Space* home, const BoolVarArgs& b, bool c, IntConLevel) {
+    if (home->failed()) return;
+    if (c) {
+      ViewArray<BoolView> x(home,b);
+      GECODE_ES_FAIL(home,Bool::NaryOrTrue<BoolView>::post(home,x));
+    } else {
+      for (int i=b.size(); i--; ) {
+	BoolView bvi(b[i]);
+	GECODE_ME_FAIL(home,bvi.t_zero(home));
+      }
+    }
+  }
+
+  void
+  bool_imp(Space* home, BoolVar b0, BoolVar b1, BoolVar b2, IntConLevel) {
+    if (home->failed()) return;
+    NegBoolView n0(b0);
+    GECODE_ME_FAIL(home,(Bool::Or<NegBoolView,BoolView,BoolView>
+			 ::post(home,n0,b1,b2)));
+  }
+  void
+  bool_imp(Space* home, BoolVar b0, BoolVar b1, bool b2, IntConLevel) {
+    if (home->failed()) return;
+    if (b2) {
+      NegBoolView n0(b0);
+      GECODE_ME_FAIL(home,(Bool::OrTrue<NegBoolView,BoolView>
+			   ::post(home,n0,b1)));
+    } else {
+      BoolView bv0(b0); BoolView bv1(b1);
+      GECODE_ME_FAIL(home,bv0.t_one(home));
+      GECODE_ME_FAIL(home,bv1.t_zero(home));
+    }
+  }
+
+  void
+  bool_eqv(Space* home, BoolVar b0, BoolVar b1, BoolVar b2, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,(Bool::Eqv<BoolView,BoolView,BoolView>
+			 ::post(home,b0,b1,b2)));
+  }
+  void
+  bool_eqv(Space* home, BoolVar b0, BoolVar b1, bool b2, IntConLevel) {
+    if (home->failed()) return;
+    if (b2) {
+      GECODE_ES_FAIL(home,(Bool::Eq<BoolView,BoolView>::post(home,b0,b1)));
+    } else {
+      NegBoolView n0(b0);
+      GECODE_ES_FAIL(home,(Bool::Eq<NegBoolView,BoolView>::post(home,n0,b1)));
+    }
+  }
+
+  void
+  bool_xor(Space* home, BoolVar b0, BoolVar b1, BoolVar b2, IntConLevel) {
+    if (home->failed()) return;
+    NegBoolView n2(b2);
+    GECODE_ES_FAIL(home,(Bool::Eqv<BoolView,BoolView,NegBoolView>
+			 ::post(home,b0,b1,n2)));
+  }
+  void
+  bool_xor(Space* home, BoolVar b0, BoolVar b1, bool b2, IntConLevel) {
+    if (home->failed()) return;
+    if (b2) {
+      NegBoolView n0(b0);
+      GECODE_ES_FAIL(home,(Bool::Eq<NegBoolView,BoolView>::post(home,n0,b1)));
+    } else {
+      GECODE_ES_FAIL(home,(Bool::Eq<BoolView,BoolView>::post(home,b0,b1)));
+    }
+  }
+
+}
+
+
+// STATISTICS: int-post
+