occur.icc

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Patrick Pekczynski <pekczynski@ps.uni-sb.de>
 *
 *  Copyright:
 *     Patrick Pekczynski, 2004
 *
 *  Last modified: $Date: 2008-02-27 11:24:12 +0100 (Wed, 27 Feb 2008) $ by $Author: tack $
 *  $Revision: 6323 $
 *
 *  This file is part of Gecode, the generic constrain
 *  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.
 */

namespace Gecode { namespace Int { namespace GCC {
  class OccurBndsView {
  private:
    int _min;
    int _max;
    int c;
    int count;
  public:
    OccurBndsView(void);
    int min(void) const;
    int max(void) const;
    int card(void) const;
    int counter(void) const;

    void min(int);
    void max(int);
    void card(int c);
    void counter(int c);

    void init(Space* home, int min, int max, int c);
    ModEvent lq(Space* home, int n);
    ModEvent gq(Space* home, int n);
    ModEvent eq(Space* home, int n);
    bool assigned(void) const;
    bool range(void) const;
    ModEvent inc(void);

    void cancel(Space*, Propagator* , PropCond ) {}
    void subscribe(Space*, Propagator* , PropCond, bool=true) {}

    void cancel(Space*, Advisor*) {}
    void subscribe(Space*, Advisor*) {}

    void update(Space*, bool, OccurBndsView&);

    Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
    OccurBndsView(Space* home, const Reflection::VarMap& m,
                  Reflection::Arg* arg);
    static Support::Symbol type(void);
    
  };

  forceinline
  OccurBndsView::OccurBndsView(void) {}

  forceinline int
  OccurBndsView::min(void) const {
    return _min;
  }

  forceinline int
  OccurBndsView::max(void) const {
    return _max;
  }

  forceinline int
  OccurBndsView::card(void) const {
    return c;
  }

  forceinline int
  OccurBndsView::counter(void) const {
    return count;
  }

  forceinline void
  OccurBndsView::min(int m) {
    _min = m;
  }

  forceinline void
  OccurBndsView::max(int m) {
    _max = m;
  }

  forceinline void
  OccurBndsView::card(int ca) {
    c = ca;
  }

  forceinline void
  OccurBndsView::counter(int count0) {
    count = count0;
  }

  forceinline void
  OccurBndsView::init(Space*, int min, int max, int val) {
    _min = min; _max=max;
    c = val;
    count = 0;
  }

  forceinline ModEvent
  OccurBndsView::inc(void) {
    count++;
    if (count > _max) {
      return ME_GEN_FAILED;
    } else {
      return ME_GEN_NONE;
    }
  }

  forceinline bool
  OccurBndsView::assigned(void) const {
    return _min==_max;
  }

  forceinline bool
  OccurBndsView::range(void) const {
    return true;
  }


  forceinline ModEvent
  OccurBndsView::lq(Space*, int i){
    // the maximum can be made consistent
    if (_min > i) {
      return ME_GEN_FAILED;
    } else {
      return ME_GEN_NONE;
    }
  }

  forceinline ModEvent
  OccurBndsView::gq(Space*, int i){
    // this bound is fix
    if (_max < i) {
      return ME_GEN_FAILED;
    }
    return ME_GEN_NONE;
  }

  forceinline ModEvent
  OccurBndsView::eq(Space*, int i){
    if (_min > i || _max < i) {
      return ME_GEN_FAILED;
    } else {
      return ME_GEN_NONE;
    }
  }

}}}

inline std::ostream&
operator<<(std::ostream& os, Gecode::Int::GCC::OccurBndsView& xs) {
  os << xs.card() << "("<< xs.counter() <<")[";
  os << xs.min() << "," << xs.max() << "]";
  return os;
}

namespace Gecode { namespace Int { namespace GCC {

  forceinline void
  OccurBndsView::update(Space*, bool, OccurBndsView& oc) {
    _min = oc._min;
    _max = oc._max;
    c = oc.c;
    count = oc.count;
  }

  forceinline Reflection::Arg*
  OccurBndsView::spec(const Space*, Reflection::VarMap&) const {
    return Reflection::Arg::newPair(
      Reflection::Arg::newPair(Reflection::Arg::newInt(_min),
        Reflection::Arg::newInt(_max)),
      Reflection::Arg::newPair(Reflection::Arg::newInt(c),
        Reflection::Arg::newInt(count)));
  }
  inline Support::Symbol
  OccurBndsView::type(void) {
    return Support::Symbol("Gecode::Int::GCC::OccurBndsView");
  }

  forceinline
  OccurBndsView::OccurBndsView(Space*, const Reflection::VarMap&,
                               Reflection::Arg* arg) {
    _min = arg->first()->first()->toInt();
    _max = arg->first()->second()->toInt();
    c    = arg->second()->first()->toInt();
    count = arg->second()->second()->toInt();
  }

  template <class T>
  forceinline int
  lookupValue(T& a, int v){
    int idx = -1;

    int l  = 0;
    int r  = a.size() - 1;

    if (r == 0) {
      if (a[0].card() == v) {
        return 0;
      } else {
        return -1;
      }
    }

    while ( l < r ) {
      if ( a[l].card() == v) {
        idx = l;
        break;
      }
      if ( a[r].card() == v) {
        idx = r;
        break;
      }
      int p  = (l + r) / 2;
      if ( v == a[p].card()) {
        idx = p;
        break;
      } else {
        if ( v < a[p].card()) {
          r = p;
        } else {
          l = p;
        }
      }
      if (l == r - 1) {
        break;
      }
    }

    return idx;
  }


  class CardView : public DerivedViewBase<IntView> {
  protected:
    int c;
    int count;
    using DerivedViewBase<IntView>::view;
  public:
    CardView(void);
    CardView(const IntView& x, int c);
    void init(const IntView& x, int c);
    void init(Space* home, int mi, int ma , int c);

    int card(void) const;
    void card(int ca);

    ModEvent inc(void);
    void counter(int);
    int counter(void);


    void operator=(const IntView& x);
    void operator=(const Gecode::Int::GCC::CardView& x);
    int min(void) const;
    int max(void) const;
    int med(void) const;
    int val(void) const;
    IntView intview(void);
    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 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 le(Space* home, int n);
    ModEvent le(Space* home, double n);
    ModEvent gq(Space* home, int n);
    ModEvent gq(Space* home, double n);
    ModEvent gr(Space* home, int n);
    ModEvent gr(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);

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

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

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

    Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
    static Support::Symbol type(void);
    CardView(Space* home, const Reflection::VarMap& m,
             Reflection::Arg* arg);

    bool operator ==(const CardView& x) const;
    bool operator !=(const CardView& x) const;
    bool operator < (const CardView& x) const;
    bool operator > (const CardView& x) const;
  };

  /*
   * Constructors and initialization
   *
   */
  forceinline
  CardView::CardView(void) {}

  forceinline
  CardView::CardView(const IntView& x, int d)
    : DerivedViewBase<IntView>(x), c(d), count(0) {}

  forceinline void
  CardView::init(const IntView& x, int d) {
    view  = x;
    c     = d;
    count = 0;
  }


  forceinline void
  CardView::init(Space* home, int mi, int ma, int d) {
    IntVar ivar(home, mi, ma);
    IntView iview(ivar);
    view  = iview;
    c     = d;
    count = 0;
  }

  forceinline void
  CardView::card(int ca) {
    c = ca;
  }

  forceinline int
  CardView::card(void) const {
    return c;
  }

  forceinline ModEvent
  CardView::inc(void) {
    count++;
    if (count > this->max()) {
      return ME_GEN_FAILED;
    } else {
      return ME_GEN_NONE;
    }
  }

  forceinline void
  CardView::counter(int c) {
    count = c;
  }

  forceinline int
  CardView::counter(void) {
    return count;
  }

  /*
   * Value access
   *
   */

  forceinline void
  CardView::operator=(const IntView& x) {
    view  = x;
    c     = 0;
    count = 0;
  }

  forceinline void
  CardView::operator=(const CardView& x) {
    view  = x.view;
    c     = x.c;
    count = x.count;
  }


  forceinline int
  CardView::min(void) const {
    return view.min();
  }
  forceinline int
  CardView::max(void) const {
    return view.max();
  }
  forceinline int
  CardView::med(void) const {
    return view.med();
  }

  forceinline int
  CardView::val(void) const {
    return view.val();
  }

  forceinline IntView
  CardView::intview(void){
    return view;
  }


  forceinline unsigned int
  CardView::width(void) const {
    return view.width();
  }
  forceinline unsigned int
  CardView::size(void) const {
    return view.size();
  }
  forceinline unsigned int
  CardView::regret_min(void) const {
    return view.regret_min();
  }
  forceinline unsigned int
  CardView::regret_max(void) const {
    return view.regret_max();
  }

  /*
   * Domain tests
   *
   */
  forceinline bool
  CardView::range(void) const {
    return view.range();
  }
  forceinline bool
  CardView::assigned(void) const {
    return view.assigned();
  }

  forceinline bool
  CardView::in(int n) const {
    return view.in(n);
  }
  forceinline bool
  CardView::in(double n) const {
    return view.in(n);
  }


  /*
   * Domain update by value
   *
   */
  forceinline ModEvent
  CardView::lq(Space* home, int n) {
    return view.lq(home,n);
  }
  forceinline ModEvent
  CardView::lq(Space* home, double n) {
    return view.lq(home,n);
  }
  forceinline ModEvent
  CardView::le(Space* home, int n) {
    return view.le(home,n);
  }
  forceinline ModEvent
  CardView::le(Space* home, double n) {
    return view.le(home,n);
  }
  forceinline ModEvent
  CardView::gq(Space* home, int n) {
    return view.gq(home,n);
  }
  forceinline ModEvent
  CardView::gq(Space* home, double n) {
    return view.gq(home,n);
  }
  forceinline ModEvent
  CardView::gr(Space* home, int n) {
    return view.gr(home,n);
  }
  forceinline ModEvent
  CardView::gr(Space* home, double n) {
    return view.gr(home,n);
  }
  forceinline ModEvent
  CardView::nq(Space* home, int n) {
    return view.nq(home,n);
  }
  forceinline ModEvent
  CardView::nq(Space* home, double n) {
    return view.nq(home,n);
  }
  forceinline ModEvent
  CardView::eq(Space* home, int n) {
    return view.eq(home,n);
  }
  forceinline ModEvent
  CardView::eq(Space* home, double n) {
    return view.eq(home,n);
  }


  /*
   * Domain update by iterator
   *
   */
  template <class I>
  ModEvent
  CardView::narrow_r(Space* home, I& i, bool depends) {
    return view.narrow_r(home,i,depends);
  }
  template <class I>
  ModEvent
  CardView::inter_r(Space* home, I& i, bool depends) {
    return view.inter_r(home,i,depends);
  }
  template <class I>
  ModEvent
  CardView::minus_r(Space* home, I& i, bool depends) {
    return view.minus_r(home,i,depends);
  }
  template <class I>
  ModEvent
  CardView::narrow_v(Space* home, I& i, bool depends) {
    return view.narrow_v(home,i,depends);
  }
  template <class I>
  ModEvent
  CardView::inter_v(Space* home, I& i, bool depends) {
    return view.inter_v(home,i,depends);
  }
  template <class I>
  ModEvent
  CardView::minus_v(Space* home, I& i, bool depends) {
    return view.minus_v(home,i,depends);
  }



  /*
   * Propagator modification events
   *
   */
  forceinline void
  CardView::schedule(Space* home, Propagator* p, ModEvent me) {
    return IntView::schedule(home,p,me);
  }
  forceinline ModEvent
  CardView::me(ModEventDelta med) {
    return IntView::me(med);
  }
  forceinline ModEventDelta
  CardView::med(ModEvent me) {
    return IntView::med(me);
  }


  /*
   * Dependencies
   *
   */
  forceinline void
  CardView::subscribe(Space* home, Propagator* p, PropCond pc, bool process) {
    view.subscribe(home, p, pc, process);
  }
  forceinline void
  CardView::cancel(Space* home, Propagator* p, PropCond pc) {
    view.cancel(home,p, pc);
  }
  forceinline void
  CardView::subscribe(Space* home, Advisor* a) {
    view.subscribe(home, a);
  }
  forceinline void
  CardView::cancel(Space* home, Advisor* a) {
    view.cancel(home, a);
  }


  /*
   * Cloning
   *
   */
  forceinline void
  CardView::update(Space* home, bool share, CardView& x) {
    c     = x.c;
    count = x.count;
    view.update(home,share,x.view);
  }

  /*
   * Serialization
   *
   */
  forceinline Reflection::Arg*
  CardView::spec(const Space* home, Reflection::VarMap& m) const {
    return Reflection::Arg::newPair(
      Reflection::Arg::newPair(Reflection::Arg::newInt(c),
        Reflection::Arg::newInt(count)), view.spec(home, m));
  }
  inline Support::Symbol
  CardView::type(void) {
    return Support::Symbol("Gecode::Int::GCC::CardView");
  }
  forceinline
  CardView::CardView(Space* home, const Reflection::VarMap& m,
                     Reflection::Arg* arg)
   : DerivedViewBase<IntView>(IntView(home, m, arg->second())) {
    c = arg->first()->first()->toInt();
    count = arg->first()->second()->toInt();
  }


}


  template <>
  class ViewRanges<GCC::CardView>
    : public Gecode::Int::ViewRanges<IntView> {
  public:
    ViewRanges(void);
    ViewRanges(const GCC::CardView& x);
    void init(const GCC::CardView& x);
  };

}}

inline std::ostream&
operator<<(std::ostream& os, Gecode::Int::GCC::CardView& v) {
  os << "("<<v.card() << ","<< v.counter() <<",";
  if (v.min() == v.max()) {
    os << v.min() <<" ";
  } else {
    if (v.range()){
      os << "["<<v.min() <<".."<<v.max()<<"] ";
    } else {
      os << "{";
      Gecode::Int::ViewValues<Gecode::Int::GCC::CardView> iter(v);
      while(iter()){
        os << iter.val() <<",";
        ++iter;
      }
      os << "}";
    }
  }
  os << ")";
  return os;
}

namespace Gecode { namespace Int {

  forceinline
  ViewRanges<GCC::CardView>::ViewRanges(void) :
    Gecode::Int::ViewRanges<IntView>()  {}

  forceinline
  ViewRanges<GCC::CardView>::ViewRanges (const GCC::CardView& x)
    : Gecode::Int::ViewRanges<IntView>(x.base())  {}

  forceinline void
  ViewRanges<GCC::CardView>::init(const GCC::CardView& x) {
    Gecode::Int::ViewRanges<IntView> xi(x.base());
  }

}}



// STATISTICS: int-prop