var-imp.icc

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Contributing authors:
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  Last modified:
 *     $Date: 2008-07-11 10:14:37 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
 *     $Revision: 7316 $
 *
 *  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.
 *
 */

#include <cmath>

namespace Gecode { namespace Int {

  class IntVarImp;
  class BoolVarImp;

  class IntDelta : public Delta {
    friend class IntVarImp;
    friend class BoolVarImp;
  private:
    int _min; 
    int _max; 
  public:
    IntDelta(bool any=true);
    IntDelta(int min, int max);
  private:
    int min(void) const;
    int max(void) const;
    bool any(void) const;
  };

}}

#include "gecode/int/var-imp/delta.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);
  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 ModEvent lq_full(Space* home, int n);
    GECODE_INT_EXPORT ModEvent gq_full(Space* home, int n);
    GECODE_INT_EXPORT ModEvent 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_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent inter_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent minus_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent narrow_v(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent inter_v(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent minus_v(Space* home, I& i, bool depends=true);



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



    static ModEventDelta med(ModEvent me);


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


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



    GECODE_INT_EXPORT Reflection::Arg*
    spec(const Space* home, Reflection::VarMap& m) const;
    static GECODE_INT_EXPORT VarImpBase*
    create(Space* home, Reflection::VarSpec& spec);
    static GECODE_INT_EXPORT void
    constrain(Space* home, VarImpBase* v, Reflection::VarSpec& spec);



    static ModEvent modevent(const Delta* d);
    int min(const Delta* d) const;
    int max(const Delta* d) const;
    bool any(const Delta* d) const;
  };


  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;
  };

}}

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

namespace Gecode {
  
  class IntVar;
  
  template <>
  class VarImpVarTraits<Int::IntVarImp> {
  public:
    typedef IntVar Var;
  };
  
  class BoolVar;
}

namespace Gecode { namespace Int {

  typedef unsigned int BoolStatus;

  class BoolVarImp : public BoolVarImpBase {
    friend class ::Gecode::BoolVar;
  private:
    GECODE_INT_EXPORT static BoolVarImp s_one;
    GECODE_INT_EXPORT static BoolVarImp s_zero;

    BoolVarImp(Space* home, bool share, BoolVarImp& x);
    BoolVarImp(int n);
  public:
    BoolVarImp(Space* home, int min, int max);



    static const int BITS = 2;
    static const BoolStatus ZERO = 0;
    static const BoolStatus ONE  = 3;
    static const BoolStatus NONE = 2;
    BoolStatus status(void) const;



    int min(void) const;
    int max(void) const;
    int val(void) const;
    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;



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



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

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



    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_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent inter_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent minus_r(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent narrow_v(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent inter_v(Space* home, I& i, bool depends=true);
    template <class I> 
    ModEvent minus_v(Space* home, I& i, bool depends=true);



    ModEvent zero(Space* home);
    ModEvent one(Space* home);
    GECODE_INT_EXPORT ModEvent zero_none(Space* home);
    GECODE_INT_EXPORT ModEvent one_none(Space* home);

  public:


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



    static void schedule(Space* home, Propagator* p, ModEvent me);
    static ModEventDelta med(ModEvent me);



    static ModEvent modevent(const Delta* d);
    int min(const Delta* d) const;
    int max(const Delta* d) const;
    bool any(const Delta* d) const;



    BoolVarImp* copy(Space* home, bool share);
    


    GECODE_INT_EXPORT Reflection::Arg*
    spec(const Space* home, Reflection::VarMap& m) const;
    static GECODE_INT_EXPORT VarImpBase*
    create(Space* home, Reflection::VarSpec& spec);
    static GECODE_INT_EXPORT void
    constrain(Space* home, VarImpBase* v, Reflection::VarSpec& spec);
    
  };

}}

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

namespace Gecode {
  template <>
  class VarImpVarTraits<Int::BoolVarImp> {
  public:
    typedef BoolVar Var;
  };
}

// STATISTICS: int-var