set.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Guido Tack <tack@gecode.org>
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Contributing authors:
 *     Gabor Szokoli <szokoli@gecode.org>
 *
 *  Copyright:
 *     Guido Tack, 2004
 *     Christian Schulte, 2004
 *     Gabor Szokoli, 2004
 *
 *  Last modified:
 *     $Date: 2013-03-07 02:18:29 +0100 (Thu, 07 Mar 2013) $ by $Author: mears $
 *     $Revision: 13455 $
 *
 *  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_SET_HH__
#define __GECODE_SET_HH__

#include <gecode/kernel.hh>
#include <gecode/int.hh>
#include <gecode/iter.hh>

/*
 * Configure linking
 *
 */
#if !defined(GECODE_STATIC_LIBS) && \
    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))

#ifdef GECODE_BUILD_SET
#define GECODE_SET_EXPORT __declspec( dllexport )
#else
#define GECODE_SET_EXPORT __declspec( dllimport )
#endif

#else

#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
#define GECODE_SET_EXPORT __attribute__ ((visibility("default")))
#else
#define GECODE_SET_EXPORT
#endif

#endif

// Configure auto-linking
#ifndef GECODE_BUILD_SET
#define GECODE_LIBRARY_NAME "Set"
#include <gecode/support/auto-link.hpp>
#endif


#include <gecode/set/exception.hpp>

namespace Gecode { namespace Set {

  namespace Limits {
    const int max = (Gecode::Int::Limits::max / 2) - 1;
    const int min = -max;
    const unsigned int card = max-min+1;
    void check(int n, const char* l);
    void check(unsigned int n, const char* l);
    void check(const IntSet& s, const char* l);
  }

}}

#include <gecode/set/limits.hpp>

#include <gecode/set/var-imp.hpp>

namespace Gecode {

  namespace Set {
    class SetView;
  }

  class SetVar : public VarImpVar<Set::SetVarImp> {
    friend class SetVarArray;
    friend class SetVarArgs;
    using VarImpVar<Set::SetVarImp>::x;
  public:


    SetVar(void);
    SetVar(const SetVar& y);
    SetVar(const Set::SetView& y);

    GECODE_SET_EXPORT SetVar(Space& home);

    GECODE_SET_EXPORT
    SetVar(Space& home,int glbMin,int glbMax,int lubMin,int lubMax,
           unsigned int cardMin = 0,
           unsigned int cardMax = Set::Limits::card);

    GECODE_SET_EXPORT
    SetVar(Space& home,const IntSet& glbD,int lubMin,int lubMax,
           unsigned int cardMin = 0,
           unsigned int cardMax = Set::Limits::card);

    GECODE_SET_EXPORT
    SetVar(Space& home,int glbMin,int glbMax,const IntSet& lubD,
           unsigned int cardMin = 0,
           unsigned int cardMax = Set::Limits::card);

    GECODE_SET_EXPORT
    SetVar(Space& home,const IntSet& glbD,const IntSet& lubD,
           unsigned int cardMin = 0,
           unsigned int cardMax = Set::Limits::card);



    unsigned int glbSize(void) const;
    unsigned int lubSize(void) const;
    unsigned int unknownSize(void) const;
    unsigned int cardMin(void) const;
    unsigned int cardMax(void) const;
    int lubMin(void) const;
    int lubMax(void) const;
    int glbMin(void) const;
    int glbMax(void) const;



    bool contains(int i) const;
    bool notContains(int i) const;
  };


  class SetVarGlbRanges {
  private:
    Set::GlbRanges<Set::SetVarImp*> iter;
  public:


    SetVarGlbRanges(void);
    SetVarGlbRanges(const SetVar& x);



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



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

  class SetVarLubRanges {
  private:
    Set::LubRanges<Set::SetVarImp*> iter;
  public:


    SetVarLubRanges(void);
    SetVarLubRanges(const SetVar& x);



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



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

  class SetVarUnknownRanges {
  private:
    Set::UnknownRanges<Set::SetVarImp*> iter;
  public:


    SetVarUnknownRanges(void);
    SetVarUnknownRanges(const SetVar& x);



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



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

  class SetVarGlbValues {
  private:
    Iter::Ranges::ToValues<SetVarGlbRanges> iter;
  public:


    SetVarGlbValues(void);
    SetVarGlbValues(const SetVar& x);



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



    int  val(void) const;
  };

  class SetVarLubValues {
  private:
    Iter::Ranges::ToValues<SetVarLubRanges> iter;
  public:


    SetVarLubValues(void);
    SetVarLubValues(const SetVar& x);



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



    int  val(void) const;
  };

  class SetVarUnknownValues {
  private:
    Iter::Ranges::ToValues<SetVarUnknownRanges> iter;
  public:


    SetVarUnknownValues(void);
    SetVarUnknownValues(const SetVar& x);



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



    int  val(void) const;
  };


  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const SetVar& x);

}

#include <gecode/set/view.hpp>

namespace Gecode {

}

#include <gecode/set/array-traits.hpp>

namespace Gecode {

  class SetVarArgs : public VarArgArray<SetVar> {
  public:


    SetVarArgs(void) {}
    explicit SetVarArgs(int n) : VarArgArray<SetVar>(n) {}
    SetVarArgs(const SetVarArgs& a) : VarArgArray<SetVar>(a) {}
    SetVarArgs(const VarArray<SetVar>& a) : VarArgArray<SetVar>(a) {}
    SetVarArgs(const std::vector<SetVar>& a) : VarArgArray<SetVar>(a) {}
    template<class InputIterator>
    SetVarArgs(InputIterator first, InputIterator last)
    : VarArgArray<SetVar>(first,last) {}
    GECODE_SET_EXPORT
    SetVarArgs(Space& home,int n,int glbMin,int glbMax,
               int lubMin,int lubMax,
               unsigned int minCard = 0,
               unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArgs(Space& home,int n,const IntSet& glb,
               int lubMin, int lubMax,
               unsigned int minCard = 0,
               unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArgs(Space& home,int n,int glbMin,int glbMax,
               const IntSet& lub,
               unsigned int minCard = 0,
               unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArgs(Space& home,int n,
               const IntSet& glb,const IntSet& lub,
               unsigned int minCard = 0,
               unsigned int maxCard = Set::Limits::card);
  };

  class SetVarArray : public VarArray<SetVar> {
  public:


    SetVarArray(void);
    SetVarArray(const SetVarArray&);
    SetVarArray(Space& home, const SetVarArgs&);
    GECODE_SET_EXPORT SetVarArray(Space& home, int n);
    GECODE_SET_EXPORT
    SetVarArray(Space& home,int n,int glbMin,int glbMax,int lubMin,int lubMax,
                unsigned int minCard = 0,
                unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArray(Space& home,int n,const IntSet& glb, int lubMin, int lubMax,
                unsigned int minCard = 0,
                unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArray(Space& home,int n,int glbMin,int glbMax,const IntSet& lub,
                unsigned int minCard = 0,
                unsigned int maxCard = Set::Limits::card);
    GECODE_SET_EXPORT
    SetVarArray(Space& home,int n,
                const IntSet& glb,const IntSet& lub,
                unsigned int minCard = 0,
                unsigned int maxCard = Set::Limits::card);
  };

}

#include <gecode/set/array.hpp>

namespace Gecode {

  enum SetRelType {
    SRT_EQ,   
    SRT_NQ,   
    SRT_SUB,  
    SRT_SUP,  
    SRT_DISJ, 
    SRT_CMPL, 
    SRT_LQ,   
    SRT_LE,   
    SRT_GQ,   
    SRT_GR    
  };

  enum SetOpType {
    SOT_UNION,  
    SOT_DUNION, 
    SOT_INTER,  
    SOT_MINUS   
  };


  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType r, int i);
  GECODE_SET_EXPORT void
  dom(Home home, const SetVarArgs& x, SetRelType r, int i);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType r, int i, int j);
  GECODE_SET_EXPORT void
  dom(Home home, const SetVarArgs& x, SetRelType r, int i, int j);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType r, const IntSet& s);
  GECODE_SET_EXPORT void
  dom(Home home, const SetVarArgs& x, SetRelType r, const IntSet& s);
  GECODE_SET_EXPORT void
  cardinality(Home home, SetVar x, unsigned int i, unsigned int j);
  GECODE_SET_EXPORT void
  cardinality(Home home, const SetVarArgs& x, unsigned int i, unsigned int j);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType rt, int i, Reify r);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType rt, int i, int j, Reify r);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetRelType rt, const IntSet& s, Reify r);
  GECODE_SET_EXPORT void
  dom(Home home, SetVar x, SetVar d);
  GECODE_SET_EXPORT void
  dom(Home home, const SetVarArgs& x, const SetVarArgs& d);



  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetRelType r, SetVar y);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetRelType rt, SetVar y, Reify r);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar s, SetRelType r, IntVar x);

  GECODE_SET_EXPORT void
  rel(Home home, IntVar x, SetRelType r, SetVar s);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar s, SetRelType rt, IntVar x, Reify r);

  GECODE_SET_EXPORT void
  rel(Home home, IntVar x, SetRelType rt, SetVar s, Reify r);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar s, IntRelType r, IntVar x);

  GECODE_SET_EXPORT void
  rel(Home home, IntVar x, IntRelType r, SetVar s);



  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetOpType op, SetVar y, SetRelType r, SetVar z);

  GECODE_SET_EXPORT void
  rel(Home home, SetOpType op, const SetVarArgs& x, SetVar y);

  GECODE_SET_EXPORT void
  rel(Home home, SetOpType op, const SetVarArgs& x, const IntSet& z, SetVar y);

  GECODE_SET_EXPORT void
  rel(Home home, SetOpType op, const IntVarArgs& x, const IntSet& z, SetVar y);

  GECODE_SET_EXPORT void
  rel(Home home, SetOpType op, const IntVarArgs& x, SetVar y);

  GECODE_SET_EXPORT void
  rel(Home home, const IntSet& x, SetOpType op, SetVar y,
      SetRelType r, SetVar z);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetOpType op, const IntSet& y,
      SetRelType r, SetVar z);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetOpType op, SetVar y,
      SetRelType r, const IntSet& z);

  GECODE_SET_EXPORT void
  rel(Home home, const IntSet& x, SetOpType op, SetVar y, SetRelType r,
      const IntSet& z);

  GECODE_SET_EXPORT void
  rel(Home home, SetVar x, SetOpType op, const IntSet& y, SetRelType r,
      const IntSet& z);




  GECODE_SET_EXPORT void
  convex(Home home, SetVar x);

  GECODE_SET_EXPORT void
  convex(Home home, SetVar x, SetVar y);



  GECODE_SET_EXPORT void
  sequence(Home home, const SetVarArgs& x);

  GECODE_SET_EXPORT void
  sequence(Home home, const SetVarArgs& y, SetVar x);




  GECODE_SET_EXPORT void
  atmostOne(Home home, const SetVarArgs& x, unsigned int c);



  GECODE_SET_EXPORT void
  min(Home home, SetVar s, IntVar x);

  GECODE_SET_EXPORT void
  notMin(Home home, SetVar s, IntVar x);

  GECODE_SET_EXPORT void
  min(Home home, SetVar s, IntVar x, Reify r);

  GECODE_SET_EXPORT void
  max(Home home, SetVar s, IntVar x);

  GECODE_SET_EXPORT void
  notMax(Home home, SetVar s, IntVar x);

  GECODE_SET_EXPORT void
  max(Home home, SetVar s, IntVar x, Reify r);

  GECODE_SET_EXPORT void
  cardinality(Home home, SetVar s, IntVar x);

  GECODE_SET_EXPORT void
  weights(Home home, IntSharedArray elements, IntSharedArray weights,
          SetVar x, IntVar y);



  GECODE_SET_EXPORT void
  channel(Home home, const IntVarArgs& x,const SetVarArgs& y);

  GECODE_SET_EXPORT void
  channelSorted(Home home, const IntVarArgs& x, SetVar y);

  GECODE_SET_EXPORT void
  channel(Home home, const BoolVarArgs& x, SetVar y);

  GECODE_SET_EXPORT void
  channel(Home home, const SetVarArgs& x, const SetVarArgs& y);


  GECODE_SET_EXPORT void
  precede(Home home, const SetVarArgs& x, int s, int t);
  GECODE_SET_EXPORT void
  precede(Home home, const SetVarArgs& x, const IntArgs& c);


  GECODE_SET_EXPORT void
  element(Home home, SetOpType op, const SetVarArgs& x, SetVar y, SetVar z,
    const IntSet& u = IntSet(Set::Limits::min,Set::Limits::max));

  GECODE_SET_EXPORT void
  element(Home home, SetOpType op, const IntVarArgs& x, SetVar y, SetVar z,
          const IntSet& u = IntSet(Set::Limits::min,Set::Limits::max));

  GECODE_SET_EXPORT void
  element(Home home, SetOpType op, const IntSetArgs& x, SetVar y, SetVar z,
          const IntSet& u = IntSet(Set::Limits::min,Set::Limits::max));

  GECODE_SET_EXPORT void
  element(Home home, SetOpType op, const IntArgs& x, SetVar y, SetVar z,
          const IntSet& u = IntSet(Set::Limits::min,Set::Limits::max));

  GECODE_SET_EXPORT void
  element(Home home, const SetVarArgs& x, IntVar y, SetVar z);

  GECODE_SET_EXPORT void
  element(Home home, const IntSetArgs& s, IntVar y, SetVar z);

  GECODE_SET_EXPORT void
  element(Home home, const IntSetArgs& a, 
          IntVar x, int w, IntVar y, int h, SetVar z);
  GECODE_SET_EXPORT void
  element(Home home, const SetVarArgs& a, 
          IntVar x, int w, IntVar y, int h, SetVar z);


  GECODE_SET_EXPORT void
  wait(Home home, SetVar x, void (*c)(Space& home));
  GECODE_SET_EXPORT void
  wait(Home home, const SetVarArgs& x, void (*c)(Space& home));

}

namespace Gecode {

  typedef bool (*SetBranchFilter)(const Space& home, SetVar x, int i);

  typedef double (*SetBranchMerit)(const Space& home, SetVar x, int i);

  typedef int (*SetBranchVal)(const Space& home, SetVar x, int i);

  typedef void (*SetBranchCommit)(Space& home, unsigned int a,
                                  SetVar x, int i, int n);

}

#include <gecode/set/branch/traits.hpp>

namespace Gecode {

  class SetAFC : public AFC {
  public:
    SetAFC(void);
    SetAFC(const SetAFC& a);
    SetAFC& operator =(const SetAFC& a);      
    SetAFC(Home home, const SetVarArgs& x, double d=1.0);
    void init(Home, const SetVarArgs& x, double d=1.0);
  };

}

#include <gecode/set/branch/afc.hpp>

namespace Gecode {


  class SetActivity : public Activity {
  public:
    SetActivity(void);
    SetActivity(const SetActivity& a);
    SetActivity& operator =(const SetActivity& a);      
    GECODE_SET_EXPORT 
    SetActivity(Home home, const SetVarArgs& x, double d=1.0);
    GECODE_SET_EXPORT void
    init(Home, const SetVarArgs& x, double d=1.0);
  };

}

#include <gecode/set/branch/activity.hpp>

namespace Gecode {

  class SetVarBranch : public VarBranch {
  public:
    enum Select {
      SEL_NONE = 0,        
      SEL_RND,             
      SEL_MERIT_MIN,       
      SEL_MERIT_MAX,       
      SEL_DEGREE_MIN,      
      SEL_DEGREE_MAX,      
      SEL_AFC_MIN,         
      SEL_AFC_MAX,         
      SEL_ACTIVITY_MIN,    
      SEL_ACTIVITY_MAX,    
      SEL_MIN_MIN,         
      SEL_MIN_MAX,         
      SEL_MAX_MIN,         
      SEL_MAX_MAX,         
      SEL_SIZE_MIN,        
      SEL_SIZE_MAX,        
      SEL_DEGREE_SIZE_MIN, 
      SEL_DEGREE_SIZE_MAX, 
      SEL_AFC_SIZE_MIN,    
      SEL_AFC_SIZE_MAX,    
      SEL_ACTIVITY_SIZE_MIN, 
      SEL_ACTIVITY_SIZE_MAX, 
    };
  protected:
    Select s;
  public:
    SetVarBranch(void);
    SetVarBranch(Rnd r);
    SetVarBranch(Select s, BranchTbl t);
    SetVarBranch(Select s, double d, BranchTbl t);
    SetVarBranch(Select s, AFC a, BranchTbl t);
    SetVarBranch(Select s, Activity a, BranchTbl t);
    SetVarBranch(Select s, VoidFunction mf, BranchTbl t);
    Select select(void) const;
    void expand(Home home, const SetVarArgs& x);
  };


  SetVarBranch SET_VAR_NONE(void);
  SetVarBranch SET_VAR_RND(Rnd r);
  SetVarBranch SET_VAR_MERIT_MIN(SetBranchMerit bm, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_MERIT_MAX(SetBranchMerit bm, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_DEGREE_MIN(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_DEGREE_MAX(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_MIN(SetAFC a, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_MAX(SetAFC a, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_ACTIVITY_MIN(double d=1.0, BranchTbl tbl=NULL);    
  SetVarBranch SET_VAR_ACTIVITY_MIN(SetActivity a, BranchTbl tbl=NULL);    
  SetVarBranch SET_VAR_ACTIVITY_MAX(double d=1.0, BranchTbl tbl=NULL);     
  SetVarBranch SET_VAR_ACTIVITY_MAX(SetActivity a, BranchTbl tbl=NULL);     
  SetVarBranch SET_VAR_MIN_MIN(BranchTbl tbl=NULL);         
  SetVarBranch SET_VAR_MIN_MAX(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_MAX_MIN(BranchTbl tbl=NULL); 
  SetVarBranch SET_VAR_MAX_MAX(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_SIZE_MIN(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_SIZE_MAX(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_SIZE_MIN(SetAFC a, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_AFC_SIZE_MAX(SetAFC a, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_ACTIVITY_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_ACTIVITY_SIZE_MIN(SetActivity a, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_ACTIVITY_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  SetVarBranch SET_VAR_ACTIVITY_SIZE_MAX(SetActivity a, BranchTbl tbl=NULL);

}

#include <gecode/set/branch/var.hpp>

namespace Gecode {

  class SetValBranch : public ValBranch {
  public:
    enum Select {
      SEL_MIN_INC,   
      SEL_MIN_EXC,   
      SEL_MED_INC,   
      SEL_MED_EXC,   
      SEL_MAX_INC,   
      SEL_MAX_EXC,   
      SEL_RND_INC,   
      SEL_RND_EXC,   
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    SetValBranch(Select s = SEL_MIN_INC);
    SetValBranch(Select s, Rnd r);
    SetValBranch(VoidFunction v, VoidFunction c);
    Select select(void) const;
  };


  SetValBranch SET_VAL_MIN_INC(void);
  SetValBranch SET_VAL_MIN_EXC(void);
  SetValBranch SET_VAL_MED_INC(void);
  SetValBranch SET_VAL_MED_EXC(void);
  SetValBranch SET_VAL_MAX_INC(void);
  SetValBranch SET_VAL_MAX_EXC(void);
  SetValBranch SET_VAL_RND_INC(Rnd r);
  SetValBranch SET_VAL_RND_EXC(Rnd r);
  SetValBranch SET_VAL(SetBranchVal v, SetBranchCommit c=NULL);

}

#include <gecode/set/branch/val.hpp>

namespace Gecode {

  class SetAssign : public ValBranch {
  public:
    enum Select {
      SEL_MIN_INC,   
      SEL_MIN_EXC,   
      SEL_MED_INC,   
      SEL_MED_EXC,   
      SEL_MAX_INC,   
      SEL_MAX_EXC,   
      SEL_RND_INC,   
      SEL_RND_EXC,   
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    SetAssign(Select s = SEL_MIN_INC);
    SetAssign(Select s, Rnd r);
    SetAssign(VoidFunction v, VoidFunction c);
    Select select(void) const;
  };


  SetAssign SET_ASSIGN_MIN_INC(void);
  SetAssign SET_ASSIGN_MIN_EXC(void);
  SetAssign SET_ASSIGN_MED_INC(void);
  SetAssign SET_ASSIGN_MED_EXC(void);
  SetAssign SET_ASSIGN_MAX_INC(void);
  SetAssign SET_ASSIGN_MAX_EXC(void);
  SetAssign SET_ASSIGN_RND_INC(Rnd r);
  SetAssign SET_ASSIGN_RND_EXC(Rnd r);
  SetAssign SET_ASSIGN(SetBranchVal v, SetBranchCommit c=NULL);

}

#include <gecode/set/branch/assign.hpp>

namespace Gecode {

  GECODE_SET_EXPORT BrancherHandle
  branch(Home home, const SetVarArgs& x,
         SetVarBranch vars, SetValBranch vals, 
         SetBranchFilter sbf=NULL);
  GECODE_SET_EXPORT BrancherHandle
  branch(Home home, const SetVarArgs& x,
         TieBreak<SetVarBranch> vars, SetValBranch vals,
         SetBranchFilter sbf=NULL);
  GECODE_SET_EXPORT BrancherHandle
  branch(Home home, SetVar x, SetValBranch vals);
  GECODE_SET_EXPORT BrancherHandle
  assign(Home home, const SetVarArgs& x, SetAssign vals,
         SetBranchFilter sbf=NULL);
  GECODE_SET_EXPORT BrancherHandle
  assign(Home home, SetVar x, SetAssign vals);

}

// LDSB-related declarations.
namespace Gecode {
  GECODE_SET_EXPORT SymmetryHandle VariableSymmetry(const SetVarArgs& x);
  GECODE_SET_EXPORT
  SymmetryHandle VariableSequenceSymmetry(const SetVarArgs& x, int ss);
  GECODE_SET_EXPORT BrancherHandle
  branch(Home home, const SetVarArgs& x,
         SetVarBranch vars, SetValBranch vals,
         const Symmetries& syms,
         SetBranchFilter sbf=NULL);
  GECODE_SET_EXPORT BrancherHandle
  branch(Home home, const SetVarArgs& x,
         TieBreak<SetVarBranch> vars, SetValBranch vals,
         const Symmetries& syms, SetBranchFilter bf=NULL);
}

#endif

// IFDEF: GECODE_HAS_SET_VARS
// STATISTICS: set-post