main page modules namespaces classes files
Gecode home

search for 

var.icc

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Contributing authors:
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  Last modified:
 *     $Date: 2006-09-21 11:35:18 +0200 (Thu, 21 Sep 2006) $ by $Author: schulte $
 *     $Revision: 3686 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#include <cmath>

#include "gecode/int/var/imp-hdr.icc"

namespace Gecode { namespace Int {

  class IntVarImpFwd;
  class IntVarImpBwd;

  class IntVarImp : public IntVarImpBase {
    friend class IntVarImpFwd;
    friend class IntVarImpBwd;
  protected:
    class RangeList : public FreeList {
    protected:
      int _min;
      int _max;
    public:


      RangeList(void);
      RangeList(int min, int max);
      RangeList(int min, int max, RangeList* p, RangeList* n);



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

      RangeList* next(const RangeList* p) const;
      RangeList* prev(const RangeList* n) const;



      void min(int n);
      void max(int n);

      void prevnext(RangeList* p, RangeList* n);
      void next(RangeList* o, RangeList* n);
      void prev(RangeList* o, RangeList* n);
      void fix(RangeList* n);



      void dispose(Space* home, RangeList* p, RangeList* l);
      void dispose(Space* home, RangeList* l);
      void dispose(Space* home);

      static void* operator new(size_t s, Space* home);
      static void  operator delete(void*);
      static void  operator delete(void*, Space*);
    };

    RangeList dom;
    RangeList* _lst;
    RangeList* fst(void) const;
    void fst(RangeList* f);
    RangeList* lst(void) const;
    void lst(RangeList* l);
    unsigned int holes;

  protected:
    IntVarImp(Space* home, bool share, IntVarImp& x, bool is_bool);
  public:
    IntVarImp(Space* home, int min, int max);
    IntVarImp(Space* home, const IntSet& d);



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

    unsigned int size(void) const;
    unsigned int width(void) const;
    unsigned int regret_min(void) const;
    unsigned int regret_max(void) const;

  private:
    GECODE_INT_EXPORT bool in_full(int n) const;

  public:


    bool range(void) const;
    bool assigned(void) const;

    bool in(int n) const;
    bool in(double n) const;

  protected:


    const RangeList* ranges_fwd(void) const;
    const RangeList* ranges_bwd(void) const;

  private:
    bool closer_min(int b) const;


    GECODE_INT_EXPORT void lq_full(Space* home, int n);
    GECODE_INT_EXPORT void gq_full(Space* home, int n);
    GECODE_INT_EXPORT void eq_full(Space* home, int n);
    GECODE_INT_EXPORT ModEvent nq_full(Space* home, int n);
  public:


    ModEvent lq(Space* home, int n);
    ModEvent lq(Space* home, double n);

    ModEvent gq(Space* home, int n);
    ModEvent gq(Space* home, double n);

    ModEvent nq(Space* home, int n);
    ModEvent nq(Space* home, double n);

    ModEvent eq(Space* home, int n);
    ModEvent eq(Space* home, double n);



    template <class I> ModEvent narrow(Space* home, I& i);
    template <class I> ModEvent inter(Space* home, I& i);
    template <class I> ModEvent minus(Space* home, I& i);



    void t_zero_none(Space* home);
    void t_one_none(Space* home);

  public:


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

  private:
    GECODE_INT_EXPORT IntVarImp* perform_copy(Space* home, bool share);
    GECODE_INT_EXPORT IntVarImp* perform_copy_bool(Space* home, bool share);
  public:


    IntVarImp* copy(Space* home, bool share);
    IntVarImp* copy_bool(Space* home, bool share);
  };


  class IntVarImpFwd {
  private:
    const IntVarImp::RangeList* p;
    const IntVarImp::RangeList* c;
  public:


    IntVarImpFwd(void);
    IntVarImpFwd(const IntVarImp* x);
    void init(const IntVarImp* x);



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



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

  class IntVarImpBwd {
  private:
    const IntVarImp::RangeList* n;
    const IntVarImp::RangeList* c;
  public:


    IntVarImpBwd(void);
    IntVarImpBwd(const IntVarImp* x);
    void init(const IntVarImp* x);



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



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


  class IntView;
  class BoolView;

}}

#include "gecode/int/var/imp.icc"


namespace Gecode {

  class IntVar {
  protected:
    Int::IntVarImp* var;
  public:


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



    Int::IntVarImp* variable(void) const;



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

    unsigned int size(void) const;
    unsigned int width(void) const;
    unsigned int degree(void) const;



    bool range(void) const;
    bool assigned(void) const;

    bool in(int n) const;



    void update(Space* home, bool share, 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);
  };

  class BoolVar : public IntVar {
  public:


    BoolVar(void);
    BoolVar(const Int::BoolView& x);
    BoolVar(Space* home, int min, int max);
    explicit BoolVar(const IntVar& x);



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

}

std::ostream&
operator<<(std::ostream&, const Gecode::IntVar& x);

/*
 * For initialization, IntVar and IntView are mutually dependent.
 * Therefore, the inclusion of the variable definition is in view.hh
 *
 */

// STATISTICS: int-var