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: 2017-04-01 20:27:10 +0200 (Sat, 01 Apr 2017) $ by $Author: schulte $
 *     $Revision: 15623 $
 *
 *  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>

#include <functional>

/*
 * 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);
    SetVarArgs(const SetVarArgs& a);
    SetVarArgs(const VarArray<SetVar>& a);
    SetVarArgs(const std::vector<SetVar>& a);
    template<class InputIterator>
    SetVarArgs(InputIterator first, InputIterator 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 rt, IntVar x);

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

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

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

}

#include <gecode/set/int.hpp>

namespace Gecode {


  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
  ite(Home home, BoolVar b, SetVar x, SetVar y, SetVar 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
  cardinality(Home home, SetVar s, IntVar x, Reify r);

  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, std::function<void(Space& home)> c);
  GECODE_SET_EXPORT void
  wait(Home home, const SetVarArgs& x,
       std::function<void(Space& home)> c);

}

namespace Gecode {

  typedef std::function<bool(const Space& home, SetVar x, int i)>
    SetBranchFilter;
  typedef std::function<double(const Space& home, SetVar x, int i)>
    SetBranchMerit;

  typedef std::function<int(const Space& home, SetVar x, int i)>
    SetBranchVal;

  typedef std::function<void(Space& home, unsigned int a,
                             SetVar x, int i, int n)>
    SetBranchCommit;

}

#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 home, const SetVarArgs& x, double d=1.0);
  };

}

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

namespace Gecode {


  class SetAction : public Action {
  public:
    SetAction(void);
    SetAction(const SetAction& a);
    SetAction& operator =(const SetAction& a);
    GECODE_SET_EXPORT
    SetAction(Home home, const SetVarArgs& x, double d=1.0,
                SetBranchMerit bm=nullptr);
    GECODE_SET_EXPORT void
    init(Home home, const SetVarArgs& x, double d=1.0,
         SetBranchMerit bm=nullptr);
  };

}

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

namespace Gecode {

  class SetCHB : public CHB {
  public:
    SetCHB(void);
    SetCHB(const SetCHB& chb);
    SetCHB& operator =(const SetCHB& chb);
    GECODE_SET_EXPORT
    SetCHB(Home home, const SetVarArgs& x, SetBranchMerit bm=nullptr);
    GECODE_SET_EXPORT void
    init(Home home, const SetVarArgs& x, SetBranchMerit bm=nullptr);
  };

}

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

namespace Gecode {

  typedef std::function<void(const Space &home, const Brancher& b,
                             unsigned int a,
                             SetVar x, int i, const int& n,
                             std::ostream& o)>
    SetVarValPrint;

}

namespace Gecode {

  class SetVarBranch : public VarBranch<SetVar> {
  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_ACTION_MIN,      
      SEL_ACTION_MAX,      
      SEL_CHB_MIN,         
      SEL_CHB_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_ACTION_SIZE_MIN, 
      SEL_ACTION_SIZE_MAX, 
      SEL_CHB_SIZE_MIN,    
      SEL_CHB_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, SetAFC a, BranchTbl t);
    SetVarBranch(Select s, SetAction a, BranchTbl t);
    SetVarBranch(Select s, SetCHB c, BranchTbl t);
    SetVarBranch(Select s, SetBranchMerit 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=nullptr);
  SetVarBranch SET_VAR_MERIT_MAX(SetBranchMerit bm, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_DEGREE_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_DEGREE_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_MIN(SetAFC a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_MAX(SetAFC a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_MIN(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_MIN(SetAction a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_MAX(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_MAX(SetAction a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_MIN(SetCHB c, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_MAX(SetCHB c, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_MIN_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_MIN_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_MAX_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_MAX_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_SIZE_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_SIZE_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_SIZE_MIN(SetAFC a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_AFC_SIZE_MAX(SetAFC a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_SIZE_MIN(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_SIZE_MIN(SetAction a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_SIZE_MAX(double d=1.0, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_ACTION_SIZE_MAX(SetAction a, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_SIZE_MIN(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_SIZE_MIN(SetCHB c, BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_SIZE_MAX(BranchTbl tbl=nullptr);
  SetVarBranch SET_VAR_CHB_SIZE_MAX(SetCHB c, BranchTbl tbl=nullptr);

}

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

namespace Gecode {

  class SetValBranch : public ValBranch<SetVar> {
  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(SetBranchVal v, SetBranchCommit 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=nullptr);

}

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

namespace Gecode {

  class SetAssign : public ValBranch<SetVar> {
  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(SetBranchVal v, SetBranchCommit 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=nullptr);

}

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

namespace Gecode {

  GECODE_SET_EXPORT void
  branch(Home home, const SetVarArgs& x,
         SetVarBranch vars, SetValBranch vals,
         SetBranchFilter bf=nullptr,
         SetVarValPrint vvp=nullptr);
  GECODE_SET_EXPORT void
  branch(Home home, const SetVarArgs& x,
         TieBreak<SetVarBranch> vars, SetValBranch vals,
         SetBranchFilter bf=nullptr,
         SetVarValPrint vvp=nullptr);
  GECODE_SET_EXPORT void
  branch(Home home, SetVar x, SetValBranch vals,
         SetVarValPrint vvp=nullptr);
  GECODE_SET_EXPORT void
  assign(Home home, const SetVarArgs& x, SetAssign vals,
         SetBranchFilter bf=nullptr,
         SetVarValPrint vvp=nullptr);
  GECODE_SET_EXPORT void
  assign(Home home, SetVar x, SetAssign vals,
         SetVarValPrint vvp=nullptr);

}

// 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 void
  branch(Home home, const SetVarArgs& x,
         SetVarBranch vars, SetValBranch vals,
         const Symmetries& syms,
         SetBranchFilter bf=nullptr,
         SetVarValPrint vvp=nullptr);
  GECODE_SET_EXPORT void
  branch(Home home, const SetVarArgs& x,
         TieBreak<SetVarBranch> vars, SetValBranch vals,
         const Symmetries& syms,
         SetBranchFilter bf=nullptr,
         SetVarValPrint vvp=nullptr);
}

namespace Gecode {

  /*
   * \brief Relaxed assignment of variables in \a x from values in \a sx
   *
   * The variables in \a x are assigned values from the assigned variables
   * in the solution \a sx with a relaxation probability \a p. That is,
   * if \$fp=0.1\f$ approximately 10% of the variables in \a x will be
   * assigned a value from \a sx.
   *
   * The random numbers are generated from the generator \a r. At least
   * one variable will not be assigned: in case the relaxation attempt
   * would suggest that all variables should be assigned, a single
   * variable will be selected randomly to remain unassigned.
   *
   * Throws an exception of type Set::ArgumentSizeMismatch, if \a x and
   * \a sx are of different size.
   *
   * Throws an exception of type Set::OutOfLimits, if \a p is not between
   * \a 0.0 and \a 1.0.
   *
   * \ingroup TaskModeSet
   */
  GECODE_SET_EXPORT void
  relax(Home home, const SetVarArgs& x, const SetVarArgs& sx,
        Rnd r, double p);

}

#include <gecode/set/trace/trace-view.hpp>

namespace Gecode {

  class SetTraceDelta {
  protected:
  public:
    class Glb
      : public Iter::Ranges::Diff<Set::GlbRanges<Set::SetView>,
                                  Iter::Ranges::RangeList> {
    protected:
      Iter::Ranges::RangeList o;
      Set::GlbRanges<Set::SetView> n;
    public:


      Glb(RangeList* o, Set::SetView n);
    };
    Glb _glb;
    class Lub
      : public Iter::Ranges::Diff<Iter::Ranges::RangeList,
                                  Set::LubRanges<Set::SetView> > {
    protected:
      Iter::Ranges::RangeList o;
      Set::LubRanges<Set::SetView> n;
    public:


      Lub(RangeList* o, Set::SetView n);
    };
    Lub _lub;


    SetTraceDelta(Set::SetTraceView o, Set::SetView n, const Delta& d);



    Glb& glb(void);
    Lub& lub(void);
  };

}

#include <gecode/set/trace/delta.hpp>

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

namespace Gecode {

  typedef ViewTracer<Set::SetView> SetTracer;
  typedef ViewTraceRecorder<Set::SetView> SetTraceRecorder;

  class GECODE_SET_EXPORT StdSetTracer : public SetTracer {
  protected:
    std::ostream& os;
  public:
    StdSetTracer(std::ostream& os0 = std::cerr);
    virtual void init(const Space& home, const SetTraceRecorder& t);
    virtual void prune(const Space& home, const SetTraceRecorder& t,
                       const ViewTraceInfo& vti, int i, SetTraceDelta& d);
    virtual void fix(const Space& home, const SetTraceRecorder& t);
    virtual void fail(const Space& home, const SetTraceRecorder& t);
    virtual void done(const Space& home, const SetTraceRecorder& t);
    static StdSetTracer def;
  };


  GECODE_SET_EXPORT void
  trace(Home home, const SetVarArgs& x,
        TraceFilter tf,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        SetTracer& t = StdSetTracer::def);
  void
  trace(Home home, const SetVarArgs& x,
        int te = (TE_INIT | TE_PRUNE | TE_FIX | TE_FAIL | TE_DONE),
        SetTracer& t = StdSetTracer::def);

}

#include <gecode/set/trace.hpp>

#endif

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