int.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *
 *  Contributing authors:
 *     Stefano Gualandi <stefano.gualandi@gmail.com>
 *     Mikael Lagerkvist <lagerkvist@gecode.org>
 *     David Rijsman <David.Rijsman@quintiq.com>
 *
 *  Copyright:
 *     Stefano Gualandi, 2013
 *     Mikael Lagerkvist, 2006
 *     David Rijsman, 2009
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  Last modified:
 *     $Date: 2015-01-16 14:10:48 +0100 (Fri, 16 Jan 2015) $ by $Author: schulte $
 *     $Revision: 14362 $
 *
 *  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_INT_HH__
#define __GECODE_INT_HH__

#include <climits>
#include <cfloat>
#include <iostream>

#include <vector>

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

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

#ifdef GECODE_BUILD_INT
#define GECODE_INT_EXPORT __declspec( dllexport )
#else
#define GECODE_INT_EXPORT __declspec( dllimport )
#endif

#else

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

#endif

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

#include <gecode/int/exception.hpp>

namespace Gecode { namespace Int {

  namespace Limits {
    const int max = INT_MAX - 1;
    const int min = -max;
    const int infinity = max + 1;
    const long long int llmax =  LLONG_MAX - 1;
    const long long int llmin = -llmax;
    const long long int llinfinity = llmax + 1;
    bool valid(int n);
    bool valid(long long int n);
    void check(int n, const char* l);
    void check(long long int n, const char* l);
    void positive(int n, const char* l);
    void positive(long long int n, const char* l);
    void nonnegative(int n, const char* l);
    void nonnegative(long long int n, const char* l);
    bool overflow_add(int n, int m);
    bool overflow_add(long long int n, long long int m);
    bool overflow_sub(int n, int m);
    bool overflow_sub(long long int n, long long int m);
    bool overflow_mul(int n, int m);
    bool overflow_mul(long long int n, long long int m);
  }

}}

#include <gecode/int/limits.hpp>

namespace Gecode {

  class IntSetRanges;

  template<class I> class IntSetInit;
  
  class IntSet : public SharedHandle {
    friend class IntSetRanges;
    template<class I> friend class IntSetInit;
  private:
    class Range {
    public:
      int min, max;
    };
    class IntSetObject : public SharedHandle::Object {
    public:
      unsigned int size;
      int n;
      Range* r;
      GECODE_INT_EXPORT static IntSetObject* allocate(int m);
      GECODE_INT_EXPORT SharedHandle::Object* copy(void) const;
      GECODE_INT_EXPORT bool in(int n) const;
      GECODE_INT_EXPORT virtual ~IntSetObject(void);
    };
    class MinInc;
    GECODE_INT_EXPORT void normalize(Range* r, int n);
    GECODE_INT_EXPORT void init(int n, int m);
    GECODE_INT_EXPORT void init(const int r[], int n);
    GECODE_INT_EXPORT void init(const int r[][2], int n);
  public:


    IntSet(void);
    IntSet(int n, int m);
    IntSet(const int r[],   int n);
    IntSet(const int r[][2], int n);
    template<class I>
    explicit IntSet(I& i);
    template<class I>
    explicit IntSet(const I& i);



    int ranges(void) const;
    int min(int i) const;
    int max(int i) const;
    unsigned int width(int i) const;



    bool in(int n) const;
    unsigned int size(void) const;
    unsigned int width(void) const;
    int min(void) const;
    int max(void) const;



    GECODE_INT_EXPORT static const IntSet empty;
  };

  class IntSetRanges {
  private:
    const IntSet::Range* i;
    const IntSet::Range* e;
  public:


    IntSetRanges(void);
    IntSetRanges(const IntSet& s);
    void init(const IntSet& s);



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



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

  class IntSetValues : public Iter::Ranges::ToValues<IntSetRanges> {
  public:


    IntSetValues(void);
    IntSetValues(const IntSet& s);
    void init(const IntSet& s);
  };

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

}

#include <gecode/int/int-set-1.hpp>

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

namespace Gecode {

  namespace Int {
    class IntView;
  }

  class IntVar : public VarImpVar<Int::IntVarImp> {
    friend class IntVarArray;
    friend class IntVarArgs;
  private:
    using VarImpVar<Int::IntVarImp>::x;
    void _init(Space& home, int min, int max);
    void _init(Space& home, const IntSet& d);
  public:


    IntVar(void);
    IntVar(const IntVar& y);
    IntVar(const Int::IntView& y);
    GECODE_INT_EXPORT IntVar(Space& home, int min, int max);
    GECODE_INT_EXPORT IntVar(Space& home, const IntSet& d);



    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 in(int n) const;
  };

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

  class IntVarRanges : public Int::IntVarImpFwd {
  public:


    IntVarRanges(void);
    IntVarRanges(const IntVar& x);
    void init(const IntVar& x);
  };

  class IntVarValues : public Iter::Ranges::ToValues<IntVarRanges> {
  public:


    IntVarValues(void);
    IntVarValues(const IntVar& x);
    void init(const IntVar& x);
  };

  namespace Int {
    class BoolView;
  }

  class BoolVar : public VarImpVar<Int::BoolVarImp> {
    friend class BoolVarArray;
    friend class BoolVarArgs;
  private:
    using VarImpVar<Int::BoolVarImp>::x;
    void _init(Space& home, int min, int max);
  public:


    BoolVar(void);
    BoolVar(const BoolVar& y);
    BoolVar(const Int::BoolView& y);
    GECODE_INT_EXPORT BoolVar(Space& home, int min, int max);



    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 in(int n) const;



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

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

}


#include <gecode/int/view.hpp>
#include <gecode/int/propagator.hpp>

namespace Gecode {


  typedef ArgArray<IntSet> IntSetArgs;

}

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

namespace Gecode {

  class IntArgs : public PrimArgArray<int> {
  public:


    IntArgs(void);
    explicit IntArgs(int n);
    IntArgs(const SharedArray<int>& x);
    IntArgs(const std::vector<int>& x);
    template<class InputIterator>
    IntArgs(InputIterator first, InputIterator last);
    GECODE_INT_EXPORT
    IntArgs(int n, int e0, ...);
    IntArgs(int n, const int* e);
    IntArgs(const PrimArgArray<int>& a);

    static IntArgs create(int n, int start, int inc=1);
  };

  class IntVarArgs : public VarArgArray<IntVar> {
  public:


    IntVarArgs(void) {}
    explicit IntVarArgs(int n) : VarArgArray<IntVar>(n) {}
    IntVarArgs(const IntVarArgs& a) : VarArgArray<IntVar>(a) {}
    IntVarArgs(const VarArray<IntVar>& a) : VarArgArray<IntVar>(a) {}
    IntVarArgs(const std::vector<IntVar>& a) : VarArgArray<IntVar>(a) {}
    template<class InputIterator>
    IntVarArgs(InputIterator first, InputIterator last)
    : VarArgArray<IntVar>(first,last) {}
    GECODE_INT_EXPORT
    IntVarArgs(Space& home, int n, int min, int max);
    GECODE_INT_EXPORT
    IntVarArgs(Space& home, int n, const IntSet& s);
  };
  class BoolVarArgs : public VarArgArray<BoolVar> {
  public:


    BoolVarArgs(void) {}
    explicit BoolVarArgs(int n) : VarArgArray<BoolVar>(n) {}
    BoolVarArgs(const BoolVarArgs& a) : VarArgArray<BoolVar>(a) {}
    BoolVarArgs(const VarArray<BoolVar>& a)
     : VarArgArray<BoolVar>(a) {}
    BoolVarArgs(const std::vector<BoolVar>& a) : VarArgArray<BoolVar>(a) {}
    template<class InputIterator>
    BoolVarArgs(InputIterator first, InputIterator last)
    : VarArgArray<BoolVar>(first,last) {}
    GECODE_INT_EXPORT
    BoolVarArgs(Space& home, int n, int min, int max);
  };

  class IntVarArray : public VarArray<IntVar> {
  public:


    IntVarArray(void);
    IntVarArray(Space& home, int n);
    IntVarArray(const IntVarArray& a);
    IntVarArray(Space& home, const IntVarArgs& a);
    GECODE_INT_EXPORT
    IntVarArray(Space& home, int n, int min, int max);
    GECODE_INT_EXPORT
    IntVarArray(Space& home, int n, const IntSet& s);
  };

  class BoolVarArray : public VarArray<BoolVar> {
  public:


    BoolVarArray(void);
    BoolVarArray(Space& home, int n);
    BoolVarArray(const BoolVarArray& a);
    BoolVarArray(Space& home, const BoolVarArgs& a);
    GECODE_INT_EXPORT
    BoolVarArray(Space& home, int n, int min, int max);
  };

}

#include <gecode/int/int-set-2.hpp>

#include <gecode/int/array.hpp>

namespace Gecode {

  enum ReifyMode {
    RM_EQV,
    RM_IMP,
    RM_PMI
  };

  class Reify {
  protected:
    BoolVar x;
    ReifyMode rm;
  public:
    Reify(void);
    Reify(BoolVar x, ReifyMode rm=RM_EQV);
    BoolVar var(void) const;
    ReifyMode mode(void) const;
    void var(BoolVar x);
    void mode(ReifyMode rm);
  };

  Reify eqv(BoolVar x);
  
  Reify imp(BoolVar x);
  
  Reify pmi(BoolVar x);

}
  
#include <gecode/int/reify.hpp>

namespace Gecode {

  enum IntRelType {
    IRT_EQ, 
    IRT_NQ, 
    IRT_LQ, 
    IRT_LE, 
    IRT_GQ, 
    IRT_GR  
  };

  enum BoolOpType {
    BOT_AND, 
    BOT_OR,  
    BOT_IMP, 
    BOT_EQV, 
    BOT_XOR  
  };

  enum IntConLevel {
    ICL_VAL, 
    ICL_BND, 
    ICL_DOM, 
    ICL_DEF  
  };

  enum TaskType {
    TT_FIXP, //< Task with fixed processing time
    TT_FIXS, //< Task with fixed start time
    TT_FIXE  //< Task with fixed end time
  };

  typedef PrimArgArray<TaskType> TaskTypeArgs;

  template<>
  class ArrayTraits<PrimArgArray<TaskType> > {
  public:
    typedef TaskTypeArgs StorageType;
    typedef TaskType     ValueType;
    typedef TaskTypeArgs ArgsType;
  };



  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int n,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, int n,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int l, int m,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, int l, int m,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, const IntSet& s,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, const IntSet& s,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int n, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, int l, int m, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, const IntSet& s, Reify r,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  dom(Home home, IntVar x, IntVar d,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, BoolVar x, BoolVar d,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const IntVarArgs& x, const IntVarArgs& d,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  dom(Home home, const BoolVarArgs& x, const BoolVarArgs& d,
      IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  rel(Home home, IntVar x0, IntRelType irt, IntVar x1,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, IntVar y,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x, IntRelType irt, int c,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, int c,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x0, IntRelType irt, IntVar x1, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, IntVar x, IntRelType irt, int c, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const IntVarArgs& x, IntRelType irt, const IntVarArgs& y,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, IntRelType irt, BoolVar x1, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, BoolVar y,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x, IntRelType irt, int n,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x, IntRelType irt, int n, Reify r,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, int n,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt, const BoolVarArgs& y,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, const BoolVarArgs& x, IntRelType irt,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, BoolVar x2,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolVar x0, BoolOpType o, BoolVar x1, int n,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolOpType o, const BoolVarArgs& x, BoolVar y,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  rel(Home home, BoolOpType o, const BoolVarArgs& x, int n,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
         BoolVar z, IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  clause(Home home, BoolOpType o, const BoolVarArgs& x, const BoolVarArgs& y,
         int n, IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  ite(Home home, BoolVar b, IntVar x, IntVar y, IntVar z,
      IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  precede(Home home, const IntVarArgs& x, int s, int t,
          IntConLevel=ICL_DEF);
  GECODE_INT_EXPORT void
  precede(Home home, const IntVarArgs& x, const IntArgs& c,
          IntConLevel=ICL_DEF);



  GECODE_INT_EXPORT void
  member(Home home, const IntVarArgs& x, IntVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const BoolVarArgs& x, BoolVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const IntVarArgs& x, IntVar y, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  member(Home home, const BoolVarArgs& x, BoolVar y, Reify r,
         IntConLevel icl=ICL_DEF);



  typedef SharedArray<int> IntSharedArray;
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, IntVar x1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, BoolVar x1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray n, IntVar x0, int x1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, IntVar y1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& x, IntVar y0, int y1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, BoolVar y1,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& x, IntVar y0, int y1,
          IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a, 
          IntVar x, int w, IntVar y, int h, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, IntSharedArray a, 
          IntVar x, int w, IntVar y, int h, BoolVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const IntVarArgs& a, 
          IntVar x, int w, IntVar y, int h, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  element(Home home, const BoolVarArgs& a, 
          IntVar x, int w, IntVar y, int h, BoolVar z,
          IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  distinct(Home home, const IntVarArgs& x,
           IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  distinct(Home home, const IntArgs& n, const IntVarArgs& x,
           IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  channel(Home home, const IntVarArgs& x, const IntVarArgs& y,
          IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  channel(Home home, const IntVarArgs& x, int xoff,
          const IntVarArgs& y, int yoff,
          IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  channel(Home home, BoolVar x0, IntVar x1,
          IntConLevel icl=ICL_DEF);
  forceinline void
  channel(Home home, IntVar x0, BoolVar x1,
          IntConLevel icl=ICL_DEF) {
    channel(home,x1,x0,icl);
  }
  GECODE_INT_EXPORT void
  channel(Home home, const BoolVarArgs& x, IntVar y, int o=0,
          IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  sorted(Home home, const IntVarArgs& x, const IntVarArgs& y,
         IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  sorted(Home home, const IntVarArgs& x, const IntVarArgs& y,
         const IntVarArgs& z,
         IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, int n, IntRelType irt, int m,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSet& y, IntRelType irt, int m,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, IntVar y, IntRelType irt, int m,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntArgs& y, IntRelType irt, int m,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, int n, IntRelType irt, IntVar z,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSet& y, IntRelType irt, IntVar z,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, IntVar y, IntRelType irt, IntVar z,
        IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntArgs& y, IntRelType irt, IntVar z,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntVarArgs& c,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x, const IntSetArgs& c,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntVarArgs& c, const IntArgs& v,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntSetArgs& c, const IntArgs& v,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  count(Home home, const IntVarArgs& x,
        const IntSet& c, const IntArgs& v,
        IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  nvalues(Home home, const IntVarArgs& x, IntRelType irt, int y,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const IntVarArgs& x, IntRelType irt, IntVar y,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const BoolVarArgs& x, IntRelType irt, int y,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nvalues(Home home, const BoolVarArgs& x, IntRelType irt, IntVar y,
          IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  sequence(Home home, const IntVarArgs& x, const IntSet& s, 
           int q, int l, int u, IntConLevel icl=ICL_DEF); 
  
  GECODE_INT_EXPORT void
  sequence(Home home, const BoolVarArgs& x, const IntSet& s, 
           int q, int l, int u, IntConLevel icl=ICL_DEF); 



  class DFA : public SharedHandle {
  private:
    class DFAI;
  public:
    class Transition {
    public:
      int i_state; 
      int symbol;  
      int o_state; 

      Transition();
      Transition(int i_state0, int symbol0, int o_state0);
    };
    class Transitions {
    private:
      const Transition* c_trans;
      const Transition* e_trans;
    public:
      Transitions(const DFA& d);
      Transitions(const DFA& d, int n);
      bool operator ()(void) const;
      void operator ++(void);
      int i_state(void) const;
      int symbol(void) const;
      int o_state(void) const;
    };
    class Symbols {
    private:
      const Transition* c_trans;
      const Transition* e_trans;
    public:
      Symbols(const DFA& d);
      bool operator ()(void) const;
      void operator ++(void);
      int val(void) const;
    };
  public:
    friend class Transitions;
    DFA(void);
    GECODE_INT_EXPORT
    DFA(int s, Transition t[], int f[], bool minimize=true);
    DFA(const DFA& d);
    int n_states(void) const;
    int n_transitions(void) const;
    unsigned int n_symbols(void) const;
    unsigned int max_degree(void) const;
    int final_fst(void) const;
    int final_lst(void) const;
    int symbol_min(void) const;
    int symbol_max(void) const;
  };


  enum ExtensionalPropKind {
    EPK_DEF,    
    EPK_SPEED,  
    EPK_MEMORY  
  };

  GECODE_INT_EXPORT void
  extensional(Home home, const IntVarArgs& x, DFA d,
              IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const BoolVarArgs& x, DFA d,
              IntConLevel icl=ICL_DEF);

  class TupleSet : public SharedHandle {
  public:
    typedef int* Tuple;

    class GECODE_VTABLE_EXPORT TupleSetI
      : public SharedHandle::Object {
    public:
      int arity;
      int size;
      Tuple** tuples;
      Tuple* tuple_data;
      int* data;
      int excess;
      int min, max;
      unsigned int domsize;
      Tuple** last;
      Tuple* nullpointer;

      template<class T>
      void add(T t);
      GECODE_INT_EXPORT void finalize(void);
      GECODE_INT_EXPORT void resize(void);
      bool finalized(void) const;
      TupleSetI(void);
      GECODE_INT_EXPORT virtual ~TupleSetI(void);
      GECODE_INT_EXPORT virtual SharedHandle::Object* copy(void) const;
    };
    
    TupleSetI* implementation(void);

    TupleSet(void);
    TupleSet(const TupleSet& d);

    void add(const IntArgs& tuple);
    void finalize(void);
    bool finalized(void) const;
    int arity(void) const;
    int tuples(void) const;
    Tuple operator [](int i) const;
    int min(void) const;
    int max(void) const;
  };

  GECODE_INT_EXPORT void
  extensional(Home home, const IntVarArgs& x, const TupleSet& t,
              ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  extensional(Home home, const BoolVarArgs& x, const TupleSet& t,
              ExtensionalPropKind epk=EPK_DEF, IntConLevel icl=ICL_DEF);

}

#include <gecode/int/extensional/dfa.hpp>
#include <gecode/int/extensional/tuple-set.hpp>

namespace Gecode {

  GECODE_INT_EXPORT void
  min(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  min(Home home, const IntVarArgs& x, IntVar y,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  max(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  max(Home home, const IntVarArgs& x, IntVar y,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  argmin(Home home, const IntVarArgs& x, IntVar y, bool tiebreak=true,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  argmax(Home home, const IntVarArgs& x, IntVar y, bool tiebreak=true,
         IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  abs(Home home, IntVar x0, IntVar x1,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  mult(Home home, IntVar x0, IntVar x1, IntVar x2,
       IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  divmod(Home home, IntVar x0, IntVar x1, IntVar x2, IntVar x3,
         IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  div(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  mod(Home home, IntVar x0, IntVar x1, IntVar x2,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  sqr(Home home, IntVar x0, IntVar x1,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  sqrt(Home home, IntVar x0, IntVar x1,
       IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  pow(Home home, IntVar x0, int n, IntVar x1,
      IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  nroot(Home home, IntVar x0, int n, IntVar x1,
       IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, int c,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, IntVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, int c,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, IntVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const IntVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, int c,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, IntVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const BoolVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, int c,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, int c, Reify r,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, IntVar y,
         IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  linear(Home home, const IntArgs& a, const BoolVarArgs& x,
         IntRelType irt, IntVar y, Reify r,
         IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  binpacking(Home home, 
             const IntVarArgs& l, 
             const IntVarArgs& b, const IntArgs& s,
             IntConLevel icl=ICL_DEF);
  /* \brief Post propagator for multi-dimensional bin packing
   *
   * In the following \a n refers to the number of items and \a m
   * refers to the number of bins.
   *
   * The multi-dimensional bin-packing constraint enforces that
   * all items are packed into bins
   * \f$b_i\in\{0,\ldots,m-1\}\f$ for \f$0\leq i<n\f$
   * and that the load of each bin corresponds to the items
   * packed into it for each dimension \f$l_{j\cdot
   * d + k} = \sum_{\{i\in\{0,\ldots,n-1\}|
   * b_{j\cdot d+k}=i}\}s_{i\cdot d+k}\f$
   * for \f$0\leq j<m\f$, \f$0\leq k<d\f$
   * Furthermore, the load variables must satisfy the capacity
   * constraints \f$l_{j\cdot d + k} \leq
   * c_k\f$ for \f$0\leq j<m\f$, \f$0\leq k<d\f$.
   *
   * The constraint is implemented by the decomposition
   * introduced in: Stefano Gualandi and Michele Lombardi. A
   * simple and effective decomposition for the multidimensional
   * binpacking constraint. CP 2013, pages 356--364.
   *
   * Posting the constraint returns a maximal set containing conflicting 
   * items that require pairwise different bins.
   *
   * Note that posting the constraint has exponential complexity in the
   * number of items due to the Bron-Kerbosch algorithm used for finding
   * the maximal conflict item sets.
   *
   * Throws the following exceptions:
   *  - Of type Int::ArgumentSizeMismatch if any of the following properties
   *    is violated: \f$|b|=n\f$, \f$|l|=m\cdot d\f$, \f$|s|=n\cdot d\f$,
   *    and \f$|c|=d\f$.
   *  - Of type Int::ArgumentSame if \a l and \a b share unassigned variables.
   *  - Of type Int::OutOfLimits if \a s or \a c contains a negative number.
   * 
   * \ingroup TaskModelIntBinPacking
   */
  GECODE_INT_EXPORT IntSet
  binpacking(Home home, int d,
             const IntVarArgs& l, const IntVarArgs& b, 
             const IntArgs& s, const IntArgs& c,
             IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  nooverlap(Home home, 
            const IntVarArgs& x, const IntArgs& w,
            const IntVarArgs& y, const IntArgs& h,
            IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home, 
            const IntVarArgs& x, const IntArgs& w,
            const IntVarArgs& y, const IntArgs& h,
            const BoolVarArgs& o,
            IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home, 
            const IntVarArgs& x0, const IntVarArgs& w, const IntVarArgs& x1,
            const IntVarArgs& y0, const IntVarArgs& h, const IntVarArgs& y1,
            IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  nooverlap(Home home, 
            const IntVarArgs& x0, const IntVarArgs& w, const IntVarArgs& x1,
            const IntVarArgs& y0, const IntVarArgs& h, const IntVarArgs& y1,
            const BoolVarArgs& o,
            IntConLevel icl=ICL_DEF);



  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntVarArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntVarArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntVarArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  cumulatives(Home home, const IntArgs& m,
              const IntVarArgs& s, const IntArgs& p,
              const IntVarArgs& e, const IntArgs& u,
              const IntArgs& c, bool at_most,
              IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntArgs& p,
        IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntArgs& p, 
        const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const TaskTypeArgs& t,
        const IntVarArgs& flex, const IntArgs& fix, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const TaskTypeArgs& t,
        const IntVarArgs& flex, const IntArgs& fix,
        const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntVarArgs& p, 
        const IntVarArgs& e, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  unary(Home home, const IntVarArgs& s, const IntVarArgs& p,
        const IntVarArgs& e, const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             IntConLevel icl=ICL_DEF);

  
  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const TaskTypeArgs& t,
             const IntVarArgs& flex, const IntArgs& fix, const IntArgs& u,
             const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntArgs& p,
             const IntArgs& u, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntArgs& p, 
             const IntArgs& u, const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntArgs& p, 
             const IntArgs& u, const BoolVarArgs& m, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntVarArgs& p,
             const IntVarArgs& e, const IntArgs& u, IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, int c, const IntVarArgs& s, const IntVarArgs& p, 
             const IntVarArgs& e, const IntArgs& u, const BoolVarArgs& m, 
             IntConLevel icl=ICL_DEF);

  GECODE_INT_EXPORT void
  cumulative(Home home, IntVar c, const IntVarArgs& s, const IntVarArgs& p, 
             const IntVarArgs& e, const IntArgs& u, const BoolVarArgs& m, 
             IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  circuit(Home home, const IntVarArgs& x,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, int offset, const IntVarArgs& x,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, 
          const IntArgs& c,
          const IntVarArgs& x, const IntVarArgs& y, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, 
          const IntArgs& c, int offset,
          const IntVarArgs& x, const IntVarArgs& y, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, 
          const IntArgs& c,
          const IntVarArgs& x, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  circuit(Home home, 
          const IntArgs& c, int offset,
          const IntVarArgs& x, IntVar z,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, const IntVarArgs& x, IntVar s, IntVar e,
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, int offset, const IntVarArgs& x, IntVar s, IntVar e,
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, 
       const IntArgs& c,
       const IntVarArgs& x, IntVar s, IntVar e, const IntVarArgs& y, IntVar z,
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, 
       const IntArgs& c, int offset,
       const IntVarArgs& x, IntVar s, IntVar e, const IntVarArgs& y, IntVar z,
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, 
       const IntArgs& c,
       const IntVarArgs& x, IntVar s, IntVar e, IntVar z,
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  path(Home home, 
       const IntArgs& c, int offset,
       const IntVarArgs& x, IntVar s, IntVar e, IntVar z,
       IntConLevel icl=ICL_DEF);




  GECODE_INT_EXPORT void
  wait(Home home, IntVar x, void (*c)(Space& home),
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, BoolVar x, void (*c)(Space& home),
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, const IntVarArgs& x, void (*c)(Space& home),
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  wait(Home home, const BoolVarArgs& x, void (*c)(Space& home),
       IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  when(Home home, BoolVar x, 
       void (*t)(Space& home), void (*e)(Space& home)= NULL,
       IntConLevel icl=ICL_DEF);


  GECODE_INT_EXPORT void
  unshare(Home home, IntVarArgs& x,
          IntConLevel icl=ICL_DEF);
  GECODE_INT_EXPORT void
  unshare(Home home, BoolVarArgs& x,
          IntConLevel icl=ICL_DEF);

}

namespace Gecode {

  typedef bool (*IntBranchFilter)(const Space& home, IntVar x, int i);
  typedef bool (*BoolBranchFilter)(const Space& home, BoolVar x, int i);

  typedef double (*IntBranchMerit)(const Space& home, IntVar x, int i);
  typedef double (*BoolBranchMerit)(const Space& home, BoolVar x, int i);

  typedef int (*IntBranchVal)(const Space& home, IntVar x, int i);
  typedef int (*BoolBranchVal)(const Space& home, BoolVar x, int i);

  typedef void (*IntBranchCommit)(Space& home, unsigned int a,
                                  IntVar x, int i, int n);
  typedef void (*BoolBranchCommit)(Space& home, unsigned int a,
                                   BoolVar x, int i, int n);
}

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

namespace Gecode {

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

}

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

namespace Gecode {

  class IntActivity : public Activity {
  public:
    IntActivity(void);
    IntActivity(const IntActivity& a);
    IntActivity& operator =(const IntActivity& a);      
    GECODE_INT_EXPORT 
    IntActivity(Home home, const IntVarArgs& x, double d=1.0,
                IntBranchMerit bm=NULL);
    GECODE_INT_EXPORT 
    IntActivity(Home home, const BoolVarArgs& x, double d=1.0,
                BoolBranchMerit bm=NULL);
    GECODE_INT_EXPORT void
    init(Home home, const IntVarArgs& x, double d=1.0,
         IntBranchMerit bm=NULL);
    GECODE_INT_EXPORT void
    init(Home home, const BoolVarArgs& x, double d=1.0,
         BoolBranchMerit bm=NULL);
  };

}

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

namespace Gecode {

  typedef void (*IntVarValPrint)(const Space &home, const BrancherHandle& bh,
                                 unsigned int a,
                                 IntVar x, int i, const int& n,
                                 std::ostream& o);

  typedef void (*BoolVarValPrint)(const Space &home, const BrancherHandle& bh,
                                  unsigned int a,
                                  BoolVar x, int i, const int& n,
                                  std::ostream& o);

}

namespace Gecode {

  class IntVarBranch : 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, 

      SEL_REGRET_MIN_MIN,
      SEL_REGRET_MIN_MAX,
      SEL_REGRET_MAX_MIN,
      SEL_REGRET_MAX_MAX
    };
  protected:
    Select s;
  public:
    IntVarBranch(void);
    IntVarBranch(Rnd r);
    IntVarBranch(Select s, BranchTbl t);
    IntVarBranch(Select s, double d, BranchTbl t);
    IntVarBranch(Select s, AFC a, BranchTbl t);
    IntVarBranch(Select s, Activity a, BranchTbl t);
    IntVarBranch(Select s, VoidFunction mf, BranchTbl t);
    Select select(void) const;
    void expand(Home home, const IntVarArgs& x);
    void expand(Home home, const BoolVarArgs& x);
  };


  IntVarBranch INT_VAR_NONE(void);
  IntVarBranch INT_VAR_RND(Rnd r);
  IntVarBranch INT_VAR_MERIT_MIN(IntBranchMerit bm, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_MERIT_MIN(BoolBranchMerit bm, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_MERIT_MAX(IntBranchMerit bm, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_MERIT_MAX(BoolBranchMerit bm, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_DEGREE_MIN(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_DEGREE_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_MIN(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_MIN(IntAFC a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_MAX(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_MAX(IntAFC a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_ACTIVITY_MIN(double d=1.0, BranchTbl tbl=NULL);    
  IntVarBranch INT_VAR_ACTIVITY_MIN(IntActivity a, BranchTbl tbl=NULL);    
  IntVarBranch INT_VAR_ACTIVITY_MAX(double d=1.0, BranchTbl tbl=NULL);     
  IntVarBranch INT_VAR_ACTIVITY_MAX(IntActivity a, BranchTbl tbl=NULL);     
  IntVarBranch INT_VAR_MIN_MIN(BranchTbl tbl=NULL);         
  IntVarBranch INT_VAR_MIN_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_MAX_MIN(BranchTbl tbl=NULL); 
  IntVarBranch INT_VAR_MAX_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_SIZE_MIN(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_SIZE_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_DEGREE_SIZE_MIN(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_DEGREE_SIZE_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_SIZE_MIN(IntAFC a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_AFC_SIZE_MAX(IntAFC a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_ACTIVITY_SIZE_MIN(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_ACTIVITY_SIZE_MIN(IntActivity a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_ACTIVITY_SIZE_MAX(double d=1.0, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_ACTIVITY_SIZE_MAX(IntActivity a, BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_REGRET_MIN_MIN(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_REGRET_MIN_MAX(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_REGRET_MAX_MIN(BranchTbl tbl=NULL);
  IntVarBranch INT_VAR_REGRET_MAX_MAX(BranchTbl tbl=NULL);

}

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

namespace Gecode {

  class IntValBranch : public ValBranch {
  public:
    enum Select {
      SEL_MIN,        
      SEL_MED,        
      SEL_MAX,        
      SEL_RND,        
      SEL_SPLIT_MIN,  
      SEL_SPLIT_MAX,  
      SEL_RANGE_MIN,  
      SEL_RANGE_MAX,  
      SEL_VAL_COMMIT, 
      SEL_VALUES_MIN, 
      SEL_VALUES_MAX, 
      SEL_NEAR_MIN,   
      SEL_NEAR_MAX,   
      SEL_NEAR_INC,   
      SEL_NEAR_DEC    
   };
  protected:
    IntSharedArray n;
    Select s;
  public:
    IntValBranch(Select s = SEL_MIN);
    IntValBranch(Rnd r);
    IntValBranch(VoidFunction v, VoidFunction c);
    IntValBranch(Select s, IntSharedArray n);
    Select select(void) const;
    IntSharedArray values(void) const;
  };


  IntValBranch INT_VAL_MIN(void);
  IntValBranch INT_VAL_MED(void);
  IntValBranch INT_VAL_MAX(void);
  IntValBranch INT_VAL_RND(Rnd r);
  IntValBranch INT_VAL_SPLIT_MIN(void);
  IntValBranch INT_VAL_SPLIT_MAX(void);
  IntValBranch INT_VAL_RANGE_MIN(void);
  IntValBranch INT_VAL_RANGE_MAX(void);
  IntValBranch INT_VAL(IntBranchVal v, IntBranchCommit c=NULL);
  IntValBranch INT_VAL(BoolBranchVal v, BoolBranchCommit c=NULL);
  IntValBranch INT_VALUES_MIN(void); 
  IntValBranch INT_VALUES_MAX(void);
  IntValBranch INT_VAL_NEAR_MIN(IntSharedArray n);
  IntValBranch INT_VAL_NEAR_MAX(IntSharedArray n);
  IntValBranch INT_VAL_NEAR_INC(IntSharedArray n);
  IntValBranch INT_VAL_NEAR_DEC(IntSharedArray n);

}

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

namespace Gecode {

  class IntAssign : public ValBranch {
  public:
    enum Select {
      SEL_MIN,       
      SEL_MED,       
      SEL_MAX,       
      SEL_RND,       
      SEL_VAL_COMMIT 
    };
  protected:
    Select s;
  public:
    IntAssign(Select s = SEL_MIN);
    IntAssign(Rnd r);
    IntAssign(VoidFunction v, VoidFunction c);
    Select select(void) const;
  };


  IntAssign INT_ASSIGN_MIN(void);
  IntAssign INT_ASSIGN_MED(void);
  IntAssign INT_ASSIGN_MAX(void);
  IntAssign INT_ASSIGN_RND(Rnd r);
  IntAssign INT_ASSIGN(IntBranchVal v, IntBranchCommit c=NULL);
  IntAssign INT_ASSIGN(BoolBranchVal v, BoolBranchCommit c=NULL);

}

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

namespace Gecode {
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const IntVarArgs& x,
         IntVarBranch vars, IntValBranch vals, 
         IntBranchFilter bf=NULL,
         IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const IntVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         IntBranchFilter bf=NULL,
         IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, IntVar x, IntValBranch vals,
         IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const BoolVarArgs& x,
         IntVarBranch vars, IntValBranch vals,
         BoolBranchFilter bf=NULL,
         BoolVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const BoolVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         BoolBranchFilter bf=NULL,
         BoolVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, BoolVar x, IntValBranch vals,
         BoolVarValPrint vvp=NULL);

  GECODE_INT_EXPORT BrancherHandle
  assign(Home home, const IntVarArgs& x, IntAssign vals,
         IntBranchFilter ibf=NULL,
         IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  assign(Home home, IntVar x, IntAssign vals,
         IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  assign(Home home, const BoolVarArgs& x, IntAssign vals,
         BoolBranchFilter bbf=NULL,
         BoolVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  assign(Home home, BoolVar x, IntAssign vals,
         BoolVarValPrint vvp=NULL);

}

namespace Gecode {

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

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

}

// LDSB-related declarations.
namespace Gecode {

  namespace Int { namespace LDSB {
    class SymmetryObject;
  }}

  class GECODE_INT_EXPORT SymmetryHandle {
  public:
    Int::LDSB::SymmetryObject* ref;
    void increment(void);
    void decrement(void);
  public:
    SymmetryHandle(void);
    SymmetryHandle(Int::LDSB::SymmetryObject* o);
    SymmetryHandle(const SymmetryHandle& h);
    const SymmetryHandle& operator=(const SymmetryHandle& h);
    ~SymmetryHandle(void);
  };
  class Symmetries;
  template<>
  class ArrayTraits<ArgArray<SymmetryHandle> > {
  public:
    typedef Symmetries     StorageType;
    typedef SymmetryHandle ValueType;
    typedef Symmetries     ArgsType;
  };


  class Symmetries : public ArgArray<SymmetryHandle> {};
  // If this is instead a typedef, strange things happen with the
  // overloading of the "branch" function.

  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const IntVarArgs& x);
  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const BoolVarArgs& x);
  GECODE_INT_EXPORT SymmetryHandle VariableSymmetry(const IntVarArgs& x, 
                                                    const IntArgs& indices);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(const IntArgs& v);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(const IntSet& v);
  GECODE_INT_EXPORT SymmetryHandle ValueSymmetry(IntVar vars);
  GECODE_INT_EXPORT
  SymmetryHandle VariableSequenceSymmetry(const IntVarArgs& x, int ss);
  GECODE_INT_EXPORT
  SymmetryHandle VariableSequenceSymmetry(const BoolVarArgs& x, int ss);
  GECODE_INT_EXPORT
  SymmetryHandle ValueSequenceSymmetry(const IntArgs& v, int ss);

  GECODE_INT_EXPORT SymmetryHandle values_reflect(int lower, int upper);
  GECODE_INT_EXPORT SymmetryHandle values_reflect(IntVar x);

  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const IntVarArgs& x,
         IntVarBranch vars, IntValBranch vals,
         const Symmetries& syms, 
         IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const IntVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         const Symmetries& syms, 
         IntBranchFilter bf=NULL, IntVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const BoolVarArgs& x,
         IntVarBranch vars, IntValBranch vals,
         const Symmetries& syms, 
         BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL);
  GECODE_INT_EXPORT BrancherHandle
  branch(Home home, const BoolVarArgs& x,
         TieBreak<IntVarBranch> vars, IntValBranch vals,
         const Symmetries& syms, 
         BoolBranchFilter bf=NULL, BoolVarValPrint vvp=NULL);
}

#endif

// IFDEF: GECODE_HAS_INT_VARS
// STATISTICS: int-post