dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/branch.cpp

@@ -0,0 +1,121 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *     Mikael Lagerkvist, 2008
+ *
+ *  Last modified:
+ *     $Date: 2011-05-11 20:44:17 +1000 (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.
+ *
+ */
+
+#include <gecode/kernel.hh>
+
+namespace Gecode {
+
+  const VarBranchOptions VarBranchOptions::def;
+
+  const ValBranchOptions ValBranchOptions::def;
+
+  const TieBreakVarBranchOptions TieBreakVarBranchOptions::def;
+
+
+  /*
+   * Function brancher
+   */
+
+  /// %Brancher for calling a function
+  class GECODE_KERNEL_EXPORT FunctionBranch : public Brancher {
+  protected:
+    /// Minimal brancher description storing no information
+    class GECODE_KERNEL_EXPORT Description : public Choice {
+    public:
+      /// Initialize description for brancher \a b, number of alternatives \a a.
+      Description(const Brancher& b, unsigned int a) : Choice(b,a) {}
+      /// Report size occupied
+      virtual size_t size(void) const { return sizeof(Description); }
+      /// Archive into \a e
+      virtual void archive(Archive& e) const {
+        Choice::archive(e);
+      }
+    };
+    /// Function to call
+    void (*f)(Space&);
+    /// Call function just once
+    bool done;
+    /// Construct brancher
+    FunctionBranch(Home home, void (*f0)(Space&))
+      : Brancher(home), f(f0), done(false) {}
+    /// Copy constructor
+    FunctionBranch(Space& home, bool share, FunctionBranch& b)
+      : Brancher(home,share,b), f(b.f), done(b.done) {}
+  public:
+    /// Check status of brancher, return true if alternatives left
+    virtual bool status(const Space&) const {
+      return !done;
+    }
+    /// Return choice
+    virtual const Choice* choice(Space&) {
+      assert(!done);
+      return new Description(*this,1);
+    }
+    /// Return choice
+    virtual const Choice* choice(const Space&, Archive&) {
+      return new Description(*this,1);
+    }
+    /// Perform commit
+    virtual ExecStatus 
+    commit(Space& home, const Choice&, unsigned int) {
+      done = true;
+      f(home);
+      return home.failed() ? ES_FAILED : ES_OK;
+    }
+    /// Copy brancher
+    virtual Actor* copy(Space& home, bool share) {
+      return new (home) FunctionBranch(home,share,*this);
+    }
+    /// Post brancher
+    static void post(Home home, void (*f)(Space&)) {
+      (void) new (home) FunctionBranch(home,f);
+    }
+  };
+
+
+  void
+  branch(Home home, void (*f)(Space& home)) {
+    if (home.failed())
+      return;
+    FunctionBranch::post(home,f);
+  }
+
+}
+
+// STATISTICS: kernel-branch

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/branch.hpp

@@ -0,0 +1,254 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2010-09-03 18:30:37 +1000 (Fri, 03 Sep 2010) $ by $Author: schulte $
+ *     $Revision: 11386 $
+ *
+ *  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 <ctime>
+
+namespace Gecode {
+
+  /**
+   * \defgroup TaskModelBranch Generic branching support
+   *
+   * Support for options to branchings, tie-breaking, filter functions, 
+   * and branchings that are independent of a particular variable domain.
+   *
+   * \ingroup TaskModel
+   */
+
+  /** \brief Branch filter function type
+   * \ingroup TaskModelBranch
+   */
+  typedef bool (*BranchFilter)(const Space& home, int i, const Var& x);
+
+  /** \brief Variable branch options
+   * \ingroup TaskModelBranch
+   */
+  class VarBranchOptions {
+  public:
+    /// Branch filter function
+    BranchFilter bf;
+    /// Seed for random variable selection
+    unsigned int seed;
+    /// Default options
+    GECODE_KERNEL_EXPORT static const VarBranchOptions def;
+    /// Initialize with default values
+    VarBranchOptions(BranchFilter bf0=NULL);
+    /// Return object with time-based seed value
+    static VarBranchOptions time(BranchFilter bf=NULL);
+  };
+
+  /** \brief Value branch options
+   * \ingroup TaskModelBranch
+   */
+  class ValBranchOptions {
+  public:
+    /// Seed for random value selection
+    unsigned int seed;
+    /// Default options
+    GECODE_KERNEL_EXPORT static const ValBranchOptions def;
+    /// Initialize with default values
+    ValBranchOptions(void);
+    /// Return object with time-based seed value
+    static ValBranchOptions time(void);
+  };
+
+
+  /// Combine variable selection criteria for tie-breaking
+  template<class VarBranch>
+  class TieBreakVarBranch {
+  public:
+    /// Branching criteria to try in order
+    VarBranch a, b, c, d;
+    /// Initialize with variable selection criteria
+    TieBreakVarBranch(VarBranch a0 = static_cast<VarBranch>(0),
+                      VarBranch b0 = static_cast<VarBranch>(0),
+                      VarBranch c0 = static_cast<VarBranch>(0),
+                      VarBranch d0 = static_cast<VarBranch>(0));
+  };
+
+  /// Combine variable branch options for tie-breaking
+  class TieBreakVarBranchOptions {
+  public:
+    /// Options for branching criteria to try in order
+    VarBranchOptions a, b, c, d;
+    /// Default options
+    GECODE_KERNEL_EXPORT static const TieBreakVarBranchOptions def;
+    /// Initialize with variable selection criteria
+    TieBreakVarBranchOptions(const VarBranchOptions& a0
+                             = VarBranchOptions::def,
+                             const VarBranchOptions& b0
+                             = VarBranchOptions::def,
+                             const VarBranchOptions& c0
+                             = VarBranchOptions::def,
+                             const VarBranchOptions& d0
+                             = VarBranchOptions::def);
+  };
+
+  /** 
+   * \defgroup TaskModelBranchTieBreak Tie-breaking for variable selection
+   * 
+   * \ingroup TaskModelBranch
+   */
+  //@{
+  /// Combine variable selection criteria \a a and \a b for tie-breaking
+  template<class VarBranch>
+  TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b);
+  /// Combine variable selection criteria \a a, \a b, and \a c for tie-breaking
+  template<class VarBranch>
+  TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b, VarBranch c);
+  /// Combine variable selection criteria \a a, \a b, \a c, and \a d for tie-breaking
+  template<class VarBranch>
+  TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b, VarBranch c, VarBranch d);
+  /// Combine variable branch options \a a and \a b for tie-breaking
+  TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b);
+  /// Combine variable branch options \a a, \a b, and \a c for tie-breaking
+  TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b, VarBranchOptions c);
+  /// Combine variable branch options \a a, \a b, \a c, and \a d for tie-breaking
+  TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b, VarBranchOptions c,
+           VarBranchOptions d);
+  //@}
+
+  /** 
+   * \defgroup TaskModelBranchExec Branch with a function
+   * 
+   * This does not really branch (it just offers a single alternative) but
+   * executes a single function during branching. A typical
+   * application is to post more constraints after another brancher 
+   * has finished.
+   *
+   * \ingroup TaskModelBranch
+   */
+  //@{
+  /// Call the function \a f (with the current space as argument) for branching
+  GECODE_KERNEL_EXPORT void
+  branch(Home home, void (*f)(Space& home));
+  //@}
+
+
+  // Variable branch options
+  forceinline
+  VarBranchOptions::VarBranchOptions(BranchFilter bf0) 
+    : bf(bf0), seed(0) {}
+
+  forceinline VarBranchOptions
+  VarBranchOptions::time(BranchFilter bf) {
+    VarBranchOptions o(bf); 
+    o.seed=static_cast<unsigned int>(::time(NULL));
+    return o;
+  }
+
+  // Value branch options
+  forceinline
+  ValBranchOptions::ValBranchOptions(void) : seed(0) {}
+
+  forceinline ValBranchOptions
+  ValBranchOptions::time(void) {
+    ValBranchOptions o; o.seed=static_cast<unsigned int>(::time(NULL));
+    return o;
+  }
+
+
+  /*
+   * Combine variable selection criteria for tie-breaking
+   */
+  template<class VarBranch>
+  forceinline
+  TieBreakVarBranch<VarBranch>::TieBreakVarBranch(VarBranch a0,
+                                                  VarBranch b0,
+                                                  VarBranch c0,
+                                                  VarBranch d0)
+    : a(a0), b(b0), c(c0), d(d0) {}
+
+  template<class VarBranch>
+  forceinline TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b) {
+    TieBreakVarBranch<VarBranch> ab(a,b);
+    return ab;
+  }
+
+  template<class VarBranch>
+  forceinline TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b, VarBranch c) {
+    TieBreakVarBranch<VarBranch> abc(a,b,c);
+    return abc;
+  }
+
+  template<class VarBranch>
+  forceinline TieBreakVarBranch<VarBranch>
+  tiebreak(VarBranch a, VarBranch b, VarBranch c, VarBranch d) {
+    TieBreakVarBranch<VarBranch> abcd(a,b,c,d);
+    return abcd;
+  }
+
+  /*
+   * Combine branch options for tie-breaking
+   */
+  forceinline
+  TieBreakVarBranchOptions::
+  TieBreakVarBranchOptions(const VarBranchOptions& a0,
+                           const VarBranchOptions& b0,
+                           const VarBranchOptions& c0,
+                           const VarBranchOptions& d0)
+    : a(a0), b(b0), c(c0), d(d0) {}
+
+  forceinline TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b) {
+    TieBreakVarBranchOptions ab(a,b);
+    return ab;
+  }
+
+  forceinline TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b, VarBranchOptions c) {
+    TieBreakVarBranchOptions abc(a,b,c);
+    return abc;
+  }
+
+  forceinline TieBreakVarBranchOptions
+  tiebreak(VarBranchOptions a, VarBranchOptions b, VarBranchOptions c,
+           VarBranchOptions d) {
+    TieBreakVarBranchOptions abcd(a,b,c,d);
+    return abcd;
+  }
+
+}
+
+// STATISTICS: kernel-branch

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/brancher-tiebreak.hpp

@@ -0,0 +1,615 @@
+/* -*- 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 20:44:17 +1000 (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 {
+
+  /**
+   * \defgroup TaskBranchTieBreak Generic view tie-breaking for brancher based on view and value selection
+   *
+   * \ingroup TaskBranchViewVal
+   */
+  //@{
+  /**
+   * \brief View selection class for static tie breaking
+   */
+  template<class A, class B>
+  class ViewSelTieBreakStatic {
+  protected:
+    /// First selection class
+    A a;
+    /// Second selection class
+    B b;
+  public:
+    /// View type
+    typedef typename A::View View;
+    /// View selection choice
+    class Choice {
+    public:
+      /// First choice
+      typename A::Choice a;
+      /// Second choice
+      typename B::Choice b;
+      /// Constructor
+      Choice(const typename A::Choice& a, const typename B::Choice& b);
+      /// Report size occupied
+      size_t size(void) const;
+      /// Archive into \a e
+      void archive(Archive& e) const;
+    };
+    /// Default constructor
+    ViewSelTieBreakStatic(void);
+    /// Constructor for initialization
+    ViewSelTieBreakStatic(Space& home, A& a, B& b);
+    /// Intialize with view \a x
+    ViewSelStatus init(Space& home, typename A::View x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(Space& home, typename A::View x);
+    /// Return choice
+    Choice choice(Space& home);
+    /// Return choice
+    Choice choice(const Space& home, Archive& e);
+    /// Commit to choice
+    void commit(Space& home, const Choice& c, unsigned int a);
+    /// Updating during cloning
+    void update(Space& home, bool share, ViewSelTieBreakStatic& vs);
+    /// Delete view selection
+    void dispose(Space& home);
+  };
+
+  /**
+   * \brief Virtualized choice baseclass
+   */
+  class ChoiceVirtualBase {
+  public:
+    /// Create copy
+    virtual ChoiceVirtualBase* copy(void) const = 0;
+    /// Report size required
+    virtual size_t size(void) const = 0;
+    /// Destructor
+    GECODE_KERNEL_EXPORT virtual ~ChoiceVirtualBase(void);
+    /// Archive into \a e
+    virtual void archive(Archive& e) const = 0;
+    /// \name Memory management
+    //@{
+    /// Allocate memory
+    static void* operator new(size_t s);
+    /// Delete memory
+    static void  operator delete(void*);
+    //@}
+  };
+
+  /**
+   * \brief Virtualized view selection base class
+   */
+  template<class View>
+  class ViewSelVirtualBase {
+  public:
+    /// Intialize with view \a x
+    virtual ViewSelStatus init(Space& home, View x) = 0;
+    /// Possibly select better view \a x
+    virtual ViewSelStatus select(Space& home, View x) = 0;
+    /// Return choice
+    virtual ChoiceVirtualBase* choice(Space& home) = 0;
+    /// Return choice
+    virtual ChoiceVirtualBase* choice(const Space& home, Archive& e) = 0;
+    /// Commit to choice
+    virtual void commit(Space& home, const ChoiceVirtualBase* c, 
+                        unsigned int a) = 0;
+    /// Create copy
+    virtual ViewSelVirtualBase<View>* copy(Space& home, bool share) = 0;
+    /// Delete view selection and return its size
+    virtual size_t dispose(Space& home) = 0;
+    /// \name Memory management
+    //@{
+    /// Allocate memory from space
+    static void* operator new(size_t s, Space& home);
+    /// No-op for exceptions
+    static void  operator delete(void* p, Space& home);
+    /// Needed for exceptions
+    static void  operator delete(void*);
+    //@}
+  };
+
+  /**
+   * \brief Virtualized choice
+   */
+  template<class Choice>
+  class ChoiceVirtual : public ChoiceVirtualBase {
+  public:
+    /// Static choice object
+    Choice choice;
+    /// Constructor for initialization
+    ChoiceVirtual(const Choice& c);
+    /// Create copy
+    virtual ChoiceVirtualBase* copy(void) const;
+    /// Report size required
+    virtual size_t size(void) const;
+    /// Destructor
+    virtual ~ChoiceVirtual(void);
+    /// Archive into \a e
+    virtual void archive(Archive& e) const;
+  };
+
+  /**
+   * \brief Virtualized view selection
+   */
+  template<class ViewSel>
+  class ViewSelVirtual : public ViewSelVirtualBase<typename ViewSel::View> {
+  protected:
+    /// Static view selection object
+    ViewSel viewsel;
+  public:
+    /// Constructor for initialization
+    ViewSelVirtual(Space& home, const VarBranchOptions& vbo);
+    /// Constructor for cloning \a vsv
+    ViewSelVirtual(Space& home, bool share, ViewSelVirtual& vsv);
+    /// Intialize with view \a x
+    virtual ViewSelStatus init(Space& home, typename ViewSel::View x);
+    /// Possibly select better view \a x
+    virtual ViewSelStatus select(Space& home, typename ViewSel::View x);
+    /// Return choice
+    virtual ChoiceVirtualBase* choice(Space& home);
+    /// Return choice
+    virtual ChoiceVirtualBase* choice(const Space& home, Archive& e);
+    /// Commit to choice
+    virtual void commit(Space& home, const ChoiceVirtualBase* d,
+                        unsigned int a);
+    /// Create copy during cloning
+    virtual ViewSelVirtualBase<typename ViewSel::View>*
+    copy(Space& home, bool share);
+    /// Delete view selection and returns its size
+    virtual size_t dispose(Space& home);
+  };
+
+  /**
+   * \brief View selection class for dynamic tie breaking
+   */
+  template<class _View>
+  class ViewSelTieBreakDynamic {
+  protected:
+    /// Number of tie breakers
+    int n;
+    /// Tie breakers
+    ViewSelVirtualBase<_View>** tb;
+  public:
+    /// View type
+    typedef _View View;
+    /// %Choice for tie breakers
+    class Choice {
+    public:
+      /// Number of choices
+      int n;
+      /// Choices
+      ChoiceVirtualBase** c;
+      /// Constructor
+      Choice(Space& home, ViewSelVirtualBase<_View>** tb, int n0);
+      /// Constructor
+      Choice(const Space& home, Archive& e,
+             ViewSelVirtualBase<_View>** tb, int n0);
+      /// Copy constructor
+      Choice(const Choice& ce);
+      /// Assignment operator
+      const Choice& operator =(const Choice& ce);
+      /// Perform commit
+      void commit(Space& home, unsigned int a,
+                  ViewSelVirtualBase<_View>** tb)  const;
+      /// Report size occupied
+      size_t size(void) const;
+      /// Destructor
+      ~Choice(void);
+      /// Archive into \a e
+      void archive(Archive& e) const;
+    };
+    /// Default constructor
+    ViewSelTieBreakDynamic(void);
+    /// Constructor for initialization
+    ViewSelTieBreakDynamic(Space& home, ViewSelVirtualBase<_View>** vsv,
+                           int n);
+    /// Intialize with view \a x
+    ViewSelStatus init(Space& home, _View x);
+    /// Possibly select better view \a x
+    ViewSelStatus select(Space& home, _View x);
+    /// Return choice
+    Choice choice(Space& home);
+    /// Return choice
+    Choice choice(const Space& home, Archive& e);
+    /// Commit to choice
+    void commit(Space& home,
+                const typename ViewSelTieBreakDynamic<_View>::Choice& c,
+                unsigned int a);
+    /// Updating during cloning
+    void update(Space& home, bool share, ViewSelTieBreakDynamic& vs);
+    /// Delete view selection
+    void dispose(Space& home);
+  };
+  //@}
+
+
+  // Select variable with static tie breaking
+  template<class A, class B>
+  forceinline
+  ViewSelTieBreakStatic<A,B>::Choice::Choice(const typename A::Choice& a0,
+                                             const typename B::Choice& b0)
+    : a(a0), b(b0) {}
+  template<class A, class B>
+  forceinline size_t
+  ViewSelTieBreakStatic<A,B>::Choice::size(void) const {
+    return a.size() + b.size();
+  }
+  template<class A, class B>
+  forceinline void
+  ViewSelTieBreakStatic<A,B>::Choice::archive(Archive& e) const {
+    a.archive(e);
+    b.archive(e);
+  }
+
+  template<class A, class B>
+  forceinline
+  ViewSelTieBreakStatic<A,B>::ViewSelTieBreakStatic(void) {}
+  template<class A, class B>
+  forceinline
+  ViewSelTieBreakStatic<A,B>::
+  ViewSelTieBreakStatic(Space&, A& a0, B& b0)
+    : a(a0), b(b0) {}
+  template<class A, class B>
+  forceinline ViewSelStatus
+  ViewSelTieBreakStatic<A,B>::init(Space& home, typename A::View x) {
+    ViewSelStatus s = a.init(home,x);
+    return (b.init(home,x) != VSS_BEST) ? VSS_BETTER : s;
+  }
+  template<class A, class B>
+  forceinline ViewSelStatus
+  ViewSelTieBreakStatic<A,B>::select(Space& home, typename A::View x) {
+    switch (a.select(home,x)) {
+    case VSS_BEST:
+      return (b.init(home,x) != VSS_BEST) ? VSS_BETTER : VSS_BEST;
+    case VSS_BETTER:
+      (void) b.init(home,x);
+      return VSS_BETTER;
+    case VSS_WORSE:
+      return VSS_WORSE;
+    case VSS_TIE:
+      switch (b.select(home,x)) {
+      case VSS_BEST:   return VSS_BETTER;
+      case VSS_BETTER: return VSS_BETTER;
+      case VSS_TIE:    return VSS_TIE;
+      case VSS_WORSE:  return VSS_WORSE;
+      default: GECODE_NEVER;
+      }
+    default: GECODE_NEVER;
+      return VSS_WORSE;
+    }
+  }
+  template<class A, class B>
+  inline typename ViewSelTieBreakStatic<A,B>::Choice
+  ViewSelTieBreakStatic<A,B>::choice(Space& home) {
+    typename ViewSelTieBreakStatic<A,B>::Choice c(a.choice(home),
+                                                  b.choice(home));
+    return c;
+  }
+  template<class A, class B>
+  inline typename ViewSelTieBreakStatic<A,B>::Choice
+  ViewSelTieBreakStatic<A,B>::choice(const Space& home, Archive& e) {
+    typename ViewSelTieBreakStatic<A,B>::Choice c(a.choice(home,e),
+                                                  b.choice(home,e));
+    return c;
+  }
+  template<class A, class B>
+  forceinline void
+  ViewSelTieBreakStatic<A,B>::commit(Space& home, const Choice& c,
+                                     unsigned int al) {
+    a.commit(home, c.a, al);
+    b.commit(home, c.b, al);
+  }
+  template<class A, class B>
+  forceinline void
+  ViewSelTieBreakStatic<A,B>::update(Space& home, bool share,
+                                     ViewSelTieBreakStatic<A,B>& vstb) {
+    a.update(home,share,vstb.a);
+    b.update(home,share,vstb.b);
+  }
+  template<class A, class B>
+  forceinline void
+  ViewSelTieBreakStatic<A,B>::dispose(Space& home) {
+    a.dispose(home);
+    b.dispose(home);
+  }
+
+
+  // Virtualized view selection
+  template<class View>
+  forceinline void
+  ViewSelVirtualBase<View>::operator delete(void*) {}
+  template<class View>
+  forceinline void
+  ViewSelVirtualBase<View>::operator delete(void*, Space&) {}
+  template<class View>
+  forceinline void*
+  ViewSelVirtualBase<View>::operator new(size_t s, Space& home) {
+    return home.ralloc(s);
+  }
+
+  // Virtualized choice
+  forceinline void
+  ChoiceVirtualBase::operator delete(void* p) {
+    heap.rfree(p);
+  }
+  forceinline void*
+  ChoiceVirtualBase::operator new(size_t s) {
+    return heap.ralloc(s);
+  }
+  forceinline
+  ChoiceVirtualBase::~ChoiceVirtualBase(void) {
+  }
+
+
+  template<class Choice>
+  forceinline
+  ChoiceVirtual<Choice>::ChoiceVirtual(const Choice& c)
+    : choice(c) {}
+  template<class Choice>
+  forceinline ChoiceVirtualBase*
+  ChoiceVirtual<Choice>::copy(void) const {
+    return new ChoiceVirtual<Choice>(choice);
+  }
+  template<class Choice>
+  forceinline size_t
+  ChoiceVirtual<Choice>::size(void) const {
+    return sizeof(ChoiceVirtual<Choice>);
+  }
+  template<class Choice>
+  ChoiceVirtual<Choice>::~ChoiceVirtual(void) {}
+  template<class Choice> void
+  ChoiceVirtual<Choice>::archive(Archive& e) const {
+    choice.archive(e);
+  }
+
+  template<class ViewSel>
+  forceinline
+  ViewSelVirtual<ViewSel>::ViewSelVirtual(Space& home,
+                                          const VarBranchOptions& vbo)
+    : viewsel(home,vbo) {}
+  template<class ViewSel>
+  forceinline
+  ViewSelVirtual<ViewSel>::ViewSelVirtual(Space& home, bool share,
+                                          ViewSelVirtual<ViewSel>& vsv) {
+    viewsel.update(home,share,vsv.viewsel);
+  }
+  template<class ViewSel>
+  ViewSelStatus
+  ViewSelVirtual<ViewSel>::init(Space& home, typename ViewSel::View x) {
+    return viewsel.init(home,x);
+  }
+  template<class ViewSel>
+  ViewSelStatus
+  ViewSelVirtual<ViewSel>::select(Space& home, typename ViewSel::View x) {
+    return viewsel.select(home,x);
+  }
+  template<class ViewSel>
+  ChoiceVirtualBase*
+  ViewSelVirtual<ViewSel>::choice(Space& home) {
+    return new ChoiceVirtual<typename ViewSel::Choice>(viewsel.choice(home));
+  }
+  template<class ViewSel>
+  ChoiceVirtualBase*
+  ViewSelVirtual<ViewSel>::choice(const Space& home, Archive& e) {
+    return new ChoiceVirtual<typename ViewSel::Choice>(viewsel.choice(home,e));
+  }
+  template<class ViewSel>
+  void
+  ViewSelVirtual<ViewSel>::commit(Space& home, const ChoiceVirtualBase* _c,
+                                  unsigned int a) {
+    const ChoiceVirtual<typename ViewSel::Choice>* c =
+      static_cast<const ChoiceVirtual<typename ViewSel::Choice>*>(_c);
+    viewsel.commit(home, c->choice, a);
+  }
+  template<class ViewSel>
+  ViewSelVirtualBase<typename ViewSel::View>*
+  ViewSelVirtual<ViewSel>::copy(Space& home, bool share) {
+    return new (home) ViewSelVirtual<ViewSel>(home,share,*this);
+  }
+  template<class ViewSel>
+  size_t
+  ViewSelVirtual<ViewSel>::dispose(Space& home) {
+    viewsel.dispose(home);
+    return sizeof(ViewSelVirtual<ViewSel>);
+  }
+
+
+  // Choice for dynamic tie breaking
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::Choice::Choice
+  (Space& home, ViewSelVirtualBase<View>** tb, int n0)
+    : n(n0), c(heap.alloc<ChoiceVirtualBase*>(n)) {
+    for (int i=n; i--; )
+      c[i] = tb[i]->choice(home);
+  }
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::Choice::Choice
+  (const Space& home, Archive& e, ViewSelVirtualBase<View>** tb,
+   int n0)
+    : n(n0), c(heap.alloc<ChoiceVirtualBase*>(n)) {
+    for (int i=n; i--; )
+      c[i] = tb[i]->choice(home,e);
+  }
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::Choice::Choice(const Choice& ce)
+    : n(ce.n), c(heap.alloc<ChoiceVirtualBase*>(n)) {
+    for (int i=n; i--; )
+      c[i] = ce.c[i]->copy();
+  }
+  template<class View>
+  forceinline const typename ViewSelTieBreakDynamic<View>::Choice&
+  ViewSelTieBreakDynamic<View>::Choice::operator =(const Choice& ce) {
+    if (&ce != this) {
+      assert(ce.n == n);
+      for (int i=n; i--; ) {
+        delete c[i]; c[i] = ce.c[i]->copy();
+      }
+    }
+    return *this;
+  }
+  template<class View>
+  forceinline void
+  ViewSelTieBreakDynamic<View>::Choice::commit
+  (Space& home, unsigned int a, ViewSelVirtualBase<View>** tb)  const {
+    for (int i=n; i--; )
+      tb[i]->commit(home, c[i], a);
+  }
+  template<class View>
+  forceinline size_t
+  ViewSelTieBreakDynamic<View>::Choice::size(void) const {
+    size_t s = (sizeof(typename ViewSelTieBreakDynamic<View>::Choice) +
+                n * sizeof(ChoiceVirtualBase*));
+    for (int i=n; i--; )
+      s += c[i]->size();
+    return s;
+  }
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::Choice::~Choice(void) {
+    for (int i=n; i--; )
+      delete c[i];
+    heap.free(c,n);
+  }
+  template<class View>
+  forceinline void
+  ViewSelTieBreakDynamic<View>::Choice::archive(Archive& e) const 
+  {
+    for (int i=0; i<n; i++)
+      c[i]->archive(e);
+  }
+
+
+  // Select variable with dynamic tie breaking
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::ViewSelTieBreakDynamic(void) {}
+  template<class View>
+  forceinline
+  ViewSelTieBreakDynamic<View>::
+  ViewSelTieBreakDynamic(Space& home, ViewSelVirtualBase<View>** vsv, int n0)
+    : n(n0), tb(home.alloc<ViewSelVirtualBase<View>*>(n)) {
+    for (int i=0; i<n; i++)
+      tb[i]=vsv[i];
+    assert(n > 0);
+  }
+  template<class View>
+  forceinline ViewSelStatus
+  ViewSelTieBreakDynamic<View>::init(Space& home, View x) {
+    ViewSelStatus s = VSS_BEST;
+    for (int i=0; i<n; i++)
+      if (tb[i]->init(home,x) != VSS_BEST)
+        s = VSS_BETTER;
+    return s;
+  }
+  template<class View>
+  forceinline ViewSelStatus
+  ViewSelTieBreakDynamic<View>::select(Space& home, View x) {
+    switch (tb[0]->select(home,x)) {
+    case VSS_BEST:
+      {
+        ViewSelStatus s = VSS_BEST;
+        for (int i=1; i<n; i++)
+          if (tb[i]->init(home,x) != VSS_BEST)
+            s = VSS_BETTER;
+        return s;
+      }
+    case VSS_BETTER:
+      for (int i=1; i<n; i++)
+        (void) tb[i]->init(home,x);
+      return VSS_BETTER;
+    case VSS_WORSE:
+      return VSS_WORSE;
+    case VSS_TIE:
+      for (int i=1; i<n; i++)
+        switch (tb[i]->select(home,x)) {
+        case VSS_BEST: case VSS_BETTER:
+          for (int j=i+1; j<n; j++)
+            (void) tb[j]->init(home,x);
+          return VSS_BETTER;
+        case VSS_TIE:    break;
+        case VSS_WORSE:  return VSS_WORSE;
+        default: GECODE_NEVER;
+        }
+      return VSS_TIE;
+    default: GECODE_NEVER;
+      return VSS_WORSE;
+    }
+  }
+  template<class _View>
+  inline typename ViewSelTieBreakDynamic<_View>::Choice
+  ViewSelTieBreakDynamic<_View>::choice(Space& home) {
+    Choice c(home,tb,n);
+    return c;
+  }
+  template<class _View>
+  inline typename ViewSelTieBreakDynamic<_View>::Choice
+  ViewSelTieBreakDynamic<_View>::choice(const Space& home, Archive& e) {
+    Choice c(home,e,tb,n);
+    return c;
+  }
+  template<class _View>
+  forceinline void
+  ViewSelTieBreakDynamic<_View>::commit
+  (Space& home, const typename ViewSelTieBreakDynamic<_View>::Choice& c,
+   unsigned int a) {
+    c.commit(home,a,tb);
+  }
+  template<class _View>
+  forceinline void
+  ViewSelTieBreakDynamic<_View>::update(Space& home, bool share,
+                                        ViewSelTieBreakDynamic<_View>& vstb) {
+    n = vstb.n;
+    tb = home.alloc<ViewSelVirtualBase<View>*>(n);
+    for (int i=0; i<n; i++)
+      tb[i] = vstb.tb[i]->copy(home,share);
+  }
+  template<class _View>
+  forceinline void
+  ViewSelTieBreakDynamic<_View>::dispose(Space& home) {
+    for (int i=0; i<n; i++)
+      home.rfree(tb[i],tb[i]->dispose(home));
+    home.free<ViewSelVirtualBase<_View>*>(tb,n);
+  }
+
+}
+
+// STATISTICS: kernel-branch