brancher-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: 2011-05-11 12:44:17 +0200 (Wed, 11 May 2011) $ by $Author: tack $
 *     $Revision: 12001 $
 *
 *  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 EmptyViewSelChoice {
  public:
    size_t size(void) const;
    void archive(Archive& e) const;
  };

  template<class _View>
  class ViewSelBase {
  public:
    typedef _View View;
    typedef EmptyViewSelChoice Choice;
    ViewSelBase(void);
    ViewSelBase(Space& home, const VarBranchOptions& vbo);
    EmptyViewSelChoice choice(Space& home);
    EmptyViewSelChoice choice(const Space& home, Archive& e);
    void commit(Space& home, const EmptyViewSelChoice& c, 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 ViewSelAfcMin : public ViewSelBase<View> {
  protected:
    double afc;
  public:
    ViewSelAfcMin(void);
    ViewSelAfcMin(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, View x);
    ViewSelStatus select(Space& home, View x);
  };

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

  class ArchivedRandomGenerator : public Support::RandomGenerator {
  public:
    ArchivedRandomGenerator(void);
    ArchivedRandomGenerator(unsigned int seed);
    ArchivedRandomGenerator(const Support::RandomGenerator& r);
    void archive(Archive& e) const;
  };

  template<class _View>
  class ViewSelRnd {
  protected:
    ArchivedRandomGenerator r;
    unsigned int n;
  public:
    typedef _View View;
    typedef ArchivedRandomGenerator Choice;
    ViewSelRnd(void);
    ViewSelRnd(Space& home, const VarBranchOptions& vbo);
    ViewSelStatus init(Space& home, _View x);
    ViewSelStatus select(Space& home, _View x);
    Choice choice(Space& home);
    Choice choice(const Space& home, Archive& e);
    void commit(Space& home, const Choice& c, unsigned a);
    void update(Space& home, bool share, ViewSelRnd& vs);
    void dispose(Space& home);
  };

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

  forceinline void
  EmptyViewSelChoice::archive(Archive& e) const { (void)e; }

  // 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 EmptyViewSelChoice
  ViewSelBase<View>::choice(Space&) {
    EmptyViewSelChoice c; return c;
  }
  template<class View>
  forceinline EmptyViewSelChoice
  ViewSelBase<View>::choice(const Space&, Archive&) {
    EmptyViewSelChoice c; return c;
  }
  template<class View>
  forceinline void
  ViewSelBase<View>::commit(Space&, const EmptyViewSelChoice&, 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 with smallest afc
  template<class View>
  forceinline
  ViewSelAfcMin<View>::ViewSelAfcMin(void) : afc(0.0) {}
  template<class View>
  forceinline
  ViewSelAfcMin<View>::ViewSelAfcMin(Space& home,
                                     const VarBranchOptions& vbo)
    : ViewSelBase<View>(home,vbo), afc(0.0) {}
  template<class View>
  forceinline ViewSelStatus
  ViewSelAfcMin<View>::init(Space&, View x) {
    afc = x.afc();
    return (afc == 0.0) ? VSS_BEST : VSS_BETTER;
  }
  template<class View>
  forceinline ViewSelStatus
  ViewSelAfcMin<View>::select(Space&, View x) {
    if (x.afc() < afc) {
      afc = x.afc();
      return (afc == 0.0) ? VSS_BEST : VSS_BETTER;
    } else if (x.afc() > afc) {
      return VSS_WORSE;
    } else {
      return VSS_TIE;
    }
  }


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


  // Archived random generator
  forceinline
  ArchivedRandomGenerator::ArchivedRandomGenerator(void) {}
  forceinline
  ArchivedRandomGenerator::ArchivedRandomGenerator(unsigned int seed)
    : Support::RandomGenerator(seed) {}
  forceinline
  ArchivedRandomGenerator::ArchivedRandomGenerator
    (const Support::RandomGenerator& r) : Support::RandomGenerator(r) {}
  forceinline void
  ArchivedRandomGenerator::archive(Archive& e) const { e << seed(); }

  // 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 typename ViewSelRnd<View>::Choice
  ViewSelRnd<View>::choice(Space&) {
    return r;
  }
  template<class View>
  forceinline typename ViewSelRnd<View>::Choice
  ViewSelRnd<View>::choice(const Space&, Archive& e) {
    return Choice(e.get());
  }
  template<class View>
  forceinline void
  ViewSelRnd<View>::commit(Space&, const Choice& c, unsigned int) {
    r = c;
  }
  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