view.icc

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2005
 *
 *  Last modified:
 *     $Date: 2008-07-11 09:39:08 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
 *     $Revision: 7297 $
 *
 *  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.
 *
 */

#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 VarViewBase<IntVarImp> {
    protected:
      using VarViewBase<IntVarImp>::varimp;
    public:


      IntView(void);
      IntView(const IntVar& x);
      IntView(IntVarImp* x);
      IntView(Space* home, const Reflection::VarMap& vars,
              Reflection::Arg* arg);



      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



      static ModEventDelta med(ModEvent me);



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
      
    };

  }

  template<>
  class ViewVarImpTraits<Int::IntView> {
  public:
    typedef Int::IntVarImp VarImp;
  };

  template<>
  class VarViewTraits<IntVar> {
  public:
    typedef Int::IntView View;
  };

  template<>
  class DomainSize<Int::IntView> {
  public:
    static int size(const Int::IntView& iv) { return iv.size(); }
  };

  namespace Int {

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


      MinusView(void);
      MinusView(const IntView& x);
      MinusView(Space* home, const Reflection::VarMap& vars,
                Reflection::Arg* arg);
      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

  }


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

  template<>
  class ViewVarImpTraits<Int::MinusView> {
  public:
    typedef Int::IntVarImp VarImp;
  };


  namespace Int {

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


      OffsetView(void);
      OffsetView(const IntView& x, int c);
      OffsetView(Space* home, const Reflection::VarMap& vars,
                 Reflection::Arg* arg);
      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

  }


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

  template<>
  class ViewVarImpTraits<Int::OffsetView> {
  public:
    typedef Int::IntVarImp VarImp;
  };



  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);
      ScaleView(Space* home, const Reflection::VarMap& vars,
                Reflection::Arg* arg);
      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 void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      Val min(const Delta* d) const;
      Val max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

    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 ViewVarImpTraits<Int::ScaleView<Val,UnsVal> > {
  public:
    typedef Int::IntVarImp VarImp;
  };



  namespace Int {

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


      ConstIntView(void);
      ConstIntView(int n);
      void init(int n);
      ConstIntView(Space* home, const Reflection::VarMap& vars,
                   Reflection::Arg* arg);



      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

  }


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

  template<>
  class ViewVarImpTraits<Int::ConstIntView> {
  public:
    typedef VarImpBase VarImp;
  };

  namespace Int {

    class ZeroIntView : public ConstViewBase {
    public:


      ZeroIntView(void);
      void init(void);
      ZeroIntView(Space* home, const Reflection::VarMap& vars,
                  Reflection::Arg* arg);



      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

  }


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

  template<>
  class ViewVarImpTraits<Int::ZeroIntView> {
  public:
    typedef VarImpBase VarImp;
  };

  namespace Int {

    class BoolView : public VarViewBase<BoolVarImp> {
    protected:
      using VarViewBase<BoolVarImp>::varimp;
    public:


      BoolView(void);
      BoolView(const BoolVar& x);
      BoolView(BoolVarImp* x);
      BoolView(Space* home, const Reflection::VarMap& vars,
               Reflection::Arg* arg);



      static const int BITS = BoolVarImp::BITS;
      static const BoolStatus ZERO = BoolVarImp::ZERO;
      static const BoolStatus ONE  = BoolVarImp::ONE;
      static const BoolStatus NONE = BoolVarImp::NONE;
      BoolStatus status(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;



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



      ModEvent one(Space* home);
      ModEvent zero(Space* home);
      ModEvent one_none(Space* home);
      ModEvent zero_none(Space* home);



      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_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_r(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent narrow_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent inter_v(Space* home, I& i, bool depends=true);
      template <class I> 
      ModEvent minus_v(Space* home, I& i, bool depends=true);



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



      static ModEventDelta med(ModEvent me);



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

  }

  template<>
  class ViewVarImpTraits<Int::BoolView> {
  public:
    typedef Int::BoolVarImp VarImp;
  };

  template<>
  class VarViewTraits<BoolVar> {
  public:
    typedef Int::BoolView View;
  };

  template<>
  class DomainSize<Int::BoolView> {
  public:
    static int size(const Int::BoolView& iv) { return iv.size(); }
  };

  namespace Int {

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


      NegBoolView(void);
      NegBoolView(const BoolView& b);
      void init(const BoolView& b);
      NegBoolView(Space* home, const Reflection::VarMap& vars,
                  Reflection::Arg* arg);



      static const int BITS = BoolView::BITS;
      static const BoolStatus ZERO = BoolView::ONE;
      static const BoolStatus ONE  = BoolView::ZERO;
      static const BoolStatus NONE = BoolView::NONE;
      BoolStatus status(void) const;



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



      ModEvent one(Space* home);
      ModEvent zero(Space* home);
      ModEvent one_none(Space* home);
      ModEvent zero_none(Space* home);



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



      bool assigned(void) const;



      static void schedule(Space* home, Propagator* p, ModEvent me);
      static ModEvent me(ModEventDelta med);
      static ModEventDelta med(ModEvent me);



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



      static ModEvent modevent(const Delta* d);
      int min(const Delta* d) const;
      int max(const Delta* d) const;
      bool any(const Delta* d) const;



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


      Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
      static Support::Symbol type(void);
    };

    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 ViewVarImpTraits<Int::NegBoolView> {
  public:
    typedef Int::BoolVarImp VarImp;
  };

}

#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/zero.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::ZeroIntView&);
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::BoolView&);
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;
}

inline std::ostream&
operator<<(std::ostream& os, const Gecode::BoolVar& x) {
  Gecode::Int::BoolView 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