gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/int.hh

@@ -0,0 +1,267 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef __GECODE_TEST_INT_HH__
+#define __GECODE_TEST_INT_HH__
+
+#include "test/test.hh"
+
+#include "gecode/int.hh"
+
+namespace Test { 
+
+  /// Testing finite domain integers
+  namespace Int {
+
+    /**
+     * \defgroup TaskTestInt Testing finite domain integers
+     * \ingroup TaskTest
+     */
+
+    /**
+     * \defgroup TaskTestIntInt General test support
+     * \ingroup TaskTestInt
+     */
+    //@{
+    /// Base class for assignments
+    class Assignment {
+    protected:
+      int n;            ///< Number of variables
+      Gecode::IntSet d; ///< Domain for each variable
+    public:
+      /// Initialize assignments for \a n0 variables and values \a d0
+      Assignment(int n0, const Gecode::IntSet& d0);
+      /// Test whether all assignments have been iterated
+      virtual bool operator()(void) const = 0;
+      /// Move to next assignment
+      virtual void operator++(void) = 0;
+      /// Return value for variable \a i
+      virtual int operator[](int i) const = 0;
+      /// Return number of variables
+      int size(void) const;
+      /// Destructor
+      virtual ~Assignment(void);
+    };
+    
+    /// Generate all assignments
+    class CpltAssignment : public Assignment {
+    protected:
+      Gecode::IntSetValues* dsv; ///< Iterator for each variable
+    public:
+      /// Initialize assignments for \a n0 variables and values \a d0
+      CpltAssignment(int n, const Gecode::IntSet& d);
+      /// Test whether all assignments have been iterated
+      virtual bool operator()(void) const;
+      /// Move to next assignment
+      virtual void operator++(void);
+      /// Return value for variable \a i
+      virtual int operator[](int i) const;
+      /// Destructor
+      virtual ~CpltAssignment(void);
+    };
+    
+    /// Generate random selection of assignments
+    class RandomAssignment : public Assignment {
+    protected:
+      int* vals; ///< The current values for the variables
+      int  a;    ///< How many assigments still to be generated
+      /// Generate new value according to domain
+      int randval(void);
+    public:
+      /// Initialize for \a a assignments for \a n0 variables and values \a d0
+      RandomAssignment(int n, const Gecode::IntSet& d, int a);
+      /// Test whether all assignments have been iterated
+      virtual bool operator()(void) const;
+      /// Move to next assignment
+      virtual void operator++(void);
+      /// Return value for variable \a i
+      virtual int operator[](int i) const;
+      /// Destructor
+      virtual ~RandomAssignment(void);
+    };
+        
+    /**
+     * \brief Base class for tests with integer constraints
+     *
+     */
+    class Test : public Base {
+    protected:
+      /// Number of variables
+      int arity;
+      /// Domain of variables
+      Gecode::IntSet dom;
+      /// Does the constraint also exist as reified constraint
+      bool reified;
+      /// Consistency level
+      Gecode::IntConLevel icl;
+      /// Propagation kind
+      Gecode::PropKind pk;
+      /// Whether to test for domain consistency
+      bool testdomcon;
+      /// Whether to perform search test
+      bool testsearch;
+    
+    public:
+      /**
+       * \brief Constructor
+       *
+       * Constructs a test with name \a s and arity \a a and variable
+       * domain \a d. Also tests for a reified constraint, 
+       * if \a r is true. Consistency level and propagation kind are 
+       * maintained for convenience.
+       */
+      Test(const std::string& s, int a, const Gecode::IntSet& d, bool r=false, 
+           Gecode::IntConLevel i=Gecode::ICL_DEF,
+           Gecode::PropKind p=Gecode::PK_DEF);
+      /**
+       * \brief Constructor
+       *
+       * Constructs a test with name \a s and arity \a a and variable
+       * domain \a min ... \a max. Also tests for a reified constraint, 
+       * if \a r is true. Consistency level and propagation kind are
+       * maintained for convenience.
+       */
+      Test(const std::string& s, int a, int min, int max, bool r=false,
+           Gecode::IntConLevel i=Gecode::ICL_DEF,
+           Gecode::PropKind p=Gecode::PK_DEF);
+      /// Create assignment
+      virtual Assignment* assignment(void) const;
+      /// Check for solution
+      virtual bool solution(const Assignment&) const = 0;
+      /// Whether to ignore assignment for reification
+      virtual bool ignore(const Assignment&) const;
+      /// Post constraint
+      virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) = 0;
+      /// Post reified constraint
+      virtual void post(Gecode::Space* home, Gecode::IntVarArray& x, 
+                        Gecode::BoolVar b);
+      /// Perform test
+      virtual bool run(void);
+      /// \name Mapping scalar values to strings
+      //@{
+      /// Map propagation kind to string
+      static std::string str(Gecode::PropKind pk);
+      /// Map integer consistency level to string
+      static std::string str(Gecode::IntConLevel icl);
+      /// Map integer relation to string
+      static std::string str(Gecode::IntRelType pk);
+      /// Map Boolean operation to string
+      static std::string str(Gecode::BoolOpType bot);
+      /// Map integer to string
+      static std::string str(int i);
+      //@}
+      /// \name General support
+      //@{
+      /// Compare \a x and \a y with respect to \a r
+      template <class T> static bool cmp(T x, Gecode::IntRelType r, T y);
+      //@}
+    };
+    //@}
+    
+    /// Iterator for integer consistency levels
+    class IntConLevels {
+    private:
+      /// Array of consistency levels
+      static const Gecode::IntConLevel icls[3];
+      /// Current position in level array
+      int i; 
+    public:
+      /// Initialize iterator
+      IntConLevels(void);
+      /// Test whether iterator is done
+      bool operator()(void) const;
+      /// Increment to next level
+      void operator++(void);
+      /// Return current level
+      Gecode::IntConLevel icl(void) const;
+    };
+    
+    /// Iterator for integer relation types
+    class IntRelTypes {
+    private:
+      /// Array of relation types
+      static const Gecode::IntRelType irts[6];
+      /// Current position in relation type array
+      int i; 
+    public:
+      /// Initialize iterator
+      IntRelTypes(void);
+      /// Reset iterator
+      void reset(void);
+      /// Test whether iterator is done
+      bool operator()(void) const;
+      /// Increment to next relation type
+      void operator++(void);
+      /// Return current relation type
+      Gecode::IntRelType irt(void) const;
+    };
+    
+    /// Iterator for Boolean operation types
+    class BoolOpTypes {
+    private:
+      /// Array of operation types
+      static const Gecode::BoolOpType bots[5];
+      /// Current position in operation type array
+      int i; 
+    public:
+      /// Initialize iterator
+      BoolOpTypes(void);
+      /// Test whether iterator is done
+      bool operator()(void) const;
+      /// Increment to next operation type
+      void operator++(void);
+      /// Return current operation type
+      Gecode::BoolOpType bot(void) const;
+    };
+    
+  }
+}
+
+/**
+ * \brief Print assignment \a
+ * \relates Assignment
+ */
+std::ostream& operator<<(std::ostream& os, const Test::Int::Assignment& a);
+
+#include "test/int.icc"
+
+#endif
+
+// STATISTICS: test-int
+

data/ext/gecode-2.2.0/test/int.icc

@@ -0,0 +1,266 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-02-26 10:40:46 +0100 (Tue, 26 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6311 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Test { namespace Int {
+
+  /*
+   * Assignments
+   *
+   */
+  inline
+  Assignment::Assignment(int n0, const Gecode::IntSet& d0)
+    : n(n0), d(d0) {}
+  inline int
+  Assignment::size(void) const {
+    return n;
+  }
+  inline
+  Assignment::~Assignment(void) {}
+  
+  
+  inline
+  CpltAssignment::CpltAssignment(int n, const Gecode::IntSet& d)
+    : Assignment(n,d), 
+      dsv(new Gecode::IntSetValues[static_cast<unsigned int>(n)]) {
+    for (int i=n; i--; )
+      dsv[i].init(d);
+  }
+  inline bool
+  CpltAssignment::operator()(void) const {
+    return dsv[0]();
+  }
+  inline int
+  CpltAssignment::operator[](int i) const {
+    assert((i>=0) && (i<n));
+    return dsv[i].val();
+  }
+  inline 
+  CpltAssignment::~CpltAssignment(void) {
+    delete [] dsv;
+  }
+  
+  
+  forceinline int
+  RandomAssignment::randval(void) {
+    unsigned int skip = Base::rand(d.size());
+    for (Gecode::IntSetRanges it(d); true; ++it) {
+      if (it.width() > skip)
+        return it.min() + static_cast<int>(skip);
+      skip -= it.width();
+    }
+    GECODE_NEVER;
+    return 0;
+  }
+
+  inline
+  RandomAssignment::RandomAssignment(int n, const Gecode::IntSet& d, int a0)
+    : Assignment(n,d), vals(new int[n]), a(a0) {
+    for (int i=n; i--; )
+      vals[i] = randval();
+  }
+  
+  inline bool
+  RandomAssignment::operator()(void) const {
+    return a>0;
+  }
+  inline int
+  RandomAssignment::operator[](int i) const {
+    assert((i>=0) && (i<n));
+    return vals[i];
+  }
+  inline
+  RandomAssignment::~RandomAssignment(void) {
+    delete [] vals;
+  }
+
+
+
+  /*
+   * Tests with integer constraints
+   *
+   */
+  inline
+  Test::Test(const std::string& s, int a, const Gecode::IntSet& d, 
+             bool r, Gecode::IntConLevel i, Gecode::PropKind p)
+    : Base("Int::"+s), arity(a), dom(d), reified(r), icl(i), pk(p),
+      testdomcon(true), testsearch(true) {}
+
+  inline
+  Test::Test(const std::string& s, int a, int min, int max, 
+             bool r, Gecode::IntConLevel i, Gecode::PropKind p)
+    : Base("Int::"+s), arity(a), dom(min,max), reified(r), icl(i), pk(p), 
+      testdomcon(true), testsearch(true) {}
+
+  inline
+  std::string
+  Test::str(Gecode::PropKind pk) {
+    using namespace Gecode;
+    switch (pk) {
+    case PK_MEMORY: return "Memory";
+    case PK_SPEED:  return "Speed";
+    default: return "Def";
+    }
+  }
+  
+  inline
+  std::string
+  Test::str(Gecode::IntConLevel icl) {
+    using namespace Gecode;
+    switch (icl) {
+    case ICL_VAL: return "Val";
+    case ICL_BND: return "Bnd";
+    case ICL_DOM: return "Dom";
+    default: return "Def";
+    }
+  }
+  
+  inline
+  std::string
+  Test::str(Gecode::IntRelType irt) {
+    using namespace Gecode;
+    switch (irt) {
+    case IRT_LQ: return "Lq";
+    case IRT_LE: return "Le";
+    case IRT_GQ: return "Gq";
+    case IRT_GR: return "Gr";
+    case IRT_EQ: return "Eq";
+    case IRT_NQ: return "Nq";
+    default: ;
+    }
+    GECODE_NEVER;
+    return "NONE";
+  }
+  
+  inline std::string 
+  Test::str(Gecode::BoolOpType bot) {
+    using namespace Gecode;
+    switch (bot) {
+    case BOT_AND: return "And";
+    case BOT_OR:  return "Or";
+    case BOT_IMP: return "Imp";
+    case BOT_EQV: return "Eqv";
+    case BOT_XOR: return "Xor";
+    default: GECODE_NEVER;
+    }
+    GECODE_NEVER;
+    return "NONE";
+  }
+
+  inline
+  std::string
+  Test::str(int i) {
+    std::stringstream s;
+    s << i;
+    return s.str();
+  }
+  
+  template<class T>
+  inline bool
+  Test::cmp(T x, Gecode::IntRelType r, T y) {
+    using namespace Gecode;
+    switch (r) {
+    case IRT_EQ: return x == y;
+    case IRT_NQ: return x != y;
+    case IRT_LQ: return x <= y;
+    case IRT_LE: return x < y;
+    case IRT_GR: return x > y;
+    case IRT_GQ: return x >= y;
+    default: ;
+    }
+    return false;
+  }
+  
+  
+  inline
+  IntConLevels::IntConLevels(void) 
+    : i(sizeof(icls)/sizeof(Gecode::IntConLevel)-1) {}
+  inline bool 
+  IntConLevels::operator()(void) const {
+    return i>=0;
+  }
+  inline void 
+  IntConLevels::operator++(void) {
+    i--;
+  }
+  inline Gecode::IntConLevel 
+  IntConLevels::icl(void) const {
+    return icls[i];
+  }
+
+
+  inline
+  IntRelTypes::IntRelTypes(void) 
+    : i(sizeof(irts)/sizeof(Gecode::IntRelType)-1) {}
+  inline void
+  IntRelTypes::reset(void) {
+    i = sizeof(irts)/sizeof(Gecode::IntRelType)-1;
+  }
+  inline bool 
+  IntRelTypes::operator()(void) const {
+    return i>=0;
+  }
+  inline void 
+  IntRelTypes::operator++(void) {
+    i--;
+  }
+  inline Gecode::IntRelType
+  IntRelTypes::irt(void) const {
+    return irts[i];
+  }
+
+  inline
+  BoolOpTypes::BoolOpTypes(void) 
+    : i(sizeof(bots)/sizeof(Gecode::BoolOpType)-1) {}
+  inline bool 
+  BoolOpTypes::operator()(void) const {
+    return i>=0;
+  }
+  inline void 
+  BoolOpTypes::operator++(void) {
+    i--;
+  }
+  inline Gecode::BoolOpType
+  BoolOpTypes::bot(void) const {
+    return bots[i];
+  }
+
+}}
+
+// STATISTICS: test-int
+