count.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>
 *
 *  Copyright:
 *     Christian Schulte, 2002
 *     Guido Tack, 2004
 *
 *  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_COUNT_HH__
#define __GECODE_INT_COUNT_HH__

#include <gecode/int.hh>

namespace Gecode { namespace Int { namespace Count {


  template<class VY>
  bool isintset(VY y);
  template<class VY>
  bool isval(VY y);

  template<class VY>
  void subscribe(Space& home, Propagator& p, VY y);
  template<class VY>
  void cancel(Space& home, Propagator& p, VY y);
  template<class VY>
  void reschedule(Space& home, Propagator& p, VY y);
  template<class VY>
  void update(VY& y, Space& home, bool shared, VY py);

  template<class VX>
  RelTest holds(VX x, VX y);
  template<class VX>
  RelTest holds(VX x, ConstIntView y);
  template<class VX>
  RelTest holds(VX x, ZeroIntView y);
  template<class VX>
  RelTest holds(VX x, const IntSet& y);

  template<class VX>
  ExecStatus post_true(Home home, ViewArray<VX>& x, VX y);
  template<class VX>
  ExecStatus post_true(Home home, ViewArray<VX>& x, ConstIntView y);
  template<class VX>
  ExecStatus post_true(Home home, ViewArray<VX>& x, ZeroIntView y);
  template<class VX>
  ExecStatus post_true(Home home, ViewArray<VX>& x, const IntSet& y);

  template<class VX>
  ExecStatus post_false(Home home, ViewArray<VX>& x, VX y);
  template<class VX>
  ExecStatus post_false(Home home, ViewArray<VX>& x, ConstIntView y);
  template<class VX>
  ExecStatus post_false(Home home, ViewArray<VX>& x, ZeroIntView y);
  template<class VX>
  ExecStatus post_false(Home home, ViewArray<VX>& x, const IntSet& y);

  template<class VX>
  ExecStatus prune(Home home, ViewArray<VX>& x, VX y);
  template<class VX>
  ExecStatus prune(Home home, ViewArray<VX>& x, ConstIntView y);
  template<class VX>
  ExecStatus prune(Home home, ViewArray<VX>& x, ZeroIntView y);
  template<class VX>
  ExecStatus prune(Home home, ViewArray<VX>& x, const IntSet& y);

}}}

#include <gecode/int/count/rel.hpp>


namespace Gecode { namespace Int { namespace Count {

  template<class VX, class VY>
  class IntBase : public Propagator {
  protected:
    ViewArray<VX> x;
    int n_s;
    VY y;
    int c;
    IntBase(Space& home, IntBase& p);
    IntBase(Home home, ViewArray<VX>& x, int n_s, VY y, int c);
  public:
    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
    virtual void reschedule(Space& home);
    virtual size_t dispose(Space& home);
  };

  template<class VX, class VY>
  class EqInt : public IntBase<VX,VY> {
  protected:
    using IntBase<VX,VY>::x;
    using IntBase<VX,VY>::n_s;
    using IntBase<VX,VY>::y;
    using IntBase<VX,VY>::c;
    EqInt(Space& home, EqInt& p);
    EqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c);
  public:
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, int c);
  };

  template<class VX, class VY>
  class GqInt : public IntBase<VX,VY> {
  protected:
    using IntBase<VX,VY>::x;
    using IntBase<VX,VY>::n_s;
    using IntBase<VX,VY>::y;
    using IntBase<VX,VY>::c;
    GqInt(Space& home, GqInt& p);
    GqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c);
  public:
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, int c);
  };

  template<class VX, class VY>
  class LqInt : public IntBase<VX,VY> {
  protected:
    using IntBase<VX,VY>::x;
    using IntBase<VX,VY>::n_s;
    using IntBase<VX,VY>::y;
    using IntBase<VX,VY>::c;
    LqInt(Space& home, LqInt& p);
    LqInt(Home home, ViewArray<VX>& x, int n_s, VY y, int c);
  public:
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, int c);
  };

}}}

#include <gecode/int/count/int-base.hpp>
#include <gecode/int/count/int-eq.hpp>
#include <gecode/int/count/int-gq.hpp>
#include <gecode/int/count/int-lq.hpp>


namespace Gecode { namespace Int { namespace Count {

  template<class VX, class VY, class VZ>
  class ViewBase : public Propagator {
  protected:
    ViewArray<VX> x;
    VY y;
    VZ z;
    int   c;
    ViewBase(Space& home, ViewBase& p);
    ViewBase(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
  public:
    virtual size_t dispose(Space& home);
    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
    virtual void reschedule(Space& home);
  protected:
    void count(Space& home);
    int atleast(void) const;
    int atmost(void) const;
    static bool sharing(const ViewArray<VX>& x, const VY& y, const VZ& z);
  };

  template<class VX, class VY, class VZ, bool shr, bool dom>
  class EqView : public ViewBase<VX,VY,VZ> {
  protected:
    using ViewBase<VX,VY,VZ>::x;
    using ViewBase<VX,VY,VZ>::z;
    using ViewBase<VX,VY,VZ>::c;
    using ViewBase<VX,VY,VZ>::y;
    using ViewBase<VX,VY,VZ>::count;
    using ViewBase<VX,VY,VZ>::atleast;
    using ViewBase<VX,VY,VZ>::atmost;
    using ViewBase<VX,VY,VZ>::sharing;

    EqView(Space& home, EqView& p);
  public:
    EqView(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
  };

  template<class VX, class VY, class VZ, bool shr>
  class LqView : public ViewBase<VX,VY,VZ> {
  protected:
    using ViewBase<VX,VY,VZ>::x;
    using ViewBase<VX,VY,VZ>::z;
    using ViewBase<VX,VY,VZ>::c;
    using ViewBase<VX,VY,VZ>::y;
    using ViewBase<VX,VY,VZ>::count;
    using ViewBase<VX,VY,VZ>::atleast;
    using ViewBase<VX,VY,VZ>::atmost;
    using ViewBase<VX,VY,VZ>::sharing;

    LqView(Space& home, LqView& p);
  public:
    LqView(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
  };

  template<class VX, class VY, class VZ, bool shr, bool dom>
  class GqView : public ViewBase<VX,VY,VZ> {
  protected:
    using ViewBase<VX,VY,VZ>::x;
    using ViewBase<VX,VY,VZ>::z;
    using ViewBase<VX,VY,VZ>::c;
    using ViewBase<VX,VY,VZ>::y;
    using ViewBase<VX,VY,VZ>::count;
    using ViewBase<VX,VY,VZ>::atleast;
    using ViewBase<VX,VY,VZ>::atmost;
    using ViewBase<VX,VY,VZ>::sharing;

    GqView(Space& home, GqView& p);
  public:
    GqView(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
    virtual Actor* copy(Space& home);
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
    static ExecStatus post(Home home, ViewArray<VX>& x, VY y, VZ z, int c);
  };

}}}

#include <gecode/int/count/view-base.hpp>
#include <gecode/int/count/view-eq.hpp>
#include <gecode/int/count/view-gq.hpp>
#include <gecode/int/count/view-lq.hpp>

#endif

// STATISTICS: int-prop