main page modules namespaces classes files
Gecode home

search for 

view.icc

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2005
 *
 *  Last modified:
 *     $Date: 2006-08-24 11:25:05 +0200 (Thu, 24 Aug 2006) $ by $Author: schulte $
 *     $Revision: 3559 $
 *
 *  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/iter.hh"

#include <iostream>

#if (-17 / 7) == -2
#define GECODE_INT_RND_TWDS_ZERO 1
#else
#define GECODE_INT_RND_TWDS_ZERO 0
#endif

namespace Gecode { namespace Int {

  template <class View>
  class ViewRanges {
  public:


    ViewRanges(void);
    ViewRanges(const View& x);
    void init(const View& x);



    bool operator()(void) const;
    void operator++(void);



    int min(void) const;
    int max(void) const;
    unsigned int width(void) const;
  };

  template <class View>
  class ViewValues
    : public Iter::Ranges::ToValues<ViewRanges<View> > {
  public:


    ViewValues(void);
    ViewValues(const View& x);
    void init(const View& x);
  };

}}

#include "gecode/int/view/iter.icc"

namespace Gecode {

  namespace Int {

    class IntView : public VariableViewBase<IntVarImp> {
    protected:
      using VariableViewBase<IntVarImp>::var;
    public:


      IntView(void);
      IntView(const IntVar& x);



      int min(void) const;
      int max(void) const;
      int med(void) const;
      int val(void) const;

      unsigned int size(void) const;
      unsigned int width(void) const;
      unsigned int regret_min(void) const;
      unsigned int regret_max(void) const;



      bool range(void) const;
      bool assigned(void) const;

      bool in(int n) const;
      bool in(double n) const;



      ModEvent lq(Space* home, int n);
      ModEvent lq(Space* home, double n);

      ModEvent le(Space* home, int n);
      ModEvent le(Space* home, double n);

      ModEvent gq(Space* home, int n);
      ModEvent gq(Space* home, double n);

      ModEvent gr(Space* home, int n);
      ModEvent gr(Space* home, double n);

      ModEvent nq(Space* home, int n);
      ModEvent nq(Space* home, double n);

      ModEvent eq(Space* home, int n);
      ModEvent eq(Space* home, double n);



      template <class I> ModEvent narrow(Space* home, I& i);
      template <class I> ModEvent inter(Space* home, I& i);
      template <class I> ModEvent minus(Space* home, I& i);



      void update(Space* home, bool share, IntView& x);
    };

  }

  template<>
  class ViewVarTraits<Int::IntView> {
  public:
    typedef Int::IntVarImp Var;
  };

  namespace Int {

    class MinusView : public DerivedViewBase<IntView> {
    protected:
      using DerivedViewBase<IntView>::view;
    public:


      MinusView(void);
      MinusView(const IntView& x);
      void init(const IntView& x);



      int min(void) const;
      int max(void) const;
      int med(void) const;
      int val(void) const;

      unsigned int size(void) const;
      unsigned int width(void) const;
      unsigned int regret_min(void) const;
      unsigned int regret_max(void) const;



      bool range(void) const;
      bool assigned(void) const;

      bool in(int n) const;
      bool in(double n) const;



      ModEvent lq(Space* home, int n);
      ModEvent lq(Space* home, double n);
      ModEvent le(Space* home, int n);
      ModEvent le(Space* home, double n);
      ModEvent gq(Space* home, int n);
      ModEvent gq(Space* home, double n);
      ModEvent gr(Space* home, int n);
      ModEvent gr(Space* home, double n);
      ModEvent nq(Space* home, int n);
      ModEvent nq(Space* home, double n);
      ModEvent eq(Space* home, int n);
      ModEvent eq(Space* home, double n);



      template <class I> ModEvent narrow(Space* home, I& i);
      template <class I> ModEvent inter(Space* home, I& i);
      template <class I> ModEvent minus(Space* home, I& i);



      static ModEvent     pme(const Propagator* p);
      static PropModEvent pme(ModEvent me);



      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
      void cancel(Space* home, Propagator* p, PropCond pc);



      void update(Space* home, bool share, MinusView& x);
    };

  }


  bool same(const Int::MinusView& x, const Int::MinusView& y);
  bool before(const Int::MinusView& x, const Int::MinusView& y);

  template<>
  class ViewVarTraits<Int::MinusView> {
  public:
    typedef Int::IntVarImp Var;
  };


  namespace Int {

    class OffsetView : public DerivedViewBase<IntView> {
    protected:
      int c;
      using DerivedViewBase<IntView>::view;
    public:


      OffsetView(void);
      OffsetView(const IntView& x, int c);
      void init(const IntView& x, int c);
      int offset(void) const;



      int min(void) const;
      int max(void) const;
      int med(void) const;
      int val(void) const;

      unsigned int size(void) const;
      unsigned int width(void) const;
      unsigned int regret_min(void) const;
      unsigned int regret_max(void) const;



      bool range(void) const;
      bool assigned(void) const;

      bool in(int n) const;
      bool in(double n) const;



      ModEvent lq(Space* home, int n);
      ModEvent lq(Space* home, double n);
      ModEvent le(Space* home, int n);
      ModEvent le(Space* home, double n);
      ModEvent gq(Space* home, int n);
      ModEvent gq(Space* home, double n);
      ModEvent gr(Space* home, int n);
      ModEvent gr(Space* home, double n);
      ModEvent nq(Space* home, int n);
      ModEvent nq(Space* home, double n);
      ModEvent eq(Space* home, int n);
      ModEvent eq(Space* home, double n);



      template <class I> ModEvent narrow(Space* home, I& i);
      template <class I> ModEvent inter(Space* home, I& i);
      template <class I> ModEvent minus(Space* home, I& i);



      static ModEvent     pme(const Propagator* p);
      static PropModEvent pme(ModEvent me);



      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
      void cancel(Space* home, Propagator* p, PropCond pc);



      void update(Space* home, bool share, OffsetView& x);
    };

  }


  bool same(const Int::OffsetView& x, const Int::OffsetView& y);
  bool before(const Int::OffsetView& x, const Int::OffsetView& y);

  template<>
  class ViewVarTraits<Int::OffsetView> {
  public:
    typedef Int::IntVarImp Var;
  };



  namespace Int {

    template <class Val, class UnsVal>
    class ScaleView : public DerivedViewBase<IntView> {
    protected:
      int a;
      using DerivedViewBase<IntView>::view;



      int floor_div(double x) const;
      int ceil_div(double x) const;
      int exact_div(double x, bool& exact) const;
#if GECODE_INT_RND_TWDS_ZERO

      int floor_div(int) const;
      int ceil_div(int) const;
      int exact_div(int, bool&) const;
#endif


    public:


      ScaleView(void);
      ScaleView(int b, const IntView& y);
      void init(int b, const IntView& y);
      int scale(void) const;




      Val min(void) const;
      Val max(void) const;
      Val med(void) const;
      Val val(void) const;

      UnsVal size(void) const;
      UnsVal width(void) const;
      UnsVal regret_min(void) const;
      UnsVal regret_max(void) const;



      bool range(void) const;
      bool assigned(void) const;
      bool in(Val n) const;



      ModEvent lq(Space* home, Val n);
      ModEvent le(Space* home, Val n);
      ModEvent gq(Space* home, Val n);
      ModEvent gr(Space* home, Val n);
      ModEvent nq(Space* home, Val n);
      ModEvent eq(Space* home, Val n);



      static ModEvent     pme(const Propagator* p);
      static PropModEvent pme(ModEvent me);



      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
      void cancel(Space* home, Propagator* p, PropCond pc);



      void update(Space* home, bool share, ScaleView<Val,UnsVal>& x);
    };

    typedef ScaleView<int,unsigned int> IntScaleView;

    typedef ScaleView<double,double> DoubleScaleView;

  }


  template <class Val, class UnsVal>
  bool same(const Int::ScaleView<Val,UnsVal>& x,
            const Int::ScaleView<Val,UnsVal>& y);
  template <class Val, class UnsVal>
  bool before(const Int::ScaleView<Val,UnsVal>& x,
              const Int::ScaleView<Val,UnsVal>& y);


  template <class Val, class UnsVal>
  class ViewVarTraits<Int::ScaleView<Val,UnsVal> > {
  public:
    typedef Int::IntVarImp Var;
  };



  namespace Int {

    class ConstIntView : public ConstantViewBase {
    protected:
      int x;
    public:


      ConstIntView(void);
      ConstIntView(int n);
      void init(int n);



      int min(void) const;
      int max(void) const;
      int med(void) const;
      int val(void) const;

      unsigned int size(void) const;
      unsigned int width(void) const;
      unsigned int regret_min(void) const;
      unsigned int regret_max(void) const;



      bool range(void) const;
      bool assigned(void) const;

      bool in(int n) const;
      bool in(double n) const;



      ModEvent lq(Space* home, int n);
      ModEvent lq(Space* home, double n);
      ModEvent le(Space* home, int n);
      ModEvent le(Space* home, double n);
      ModEvent gq(Space* home, int n);
      ModEvent gq(Space* home, double n);
      ModEvent gr(Space* home, int n);
      ModEvent gr(Space* home, double n);
      ModEvent nq(Space* home, int n);
      ModEvent nq(Space* home, double n);
      ModEvent eq(Space* home, int n);
      ModEvent eq(Space* home, double n);



      template <class I> ModEvent narrow(Space* home, I& i);
      template <class I> ModEvent inter(Space* home, I& i);
      template <class I> ModEvent minus(Space* home, I& i);



      static ModEvent     pme(const Propagator* p);
      static PropModEvent pme(ModEvent me);



      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
      void cancel(Space* home, Propagator* p, PropCond pc);



      void update(Space* home, bool share, ConstIntView& x);
    };

  }


  bool same(const Int::ConstIntView& x, const Int::ConstIntView& y);
  template <class View, unsigned int n>
  bool before(const Int::ConstIntView& x, const Int::ConstIntView& y);

  template<>
  class ViewVarTraits<Int::ConstIntView> {
  public:
    typedef VarBase Var;
  };

  namespace Int {

    class BoolView : public IntView {
      friend class ViewArray<BoolView>;
    public:


      BoolView(void);
      BoolView(const BoolVar& b);
    private:
      BoolView(const IntVar& b);
    public:
      explicit BoolView(const IntView& x);



      bool zero(void) const;
      bool one(void) const;
      bool none(void) const;



      ModEvent t_one(Space* home);
      ModEvent t_zero(Space* home);
      void t_one_none(Space* home);
      void t_zero_none(Space* home);



      void update(Space* home, bool share, BoolView& x);
    };

  }

  template<>
  class ViewVarTraits<Int::BoolView> {
  public:
    typedef Int::IntVarImp Var;
  };

  namespace Int {

    class NegBoolView : public DerivedViewBase<BoolView> {
    protected:
      using DerivedViewBase<BoolView>::view;
    public:


      NegBoolView(void);
      NegBoolView(const BoolView& b);
      void init(const BoolView& b);



      bool zero(void) const;
      bool one(void) const;
      bool none(void) const;



      ModEvent t_one(Space* home);
      ModEvent t_zero(Space* home);
      void t_one_none(Space* home);
      void t_zero_none(Space* home);



      int min(void) const;
      int max(void) const;
      int val(void) const;



      bool assigned(void) const;



      static ModEvent     pme(const Propagator* p);
      static PropModEvent pme(ModEvent me);



      void subscribe(Space* home, Propagator* p, PropCond pc, bool process=true);
      void cancel(Space* home, Propagator* p, PropCond pc);



      void update(Space* home, bool share, NegBoolView& x);
    };

    enum BoolTest {
      BT_NONE, 
      BT_SAME, 
      BT_COMP  
    };


    BoolTest bool_test(const BoolView& b0, const BoolView& b1);
    BoolTest bool_test(const BoolView& b0, const NegBoolView& b1);
    BoolTest bool_test(const NegBoolView& b0, const BoolView& b1);
    BoolTest bool_test(const NegBoolView& b0, const NegBoolView& b1);

  }


  bool same(const Int::NegBoolView& x, const Int::NegBoolView& y);
  bool before(const Int::NegBoolView& x, const Int::NegBoolView& y);

  template<>
  class ViewVarTraits<Int::NegBoolView> {
  public:
    typedef Int::IntVarImp Var;
  };

}

#include "gecode/int/var/int.icc"
#include "gecode/int/var/bool.icc"

#include "gecode/int/view/int.icc"
#include "gecode/int/view/bool.icc"

#include "gecode/int/view/constint.icc"

#include "gecode/int/view/minus.icc"
#include "gecode/int/view/offset.icc"
#include "gecode/int/view/scale.icc"

GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::IntView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::MinusView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::OffsetView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::ConstIntView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::IntScaleView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::DoubleScaleView&);
GECODE_INT_EXPORT std::ostream&
operator<<(std::ostream&, const Gecode::Int::NegBoolView&);


inline std::ostream&
operator<<(std::ostream& os, const Gecode::IntVar& x) {
  Gecode::Int::IntView vx(x);
  return os << vx;
}

namespace Gecode {

  namespace Int {


    enum RelTest {
      RT_FALSE = 0, 
      RT_MAYBE = 1, 
      RT_TRUE  = 2   
    };

    template <class View> RelTest rtest_eq_bnd(View x, View y);
    template <class View> RelTest rtest_eq_dom(View x, View y);
    template <class View> RelTest rtest_eq_bnd(View x, int n);
    template <class View> RelTest rtest_eq_dom(View x, int n);

    template <class View> RelTest rtest_nq_bnd(View x, View y);
    template <class View> RelTest rtest_nq_dom(View x, View y);
    template <class View> RelTest rtest_nq_bnd(View x, int n);
    template <class View> RelTest rtest_nq_dom(View x, int n);

    template <class View> RelTest rtest_lq(View x, View y);
    template <class View> RelTest rtest_lq(View x, int n);

    template <class View> RelTest rtest_le(View x, View y);
    template <class View> RelTest rtest_le(View x, int n);

    template <class View> RelTest rtest_gq(View x, View y);
    template <class View> RelTest rtest_gq(View x, int n);

    template <class View> RelTest rtest_gr(View x, View y);
    template <class View> RelTest rtest_gr(View x, int n);

  }

}

#include "gecode/int/view/rtest.icc"

// STATISTICS: int-var