main page modules namespaces classes files
Gecode home

search for 

rel.hh

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *
 *  Contributing authors:
 *     Gabor Szokoli <szokoli@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *     Gabor Szokoli, 2003
 *
 *  Last modified:
 *     $Date: 2006-08-31 17:36:38 +0200 (Thu, 31 Aug 2006) $ by $Author: schulte $
 *     $Revision: 3579 $
 *
 *  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.
 *
 */

#ifndef __GECODE_INT_REL_HH__
#define __GECODE_INT_REL_HH__

#include "gecode/int.hh"

#include "gecode/iter.hh"

namespace Gecode { namespace Int { namespace Rel {

  /*
   * Equality propagators
   *
   */

  template <class View0,class View1>
  class EqDom :
    public InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM> {
  protected:
    using InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>::x0;
    using InhomBinaryPropagator<View0,PC_INT_DOM,View1,PC_INT_DOM>::x1;

    EqDom(Space* home, bool share, EqDom<View0,View1>& p);
    EqDom(Space* home, View0 x0, View1 x1);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual PropCost cost(void) const;
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View0 x0, View1 x1);
  };

  template <class View0, class View1>
  class EqBnd :
    public InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND> {
  protected:
    using InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>::x0;
    using InhomBinaryPropagator<View0,PC_INT_BND,View1,PC_INT_BND>::x1;

    EqBnd(Space* home, bool share, EqBnd<View0,View1>& p);
    EqBnd(Space* home, View0 x0, View1 x1);
  public:
    EqBnd(Space* home, bool share, Propagator& p, View0 x0, View1 x1);
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View0 x0, View1 x1);
  };

  template <class View>
  class NaryEqDom : public NaryPropagator<View,PC_INT_DOM> {
  protected:
    using NaryPropagator<View,PC_INT_DOM>::x;

    NaryEqDom(Space* home, bool share, NaryEqDom<View>& p);
    NaryEqDom(Space* home, ViewArray<View>&);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual PropCost cost(void) const;
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, ViewArray<View>& x);
  };

  template <class View>
  class NaryEqBnd : public NaryPropagator<View,PC_INT_BND> {
  protected:
    using NaryPropagator<View,PC_INT_BND>::x;

    NaryEqBnd(Space* home, bool share, NaryEqBnd<View>& p);
    NaryEqBnd(Space* home, ViewArray<View>&);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual PropCost cost(void) const;
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, ViewArray<View>& x);
  };

  template <class View, class CtrlView>
  class ReEqDom : public ReBinaryPropagator<View,PC_INT_DOM,CtrlView> {
  protected:
    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::x0;
    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::x1;
    using ReBinaryPropagator<View,PC_INT_DOM,CtrlView>::b;

    ReEqDom(Space* home, bool share, ReEqDom& p);
    ReEqDom(Space* home, View x0, View x1, CtrlView b);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
  };

  template <class View, class CtrlView>
  class ReEqBnd : public ReBinaryPropagator<View,PC_INT_BND,CtrlView> {
  protected:
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x0;
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x1;
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::b;

    ReEqBnd(Space* home, bool share, ReEqBnd& p);
    ReEqBnd(Space* home, View x0, View x1, CtrlView b);
  public:
    virtual Actor*     copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
  };

  template <class View, class CtrlView>
  class ReEqDomInt : public ReUnaryPropagator<View,PC_INT_DOM,CtrlView> {
  protected:
    using ReUnaryPropagator<View,PC_INT_DOM,CtrlView>::x0;
    using ReUnaryPropagator<View,PC_INT_DOM,CtrlView>::b;

    int c;
    ReEqDomInt(Space* home, bool share, ReEqDomInt& p);
    ReEqDomInt(Space* home, View x, int c, CtrlView b);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
  };

  template <class View, class CtrlView>
  class ReEqBndInt : public ReUnaryPropagator<View,PC_INT_BND,CtrlView> {
  protected:
    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::x0;
    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::b;

    int c;
    ReEqBndInt(Space* home, bool share, ReEqBndInt& p);
    ReEqBndInt(Space* home, View x, int c, CtrlView b);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
  };




  /*
   * Disequality propagators
   *
   */

  template <class View>
  class Nq : public BinaryPropagator<View,PC_INT_VAL> {
  protected:
    using BinaryPropagator<View,PC_INT_VAL>::x0;
    using BinaryPropagator<View,PC_INT_VAL>::x1;

    Nq(Space* home, bool share, Nq<View>& p);
    Nq(Space* home, View x0, View x1);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual PropCost cost(void) const;
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1);
  };

  /*
   * Order propagators
   *
   */

  template <class View>
  class Lq : public BinaryPropagator<View,PC_INT_BND> {
  protected:
    using BinaryPropagator<View,PC_INT_BND>::x0;
    using BinaryPropagator<View,PC_INT_BND>::x1;

    Lq(Space* home, bool share, Lq& p);
    Lq(Space* home, View x0, View x1);
  public:
    virtual Actor*     copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1);
  };

  template <class View>
  class Le : public BinaryPropagator<View,PC_INT_BND> {
  protected:
    using BinaryPropagator<View,PC_INT_BND>::x0;
    using BinaryPropagator<View,PC_INT_BND>::x1;

    Le(Space* home, bool share, Le& p);
    Le(Space* home, View x0, View x1);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1);
  };



  /*
   * Reified order propagators
   *
   */

  template <class View, class CtrlView>
  class ReLq : public ReBinaryPropagator<View,PC_INT_BND,CtrlView> {
  protected:
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x0;
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::x1;
    using ReBinaryPropagator<View,PC_INT_BND,CtrlView>::b;

    ReLq(Space* home, bool share, ReLq& p);
    ReLq(Space* home, View x0, View x1, CtrlView b);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x0, View x1, CtrlView b);
  };

  template <class View, class CtrlView>
  class ReLqInt : public ReUnaryPropagator<View,PC_INT_BND,CtrlView> {
  protected:
    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::x0;
    using ReUnaryPropagator<View,PC_INT_BND,CtrlView>::b;

    int c;
    ReLqInt(Space* home, bool share, ReLqInt& p);
    ReLqInt(Space* home, View x, int c, CtrlView b);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, View x, int c, CtrlView b);
   };





  template <class View>
  class Lex : public NaryPropagator<ViewTuple<View,2>,PC_INT_BND> {
  protected:
    using NaryPropagator<ViewTuple<View,2>,PC_INT_BND>::x;

    bool strict;
    Lex(Space* home, bool share, Lex& p);
    Lex(Space* home, ViewArray<ViewTuple<View,2> >& xy, bool strict);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home,
                            ViewArray<ViewTuple<View,2> >& xy, bool strict);
  };


  template<class View>
  class NaryNq : public BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM> {
  protected:
    using BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>::x0;
    using BinaryPropagator<ViewTuple<View,2>,PC_INT_DOM>::x1;
    ViewArray<ViewTuple<View,2> > x;
    NaryNq(Space* home,  ViewArray<ViewTuple<View,2> >& x);
    NaryNq(Space* home, bool share, NaryNq& p);
  public:
    virtual Actor* copy(Space* home, bool share);
    virtual ExecStatus propagate(Space* home);
    static  ExecStatus post(Space* home, ViewArray<ViewTuple<View,2> >& x);
  };


}}}

#include "gecode/int/rel/eq.icc"
#include "gecode/int/rel/nq.icc"
#include "gecode/int/rel/lq-le.icc"
#include "gecode/int/rel/lex.icc"

#endif


// STATISTICS: int-prop