dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/test/int.hh

@@ -0,0 +1,353 @@
+/* -*- 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: 2010-06-03 21:11:11 +1000 (Thu, 03 Jun 2010) $ by $Author: tack $
+ *     $Revision: 11013 $
+ *
+ *  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);
+    };
+
+    /// Generate random selection of assignments
+    class RandomMixAssignment : public Assignment {
+    protected:
+      int* vals; ///< The current values for the variables
+      int  a;    ///< How many assigments still to be generated
+      int _n1;   ///< How many variables in the second set
+      Gecode::IntSet _d1; ///< Domain for second set of variables
+      /// Generate new value according to domain \a d
+      int randval(const Gecode::IntSet& d);
+    public:
+      /// Initialize for \a a assignments for \a n0 variables and values \a d0
+      RandomMixAssignment(int n0, const Gecode::IntSet& d0,
+                          int n1, const Gecode::IntSet& d1, int a0);
+      /// 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 ~RandomMixAssignment(void);
+    };
+
+    /// Level of consistency to test for
+    enum ConTestLevel {
+      CTL_NONE,     ///< No consistency-test
+      CTL_DOMAIN,   ///< Test for domain-consistency
+      CTL_BOUNDS_D, ///< Test for bounds(d)-consistency
+      CTL_BOUNDS_Z, ///< Test for bounds(z)-consistency
+    };
+
+    class Test;
+
+    /// Space for executing tests
+    class TestSpace : public Gecode::Space {
+    public:
+      /// Initial domain
+      Gecode::IntSet d;
+      /// Variables to be tested
+      Gecode::IntVarArray x;
+      /// Control variable for reified propagators
+      Gecode::BoolVar b;
+      /// Whether the test is for a reified propagator
+      bool reified;
+      /// The test currently run
+      Test* test;
+
+      /**
+       * \brief Create test space
+       *
+       * Creates \a n variables with domain \a d0 and stores whether
+       * the test is for a reified propagator (\a r), and the test itself
+       * (\a t).
+       *
+       */
+      TestSpace(int n, Gecode::IntSet& d0, bool r, Test* t, bool log=true);
+      /// Constructor for cloning \a s
+      TestSpace(bool share, TestSpace& s);
+      /// Copy space during cloning
+      virtual Gecode::Space* copy(bool share);
+      /// Test whether all variables are assigned
+      bool assigned(void) const;
+      /// Post propagator
+      void post(void);
+      /// Compute a fixpoint and check for failure
+      bool failed(void);
+      /// Perform integer tell operation on \a x[i]
+      void rel(int i, Gecode::IntRelType irt, int n);
+      /// Perform Boolean tell on \a b
+      void rel(bool sol);
+      /// Assign all (or all but one, if \a skip is true) variables to values in \a a
+      void assign(const Assignment& a, bool skip=false);
+      /// Assing a random variable to a random bound
+      void bound(void);
+      /** \brief Prune some random values from variable \a i
+       *
+       * If \a bounds_only is true, then the pruning is only done on the
+       * bounds of the variable.
+       */
+      void prune(int i, bool bounds_only);
+      /// Prune some random values for some random variable
+      void prune(void);
+      /// Prune values but not those in assignment \a a
+      bool prune(const Assignment& a, bool testfix);
+    };
+
+    /**
+     * \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;
+      /// Whether to test for certain consistency
+      ConTestLevel contest;
+      /// Whether to perform search test
+      bool testsearch;
+      /// Whether to perform fixpoint test
+      bool testfix;
+
+    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. The consistency level is
+       * maintained for convenience.
+       */
+      Test(const std::string& s, int a, const Gecode::IntSet& d, bool r=false,
+           Gecode::IntConLevel i=Gecode::ICL_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. The consistency level is
+       * maintained for convenience.
+       */
+      Test(const std::string& s, int a, int min, int max, bool r=false,
+           Gecode::IntConLevel i=Gecode::ICL_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 extensional propagation kind to string
+      static std::string str(Gecode::ExtensionalPropKind epk);
+      /// Map integer consistency level to string
+      static std::string str(Gecode::IntConLevel icl);
+      /// Map integer relation to string
+      static std::string str(Gecode::IntRelType irl);
+      /// Map Boolean operation to string
+      static std::string str(Gecode::BoolOpType bot);
+      /// Map integer to string
+      static std::string str(int i);
+      /// Map integer array to string
+      static std::string str(const Gecode::IntArgs& 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.hpp"
+
+#endif
+
+// STATISTICS: test-int
+

data/ext/libgecode3/vendor/gecode-3.7.3/test/int.hpp

@@ -0,0 +1,314 @@
+/* -*- 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: 2010-06-03 21:11:11 +1000 (Thu, 03 Jun 2010) $ by $Author: tack $
+ *     $Revision: 11013 $
+ *
+ *  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;
+  }
+
+  forceinline int
+  RandomMixAssignment::randval(const Gecode::IntSet& d) {
+    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
+  RandomMixAssignment::RandomMixAssignment(int n0, const Gecode::IntSet& d0,
+                                           int n1, const Gecode::IntSet& d1, 
+                                           int a0)
+    : Assignment(n0+n1,d0),vals(new int[n0+n1]),a(a0),_n1(n1),_d1(d1) {
+    for (int i=n0; i--; )
+      vals[i] = randval(d);
+    for (int i=n1; i--; )
+      vals[n0+i] = randval(_d1);
+  }
+
+  inline bool
+  RandomMixAssignment::operator()(void) const {
+    return a>0;
+  }
+
+  inline int
+  RandomMixAssignment::operator[](int i) const {
+    assert((i>=0) && (i<n));
+    return vals[i];
+  }
+
+  inline
+  RandomMixAssignment::~RandomMixAssignment(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)
+    : Base("Int::"+s), arity(a), dom(d), reified(r), icl(i),
+      contest(icl == Gecode::ICL_DOM ? CTL_DOMAIN : CTL_NONE),
+      testsearch(true), testfix(true) {}
+
+  inline
+  Test::Test(const std::string& s, int a, int min, int max,
+             bool r, Gecode::IntConLevel i)
+    : Base("Int::"+s), arity(a), dom(min,max), reified(r), icl(i),
+      contest(icl == Gecode::ICL_DOM ? CTL_DOMAIN : CTL_NONE),
+      testsearch(true), testfix(true) {}
+
+  inline
+  std::string
+  Test::str(Gecode::ExtensionalPropKind epk) {
+    using namespace Gecode;
+    switch (epk) {
+    case EPK_MEMORY: return "Memory";
+    case EPK_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();
+  }
+
+  inline
+  std::string
+  Test::str(const Gecode::IntArgs& x) {
+    std::string s = "";
+    for (int i=0; i<x.size()-1; i++)
+      s += str(x[i]) + ",";
+    return "[" + s + str(x[x.size()-1]) + "]";
+  }
+
+  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
+