float.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.dev>
 *     Mikael Zayenz Lagerkvist <lagerkvist@gecode.dev>
 *     Vincent Barichard <Vincent.Barichard@univ-angers.fr>
 *
 *  Copyright:
 *     Christian Schulte, 2005
 *     Mikael Zayenz Lagerkvist, 2006
 *     Vincent Barichard, 2012
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.dev
 *
 *  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_FLOAT_HH
#define GECODE_TEST_FLOAT_HH
 
#include "test/test.hh"
 
#include <gecode/float.hh>
 
namespace Test {

  namespace Float {

    enum MaybeType {
      MT_FALSE = 0, //< Does hold
      MT_TRUE,      //< Does not hold
      MT_MAYBE      //< Might or might not hold
    };

    MaybeType operator &(MaybeType a, MaybeType b);

    enum AssignmentType {
      CPLT_ASSIGNMENT = 0,
      RANDOM_ASSIGNMENT,
      EXTEND_ASSIGNMENT
    };
 
    class Test;



    class Assignment {
    protected:
      int n;              
      Gecode::FloatVal d; 
    public:
      Assignment(int n0, const Gecode::FloatVal& d0);
      virtual bool has_more(void) const = 0;
      virtual void next(Gecode::Support::RandomGenerator& rand) = 0;
      virtual Gecode::FloatVal operator[](int i) const = 0;
      virtual void set(int i, const Gecode::FloatVal& val) = 0;
      int size(void) const;
      virtual ~Assignment(void);
    };

    class CpltAssignment : public Assignment {
    protected:
      Gecode::FloatVal* dsv; 
      Gecode::FloatNum step; 
    public:
      CpltAssignment(int n, const Gecode::FloatVal& d, Gecode::FloatNum s);
      virtual bool has_more(void) const;
      virtual void next(Gecode::Support::RandomGenerator& rand);
      virtual Gecode::FloatVal operator[](int i) const;
      virtual void set(int i, const Gecode::FloatVal& val);
      virtual ~CpltAssignment(void);
    };

    class ExtAssignment : public Assignment {
    protected:
      const Test* curPb;     
      Gecode::FloatVal* dsv; 
      Gecode::FloatNum step; 
    public:
      ExtAssignment(int n, const Gecode::FloatVal& d, Gecode::FloatNum s, const Test* pb,
                    Gecode::Support::RandomGenerator& rand);
      virtual bool has_more(void) const;
      virtual void next(Gecode::Support::RandomGenerator& rand);
      virtual Gecode::FloatVal operator[](int i) const;
      virtual void set(int i, const Gecode::FloatVal& val);
      virtual ~ExtAssignment(void);
    };
 

    class RandomAssignment : public Assignment {
    protected:
      Gecode::FloatVal* vals; 
      int  a;                 
      Gecode::FloatNum randval(Gecode::Support::RandomGenerator& rand);
    public:
      RandomAssignment(int n, const Gecode::FloatVal& d, int a0, Gecode::Support::RandomGenerator& rand);
      virtual bool has_more(void) const;
      virtual void next(Gecode::Support::RandomGenerator& rand);
      virtual Gecode::FloatVal operator[](int i) const;
      virtual void set(int i, const Gecode::FloatVal& val);
      virtual ~RandomAssignment(void);
    };

    class TestSpace : public Gecode::Space {
    public:
      Gecode::FloatVal d;
      Gecode::FloatNum step;
      Gecode::FloatVarArray x;
      Gecode::Reify r;
      Test* test;
      bool reified;

      TestSpace(int n, Gecode::FloatVal& d, Gecode::FloatNum s, Test* t);
      TestSpace(int n, Gecode::FloatVal& d, Gecode::FloatNum s, Test* t,
                Gecode::ReifyMode rm);
      TestSpace(TestSpace& s);
      virtual Gecode::Space* copy(void);
      virtual void dropUntil(const Assignment& a);
      bool assigned(void) const;
      bool matchAssignment(const Assignment& a) const;
      void post(void);
      bool failed(void);
      void rel(int i, Gecode::FloatRelType frt, Gecode::FloatVal n);
      void rel(bool sol);
      void assign(const Assignment& a, MaybeType& sol, bool skip, Gecode::Support::RandomGenerator& rand);
      void bound(Gecode::Support::RandomGenerator& rand);
      Gecode::FloatNum cut(int* cutDirections);
      void prune(int i, Gecode::Support::RandomGenerator& rand);
      void prune(Gecode::Support::RandomGenerator& rand);
      bool prune(const Assignment& a, bool testfix, Gecode::Support::RandomGenerator& rand);
      void disable(void);
      void enable(void);
      unsigned int propagators(void);
    };

    class Test : public Base {
    protected:
      int arity;
      Gecode::FloatVal dom;
      Gecode::FloatNum step;
      AssignmentType assignmentType;
      bool reified;
      int rms;
      bool testsearch;
      bool testfix;
      bool testsubsumed;


      bool eqv(void) const;
      bool imp(void) const;
      bool pmi(void) const;
    public:
      Test(const std::string& s, int a, const Gecode::FloatVal& d,
           Gecode::FloatNum st, AssignmentType at,
           bool r);
      Test(const std::string& s, int a,
           Gecode::FloatNum min, Gecode::FloatNum max,
           Gecode::FloatNum st, AssignmentType at,
           bool r);
      virtual Assignment* assignment(void) const;
      virtual bool extendAssignment(Assignment& a) const;
      virtual MaybeType solution(const Assignment&) const = 0;
      bool subsumed(const TestSpace& ts) const;
      virtual bool ignore(const Assignment& a) const;
      virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) = 0;
      virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x,
                        Gecode::Reify r);
      virtual bool run(void);


      static std::string str(Gecode::FloatRelType frt);
      static std::string str(Gecode::FloatNum f);
      static std::string str(Gecode::FloatVal f);
      static std::string str(const Gecode::FloatValArgs& f);


      static MaybeType cmp(Gecode::FloatVal x, Gecode::FloatRelType r,
                           Gecode::FloatVal y);
      static MaybeType eq(Gecode::FloatVal x, Gecode::FloatVal y);
      bool flip(void);
    };


    class FloatRelTypes {
    private:
      static const Gecode::FloatRelType frts[6];
      int i;
    public:
      FloatRelTypes(void);
      void reset(void);
      bool operator()(void) const;
      void operator++(void);
      Gecode::FloatRelType frt(void) const;
    };
 
  }
}

std::ostream& operator<<(std::ostream& os, const Test::Float::Assignment& a);
 
#include "test/float.hpp"
 
#endif
 
// STATISTICS: test-float