branching-view.hpp

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main author:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2008
 *
 *  Last modified:
 *     $Date: 2009-02-24 16:44:47 +0100 (Tue, 24 Feb 2009) $ by $Author: schulte $
 *     $Revision: 8280 $
 *
 *  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.
 *
 */

namespace Gecode {


  class EmptyViewSelDesc {
  public:
    size_t size(void) const;
  };

  template <class _View>
  class ViewSelBase {
  public:
    typedef _View View;
    typedef EmptyViewSelDesc Desc;
    ViewSelBase(void);
    ViewSelBase(Space& home, const VarBranchOptions& vbo);
    EmptyViewSelDesc description(Space& home);
    void commit(Space& home, const EmptyViewSelDesc& d, unsigned a);
    void update(Space& home, bool share, ViewSelBase& vs);
    void dispose(Space& home);
  };

  template <class View>
  class ViewSelNone : public ViewSelBase<View> {
  public:
    ViewSelNone(void);
    ViewSelNone(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, View x);
    ViewSelStatus select(Space& home, View x);
  };

  template<class View>
  class ViewSelDegreeMin : public ViewSelBase<View> {
  protected:
    unsigned int degree;
  public:
    ViewSelDegreeMin(void);
    ViewSelDegreeMin(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, View x);
    ViewSelStatus select(Space& home, View x);
  };

  template<class View>
  class ViewSelDegreeMax : public ViewSelBase<View> {
  protected:
    unsigned int degree;
  public:
    ViewSelDegreeMax(void);
    ViewSelDegreeMax(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, View x);
    ViewSelStatus select(Space& home, View x);
  };

  template<class _View>
  class ViewSelRnd {
  protected:
    Support::RandomGenerator r;
    unsigned int n;
  public:
    typedef _View View;
    typedef Support::RandomGenerator Desc;
    ViewSelRnd(void);
    ViewSelRnd(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, _View x);
    ViewSelStatus select(Space& home, _View x);
    Support::RandomGenerator description(Space& home);
    void commit(Space& home, const Support::RandomGenerator& d, unsigned a);
    void update(Space& home, bool share, ViewSelRnd& vs);
    void dispose(Space& home);
  };

  // Empty view selection description
  forceinline size_t
  EmptyViewSelDesc::size(void) const {
    return sizeof(EmptyViewSelDesc);
  }

  // Selection base class
  template<class View>
  forceinline
  ViewSelBase<View>::ViewSelBase(void) {}
  template<class View>
  forceinline
  ViewSelBase<View>::ViewSelBase(Space&, const VarBranchOptions&) {}
  template<class View>
  forceinline EmptyViewSelDesc
  ViewSelBase<View>::description(Space&) {
    EmptyViewSelDesc d; return d;
  }
  template<class View>
  forceinline void
  ViewSelBase<View>::commit(Space&, const EmptyViewSelDesc&, unsigned int) {}
  template<class View>
  forceinline void
  ViewSelBase<View>::update(Space&, bool, ViewSelBase<View>&) {}
  template<class View>
  forceinline void
  ViewSelBase<View>::dispose(Space&) {}


  // Select first view
  template<class View>
  forceinline
  ViewSelNone<View>::ViewSelNone(void) {}
  template<class View>
  forceinline
  ViewSelNone<View>::ViewSelNone(Space& home, const VarBranchOptions& vbo)
    : ViewSelBase<View>(home,vbo) {}
  template<class View>
  forceinline ViewSelStatus
  ViewSelNone<View>::init(Space&, View) {
    return VSS_BEST;
  }
  template<class View>
  forceinline ViewSelStatus
  ViewSelNone<View>::select(Space&, View) {
    return VSS_BEST;
  }


  // Select variable with smallest degree
  template<class View>
  forceinline
  ViewSelDegreeMin<View>::ViewSelDegreeMin(void) : degree(0U) {}
  template<class View>
  forceinline
  ViewSelDegreeMin<View>::ViewSelDegreeMin(Space& home,
                                           const VarBranchOptions& vbo)
    : ViewSelBase<View>(home,vbo), degree(0U) {}
  template<class View>
  forceinline ViewSelStatus
  ViewSelDegreeMin<View>::init(Space&, View x) {
    degree = x.degree();
    return (degree == 0) ? VSS_BEST : VSS_BETTER;
  }
  template<class View>
  forceinline ViewSelStatus
  ViewSelDegreeMin<View>::select(Space&, View x) {
    if (x.degree() < degree) {
      degree = x.degree();
      return (degree == 0) ? VSS_BEST : VSS_BETTER;
    } else if (x.degree() > degree) {
      return VSS_WORSE;
    } else {
      return VSS_TIE;
    }
  }


  // Select variable with largest degree
  template<class View>
  forceinline
  ViewSelDegreeMax<View>::ViewSelDegreeMax(void) : degree(0) {}
  template<class View>
  forceinline
  ViewSelDegreeMax<View>::ViewSelDegreeMax(Space& home,
                                           const VarBranchOptions& vbo)
    : ViewSelBase<View>(home,vbo), degree(0U) {}
  template<class View>
  forceinline ViewSelStatus
  ViewSelDegreeMax<View>::init(Space&, View x) {
    degree = x.degree();
    return VSS_BETTER;
  }
  template<class View>
  forceinline ViewSelStatus
  ViewSelDegreeMax<View>::select(Space&, View x) {
    if (x.degree() > degree) {
      degree = x.degree();
      return VSS_BETTER;
    } else if (x.degree() < degree) {
      return VSS_WORSE;
    } else {
      return VSS_TIE;
    }
  }


  // Select variable by random
  template<class View>
  forceinline
  ViewSelRnd<View>::ViewSelRnd(void) : n(0) {}
  template<class View>
  forceinline
  ViewSelRnd<View>::ViewSelRnd(Space&, const VarBranchOptions& vbo)
    : r(vbo.seed), n(0) {}
  template<class View>
  forceinline ViewSelStatus
  ViewSelRnd<View>::init(Space&, View) {
    n=1;
    return VSS_BETTER;
  }
  template<class View>
  forceinline ViewSelStatus
  ViewSelRnd<View>::select(Space&, View) {
    n++;
    return (r(n) == (n-1)) ? VSS_BETTER : VSS_WORSE;
  }
  template<class View>
  forceinline Support::RandomGenerator
  ViewSelRnd<View>::description(Space&) {
    return r;
  }
  template<class View>
  forceinline void
  ViewSelRnd<View>::commit(Space&, const Support::RandomGenerator& d,
                           unsigned int) {
    r = d;
  }
  template<class View>
  forceinline void
  ViewSelRnd<View>::update(Space&, bool, ViewSelRnd<View>& vs) {
    r = vs.r;
  }
  template<class View>
  forceinline void
  ViewSelRnd<View>::dispose(Space&) {
  }

}

// STATISTICS: kernel-branch