int.hh

Go to the documentation of this file.

/* -*- 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: 2013-02-06 15:10:02 +0100 (Wed, 06 Feb 2013) $ by $Author: schulte $
 *     $Revision: 13270 $
 *
 *  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 {

  namespace Int {


    class Assignment {
    protected:
      int n;            
      Gecode::IntSet d; 
    public:
      Assignment(int n0, const Gecode::IntSet& d0);
      virtual bool operator()(void) const = 0;
      virtual void operator++(void) = 0;
      virtual int operator[](int i) const = 0;
      int size(void) const;
      virtual ~Assignment(void);
    };

    class CpltAssignment : public Assignment {
    protected:
      Gecode::IntSetValues* dsv; 
    public:
      CpltAssignment(int n, const Gecode::IntSet& d);
      virtual bool operator()(void) const;
      virtual void operator++(void);
      virtual int operator[](int i) const;
      virtual ~CpltAssignment(void);
    };

    class RandomAssignment : public Assignment {
    protected:
      int* vals; 
      int  a;    

      int randval(void);
    public:
      RandomAssignment(int n, const Gecode::IntSet& d, int a);
      virtual bool operator()(void) const;
      virtual void operator++(void);
      virtual int operator[](int i) const;
      virtual ~RandomAssignment(void);
    };

    class RandomMixAssignment : public Assignment {
    protected:
      int* vals; 
      int  a;    
      int _n1;   
      Gecode::IntSet _d1; 

      int randval(const Gecode::IntSet& d);
    public:
      RandomMixAssignment(int n0, const Gecode::IntSet& d0,
                          int n1, const Gecode::IntSet& d1, int a0);
      virtual bool operator()(void) const;
      virtual void operator++(void);
      virtual int operator[](int i) const;
      virtual ~RandomMixAssignment(void);
    };

    enum ConTestLevel {
      CTL_NONE,     
      CTL_DOMAIN,   
      CTL_BOUNDS_D, 
      CTL_BOUNDS_Z, 
    };

    class Test;

    class TestSpace : public Gecode::Space {
    public:
      Gecode::IntSet d;
      Gecode::IntVarArray x;
      Gecode::Reify r;
      Test* test;
      bool reified;

      TestSpace(int n, Gecode::IntSet& d, Test* t); 
      TestSpace(int n, Gecode::IntSet& d, Test* t, Gecode::ReifyMode rm);
      TestSpace(bool share, TestSpace& s);
      virtual Gecode::Space* copy(bool share);
      bool assigned(void) const;
      void post(void);
      bool failed(void);
      void rel(int i, Gecode::IntRelType irt, int n);
      void rel(bool sol);
      void assign(const Assignment& a, bool skip=false);
      void bound(void);
      void prune(int i, bool bounds_only);
      void prune(void);
      bool prune(const Assignment& a, bool testfix);
    };

    class Test : public Base {
    protected:
      int arity;
      Gecode::IntSet dom;
      bool reified;
      int rms;
      Gecode::IntConLevel icl;
      ConTestLevel contest;
      bool testsearch;
      bool testfix;


      bool eqv(void) const;
      bool imp(void) const;
      bool pmi(void) const;
    public:
      Test(const std::string& p, const std::string& s,
           int a, const Gecode::IntSet& d, bool r=false,
           Gecode::IntConLevel i=Gecode::ICL_DEF);
      Test(const std::string& s,
           int a, const Gecode::IntSet& d, bool r=false,
           Gecode::IntConLevel i=Gecode::ICL_DEF);
      Test(const std::string& p, const std::string& s, 
           int a, int min, int max, bool r=false,
           Gecode::IntConLevel i=Gecode::ICL_DEF);
      Test(const std::string& s, 
           int a, int min, int max, bool r=false,
           Gecode::IntConLevel i=Gecode::ICL_DEF);
      virtual Assignment* assignment(void) const;
      virtual bool solution(const Assignment&) const = 0;
      virtual bool ignore(const Assignment&) const;
      virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) = 0;
      virtual void post(Gecode::Space& home, Gecode::IntVarArray& x,
                        Gecode::Reify r);
      virtual bool run(void);


      static std::string str(Gecode::ExtensionalPropKind epk);
      static std::string str(Gecode::IntConLevel icl);
      static std::string str(Gecode::IntRelType irl);
      static std::string str(Gecode::BoolOpType bot);
      static std::string str(int i);
      static std::string str(const Gecode::IntArgs& i);



      template<class T> static bool cmp(T x, Gecode::IntRelType r, T y);
    };

    class IntConLevels {
    private:
      static const Gecode::IntConLevel icls[3];
      int i;
    public:
      IntConLevels(void);
      bool operator()(void) const;
      void operator++(void);
      Gecode::IntConLevel icl(void) const;
    };

    class IntRelTypes {
    private:
      static const Gecode::IntRelType irts[6];
      int i;
    public:
      IntRelTypes(void);
      void reset(void);
      bool operator()(void) const;
      void operator++(void);
      Gecode::IntRelType irt(void) const;
    };

    class BoolOpTypes {
    private:
      static const Gecode::BoolOpType bots[5];
      int i;
    public:
      BoolOpTypes(void);
      bool operator()(void) const;
      void operator++(void);
      Gecode::BoolOpType bot(void) const;
    };

  }
}

std::ostream& operator<<(std::ostream& os, const Test::Int::Assignment& a);

#include "test/int.hpp"

#endif

// STATISTICS: test-int