ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/CoinPresolveTighten.hpp

@@ -1,55 +0,0 @@
-/* $Id: CoinPresolveTighten.hpp 1498 2011-11-02 15:25:35Z mjs $ */
-// Copyright (C) 2002, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinPresolveTighten_H
-#define CoinPresolveTighten_H
-
-#include "CoinPresolveMatrix.hpp"
-
-// This action has no separate class;
-// instead, it decides which columns can be made fixed
-// and calls make_fixed_action::presolve.
-const CoinPresolveAction *tighten_zero_cost(CoinPresolveMatrix *prob,
-					 const CoinPresolveAction *next);
-
-#define	DO_TIGHTEN	30
-
-class do_tighten_action : public CoinPresolveAction {
-  do_tighten_action();
-  do_tighten_action(const do_tighten_action& rhs);
-  do_tighten_action& operator=(const do_tighten_action& rhs);
-
-  struct action {
-    int *rows;
-    double *lbound;
-    double *ubound;
-    int col;
-    int nrows;
-    int direction;	// just for assertions
-  };
-
-  const int nactions_;
-  const action *const actions_;
-
-  do_tighten_action(int nactions,
-		      const action *actions,
-		      const CoinPresolveAction *next) :
-    CoinPresolveAction(next),
-    nactions_(nactions), actions_(actions) {}
-
- public:
-  const char *name() const;
-
-  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
-					 const CoinPresolveAction *next);
-
-  void postsolve(CoinPostsolveMatrix *prob) const;
-
-  virtual ~do_tighten_action();
-
-};
-#endif
-
-

data/ext/ruby-cbc/install/include/coin/CoinPresolveTripleton.hpp

@@ -1,66 +0,0 @@
-/* $Id: CoinPresolveTripleton.hpp 1498 2011-11-02 15:25:35Z mjs $ */
-// Copyright (C) 2003, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinPresolveTripleton_H
-#define CoinPresolveTripleton_H
-#define TRIPLETON 11
-/** We are only going to do this if it does not increase number of elements?.
-    It could be generalized to more than three but it seems unlikely it would
-    help.
-
-    As it is adapted from doubleton icoly is one dropped.
- */
-class tripleton_action : public CoinPresolveAction {
- public:
-  struct action {
-    int icolx;
-    int icolz;
-    int row;
-
-    int icoly;
-    double cloy;
-    double cupy;
-    double costy;
-    double clox;
-    double cupx;
-    double costx;
-
-    double rlo;
-    double rup;
-
-    double coeffx;
-    double coeffy;
-    double coeffz;
-
-    double *colel;
-
-    int ncolx;
-    int ncoly;
-  };
-
-  const int nactions_;
-  const action *const actions_;
-
- private:
-  tripleton_action(int nactions,
-		      const action *actions,
-		      const CoinPresolveAction *next) :
-    CoinPresolveAction(next),
-    nactions_(nactions), actions_(actions)
-{}
-
- public:
-  const char *name() const { return ("tripleton_action"); }
-
-  static const CoinPresolveAction *presolve(CoinPresolveMatrix *,
-					 const CoinPresolveAction *next);
-  
-  void postsolve(CoinPostsolveMatrix *prob) const;
-
-  virtual ~tripleton_action();
-};
-#endif
-
-

data/ext/ruby-cbc/install/include/coin/CoinPresolveUseless.hpp

@@ -1,63 +0,0 @@
-/* $Id: CoinPresolveUseless.hpp 1566 2012-11-29 19:33:56Z lou $ */
-// Copyright (C) 2002, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinPresolveUseless_H
-#define CoinPresolveUseless_H
-#define	USELESS		20
-
-class useless_constraint_action : public CoinPresolveAction {
-  struct action {
-    double rlo;
-    double rup;
-    const int *rowcols;
-    const double *rowels;
-    int row;
-    int ninrow;
-  };
-
-  const int nactions_;
-  const action *const actions_;
-
-  useless_constraint_action(int nactions,
-                            const action *actions,
-                            const CoinPresolveAction *next);
-
- public:
-  const char *name() const;
-
-  // These rows are asserted to be useless,
-  // that is, given a solution the row activity
-  // must be in range.
-  static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob,
-					 const int *useless_rows,
-					 int nuseless_rows,
-					 const CoinPresolveAction *next);
-
-  void postsolve(CoinPostsolveMatrix *prob) const;
-
-  virtual ~useless_constraint_action();
-
-};
-
-/*! \relates useless_constraint_action
-    \brief Scan constraints looking for useless constraints
-
-  A front end to identify useless constraints and hand them to
-  useless_constraint_action::presolve() for processing.
-
-  In a bit more detail, the routine implements a greedy algorithm that
-  identifies a set of necessary constraints. A constraint is necessary if it
-  implies a tighter bound on a variable than the original column bound. These
-  tighter column bounds are then used to calculate row activity and identify
-  constraints that are useless given the presence of the necessary
-  constraints. 
-*/
-
-const CoinPresolveAction *testRedundant(CoinPresolveMatrix *prob,
-					const CoinPresolveAction *next) ;
-
-
-
-#endif

data/ext/ruby-cbc/install/include/coin/CoinPresolveZeros.hpp

@@ -1,60 +0,0 @@
-/* $Id: CoinPresolveZeros.hpp 1498 2011-11-02 15:25:35Z mjs $ */
-// Copyright (C) 2002, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinPresolveZeros_H
-#define CoinPresolveZeros_H
-
-/*! \file
-
-  Drop/reintroduce explicit zeros.
-*/
-
-#define	DROP_ZERO	8
-
-/*! \brief Tracking information for an explicit zero coefficient
-
-  \todo Why isn't this a nested class in drop_zero_coefficients_action?
-	That would match the structure of other presolve classes.
-*/
-
-struct dropped_zero {
-  int row;
-  int col;
-};
-
-/*! \brief Removal of explicit zeros
-
-  The presolve action for this class removes explicit zeros from the constraint
-  matrix. The postsolve action puts them back.
-*/
-class drop_zero_coefficients_action : public CoinPresolveAction {
-
-  const int nzeros_;
-  const dropped_zero *const zeros_;
-
-  drop_zero_coefficients_action(int nzeros,
-				const dropped_zero *zeros,
-				const CoinPresolveAction *next) :
-    CoinPresolveAction(next),
-    nzeros_(nzeros), zeros_(zeros)
-{}
-
- public:
-  const char *name() const { return ("drop_zero_coefficients_action"); }
-
-  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
-					 int *checkcols,
-					 int ncheckcols,
-					 const CoinPresolveAction *next);
-
-  void postsolve(CoinPostsolveMatrix *prob) const;
-
-  virtual ~drop_zero_coefficients_action() { deleteAction(zeros_,dropped_zero*); }
-};
-
-const CoinPresolveAction *drop_zero_coefficients(CoinPresolveMatrix *prob,
-					      const CoinPresolveAction *next);
-
-#endif

data/ext/ruby-cbc/install/include/coin/CoinRational.hpp

@@ -1,44 +0,0 @@
-// Authors: Matthew Saltzman and Ted Ralphs
-// Copyright 2015, Matthew Saltzman and Ted Ralphs
-// Licensed under the Eclipse Public License 1.0
-
-#ifndef CoinRational_H
-#define CoinRational_H
-
-#include <cmath>
-
-//Small class for rational numbers
-class CoinRational
-{
-
-public :
-   long getDenominator() { return denominator_; }
-   long getNumerator() { return numerator_; }
-
-   CoinRational(): 
-      numerator_(0),
-      denominator_(1)
-   {};
-   
-   CoinRational(long n, long d):
-      numerator_(n),
-      denominator_(d)
-   {};
-
-   CoinRational(double val, double maxdelta, long maxdnom)
-   {
-      if (!nearestRational_(val, maxdelta, maxdnom)){
-	 numerator_ = 0;
-	 denominator_ = 1;
-      }	    
-   };
-
-private :
-
-   long numerator_;
-   long denominator_;
-     
-   bool nearestRational_(double val, double maxdelta, long maxdnom);
-};
-
-#endif

data/ext/ruby-cbc/install/include/coin/CoinSearchTree.hpp

@@ -1,465 +0,0 @@
-/* $Id: CoinSearchTree.hpp 1824 2015-04-04 16:27:28Z tkr $ */
-// Copyright (C) 2006, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CoinSearchTree_H
-#define CoinSearchTree_H
-
-#include <vector>
-#include <algorithm>
-#include <cmath>
-#include <string>
-
-#include "CoinFinite.hpp"
-#include "CoinHelperFunctions.hpp"
-
-// #define DEBUG_PRINT
-
-//#############################################################################
-
-class BitVector128 {
-  friend bool operator<(const BitVector128& b0, const BitVector128& b1);
-private:
-  unsigned int bits_[4];
-public:
-  BitVector128();
-  BitVector128(unsigned int bits[4]);
-  ~BitVector128() {}
-  void set(unsigned int bits[4]);
-  void setBit(int i);
-  void clearBit(int i);
-  std::string str() const;
-};
-
-bool operator<(const BitVector128& b0, const BitVector128& b1);
-
-//#############################################################################
-
-/** A class from which the real tree nodes should be derived from. Some of the
-    data that undoubtedly exist in the real tree node is replicated here for
-    fast access. This class is used in the various comparison functions. */
-class CoinTreeNode {
-protected:
-    CoinTreeNode() :
-	depth_(-1),
-	fractionality_(-1),
-	quality_(-COIN_DBL_MAX),
-	true_lower_bound_(-COIN_DBL_MAX),
-	preferred_() {}
-    CoinTreeNode(int d,
-		 int f = -1,
-		 double q = -COIN_DBL_MAX,
-		 double tlb = -COIN_DBL_MAX,
-		 BitVector128 p = BitVector128()) :
-	depth_(d),
-	fractionality_(f),
-	quality_(q),
-	true_lower_bound_(tlb),
-	preferred_(p) {}
-    CoinTreeNode(const CoinTreeNode& x) :
-	depth_(x.depth_),
-	fractionality_(x.fractionality_),
-	quality_(x.quality_),
-	true_lower_bound_(x.true_lower_bound_),
-	preferred_(x.preferred_) {}
-    CoinTreeNode& operator=(const CoinTreeNode& x) {
-        if (this != &x) {
-	  depth_ = x.depth_;
-	  fractionality_ = x.fractionality_;
-	  quality_ = x.quality_;
-	  true_lower_bound_ = x.true_lower_bound_;
-	  preferred_ = x.preferred_;
-	}
-	return *this;
-    }
-private:
-    /// The depth of the node in the tree
-    int depth_;
-    /** A measure of fractionality, e.g., the number of unsatisfied
-	integrality requirements */
-    int fractionality_;
-    /** Some quality for the node. For normal branch-and-cut problems the LP
-	relaxation value will do just fine. It is probably an OK approximation
-	even if column generation is done. */
-    double quality_;
-    /** A true lower bound on the node. May be -infinity. For normal
-	branch-and-cut problems the LP relaxation value is OK. It is different
-	when column generation is done. */
-    double true_lower_bound_;
-    /** */
-    BitVector128 preferred_;
-public:
-    virtual ~CoinTreeNode() {}
-
-    inline int          getDepth()         const { return depth_; }
-    inline int          getFractionality() const { return fractionality_; }
-    inline double       getQuality()       const { return quality_; }
-    inline double       getTrueLB()        const { return true_lower_bound_; }
-    inline BitVector128 getPreferred()     const { return preferred_; }
-    
-    inline void setDepth(int d)              { depth_ = d; }
-    inline void setFractionality(int f)      { fractionality_ = f; }
-    inline void setQuality(double q)         { quality_ = q; }
-    inline void setTrueLB(double tlb)        { true_lower_bound_ = tlb; }
-    inline void setPreferred(BitVector128 p) { preferred_ = p; }
-};
-
-//==============================================================================
-
-class CoinTreeSiblings {
-private:
-    CoinTreeSiblings();
-    CoinTreeSiblings& operator=(const CoinTreeSiblings&);
-private:
-    int current_;
-    int numSiblings_;
-    CoinTreeNode** siblings_;
-public:
-    CoinTreeSiblings(const int n, CoinTreeNode** nodes) :
-	current_(0), numSiblings_(n), siblings_(new CoinTreeNode*[n])
-    {
-	CoinDisjointCopyN(nodes, n, siblings_);
-    }
-    CoinTreeSiblings(const CoinTreeSiblings& s) :
-	current_(s.current_),
-	numSiblings_(s.numSiblings_),
-	siblings_(new CoinTreeNode*[s.numSiblings_])
-    {
-	CoinDisjointCopyN(s.siblings_, s.numSiblings_, siblings_);
-    }
-    ~CoinTreeSiblings() { delete[] siblings_; }
-    inline CoinTreeNode* currentNode() const { return siblings_[current_]; }
-    /** returns false if cannot be advanced */
-    inline bool advanceNode() { return ++current_ != numSiblings_; }
-    inline int toProcess() const { return numSiblings_ - current_; }
-    inline int size() const { return numSiblings_; }
-    inline void printPref() const {
-      for (int i = 0; i < numSiblings_; ++i) {
-	std::string pref = siblings_[i]->getPreferred().str();
-	printf("prefs of sibligs: sibling[%i]: %s\n", i, pref.c_str());
-      }
-    }
-};
-
-//#############################################################################
-
-/** Function objects to compare search tree nodes. The comparison function
-    must return true if the first argument is "better" than the second one,
-    i.e., it should be processed first. */
-/*@{*/
-/** Depth First Search. */
-struct CoinSearchTreeComparePreferred {
-  static inline const char* name() { return "CoinSearchTreeComparePreferred"; }
-  inline bool operator()(const CoinTreeSiblings* x,
-			 const CoinTreeSiblings* y) const {
-    register const CoinTreeNode* xNode = x->currentNode();
-    register const CoinTreeNode* yNode = y->currentNode();
-    const BitVector128 xPref = xNode->getPreferred();
-    const BitVector128 yPref = yNode->getPreferred();
-    bool retval = true;
-    if (xPref < yPref) {
-      retval = true;
-    } else if (yPref < xPref) {
-      retval = false;
-    } else {
-      retval = xNode->getQuality() < yNode->getQuality();
-    }
-#ifdef DEBUG_PRINT
-    printf("Comparing xpref (%s) and ypref (%s) : %s\n",
-	   xpref.str().c_str(), ypref.str().c_str(), retval ? "T" : "F");
-#endif
-    return retval;
-  }
-};
-
-//-----------------------------------------------------------------------------
-/** Depth First Search. */
-struct CoinSearchTreeCompareDepth {
-  static inline const char* name() { return "CoinSearchTreeCompareDepth"; }
-  inline bool operator()(const CoinTreeSiblings* x,
-			 const CoinTreeSiblings* y) const {
-#if 1
-    return x->currentNode()->getDepth() >= y->currentNode()->getDepth();
-#else
-    if(x->currentNode()->getDepth() > y->currentNode()->getDepth())
-      return 1;
-    if(x->currentNode()->getDepth() == y->currentNode()->getDepth() &&
-       x->currentNode()->getQuality() <= y->currentNode()->getQuality())
-      return 1;
-    return 0;
-#endif
-  }
-};
-
-//-----------------------------------------------------------------------------
-/* Breadth First Search */
-struct CoinSearchTreeCompareBreadth {
-  static inline const char* name() { return "CoinSearchTreeCompareBreadth"; }
-  inline bool operator()(const CoinTreeSiblings* x,
-			 const CoinTreeSiblings* y) const {
-    return x->currentNode()->getDepth() < y->currentNode()->getDepth();
-  }
-};
-
-//-----------------------------------------------------------------------------
-/** Best first search */
-struct CoinSearchTreeCompareBest {
-  static inline const char* name() { return "CoinSearchTreeCompareBest"; }
-  inline bool operator()(const CoinTreeSiblings* x,
-			 const CoinTreeSiblings* y) const {
-    return x->currentNode()->getQuality() < y->currentNode()->getQuality();
-  }
-};
-
-//#############################################################################
-
-class CoinSearchTreeBase
-{
-private:
-    CoinSearchTreeBase(const CoinSearchTreeBase&);
-    CoinSearchTreeBase& operator=(const CoinSearchTreeBase&);
-
-protected:
-    std::vector<CoinTreeSiblings*> candidateList_;
-    int numInserted_;
-    int size_;
-
-protected:
-    CoinSearchTreeBase() : candidateList_(), numInserted_(0), size_(0) {}
-
-    virtual void realpop() = 0;
-    virtual void realpush(CoinTreeSiblings* s) = 0;
-    virtual void fixTop() = 0;
-
-public:
-    virtual ~CoinSearchTreeBase() {}
-    virtual const char* compName() const = 0;
-
-    inline const std::vector<CoinTreeSiblings*>& getCandidates() const {
-	return candidateList_;
-    }
-    inline bool empty() const { return candidateList_.empty(); }
-    inline int size() const { return size_; }
-    inline int numInserted() const { return numInserted_; }
-    inline CoinTreeNode* top() const {
-       if (size_ == 0 || candidateList_.size() == 0)
-	return NULL;
-#ifdef DEBUG_PRINT
-      char output[44];
-      output[43] = 0;
-      candidateList_.front()->currentNode()->getPreferred().print(output);
-      printf("top's pref: %s\n", output);
-#endif
-      return candidateList_.front()->currentNode();
-    }
-    /** pop will advance the \c next pointer among the siblings on the top and
-	then moves the top to its correct position. #realpop is the method
-	that actually removes the element from the heap */
-    inline void pop() {
-	CoinTreeSiblings* s = candidateList_.front();
-	if (!s->advanceNode()) {
-	    realpop();
-	    delete s;
-	} else {
-	    fixTop();
-	}
-	--size_;
-    }
-    inline void push(int numNodes, CoinTreeNode** nodes,
-		     const bool incrInserted = true) {
-	CoinTreeSiblings* s = new CoinTreeSiblings(numNodes, nodes);
-	realpush(s);
-	if (incrInserted) {
-	    numInserted_ += numNodes;
-	}
-	size_ += numNodes;
-    }
-    inline void push(const CoinTreeSiblings& sib,
-		     const bool incrInserted = true) {
-	CoinTreeSiblings* s = new CoinTreeSiblings(sib);
-#ifdef DEBUG_PRINT
-	s->printPref();
-#endif
-	realpush(s);
-	if (incrInserted) {
-	    numInserted_ += sib.toProcess();
-	}
-	size_ += sib.toProcess();
-    }
-};
-
-//#############################################################################
-
-// #define CAN_TRUST_STL_HEAP
-#ifdef CAN_TRUST_STL_HEAP
-
-template <class Comp>
-class CoinSearchTree : public CoinSearchTreeBase
-{
-private:
-    Comp comp_;
-protected:
-    virtual void realpop() {
-	candidateList_.pop_back();
-    }
-    virtual void fixTop() {
-	CoinTreeSiblings* s = top();
-	realpop();
-	push(s, false);
-    }
-    virtual void realpush(CoinTreeSiblings* s) {
-	nodes_.push_back(s);
-	std::push_heap(candidateList_.begin(), candidateList_.end(), comp_);
-    }
-public:
-    CoinSearchTree() : CoinSearchTreeBase(), comp_() {}
-    CoinSearchTree(const CoinSearchTreeBase& t) :
-	CoinSearchTreeBase(), comp_() {
-	candidateList_ = t.getCandidates();
-	std::make_heap(candidateList_.begin(), candidateList_.end(), comp_);
-	numInserted_ = t.numInserted_;
-	size_ = t.size_;
-    }
-    ~CoinSearchTree() {}
-    const char* compName() const { return Comp::name(); }
-};
-
-#else
-
-template <class Comp>
-class CoinSearchTree : public CoinSearchTreeBase
-{
-private:
-    Comp comp_;
-
-protected:
-    virtual void realpop() {
-	candidateList_[0] = candidateList_.back();
-	candidateList_.pop_back();
-	fixTop();
-    }
-    /** After changing data in the top node, fix the heap */
-    virtual void fixTop() {
-	const size_t size = candidateList_.size();
-	if (size > 1) {
-	    CoinTreeSiblings** candidates = &candidateList_[0];
-	    CoinTreeSiblings* s = candidates[0];
-	    --candidates;
-	    size_t pos = 1;
-	    size_t ch;
-	    for (ch = 2; ch < size; pos = ch, ch *= 2) {
-		if (comp_(candidates[ch+1], candidates[ch]))
-		    ++ch;
-		if (comp_(s, candidates[ch]))
-		    break;
-		candidates[pos] = candidates[ch];
-	    }
-	    if (ch == size) {
-		if (comp_(candidates[ch], s)) {
-		    candidates[pos] = candidates[ch];
-		    pos = ch;
-		}
-	    }
-	    candidates[pos] = s;
-	}
-    }
-    virtual void realpush(CoinTreeSiblings* s) {
-	candidateList_.push_back(s);
-	CoinTreeSiblings** candidates = &candidateList_[0];
-	--candidates;
-	size_t pos = candidateList_.size();
-	size_t ch;
-	for (ch = pos/2; ch != 0; pos = ch, ch /= 2) {
-	    if (comp_(candidates[ch], s))
-		break;
-	    candidates[pos] = candidates[ch];
-	}
-	candidates[pos] = s;
-    }
-  
-public:
-    CoinSearchTree() : CoinSearchTreeBase(), comp_() {}
-    CoinSearchTree(const CoinSearchTreeBase& t) :
-	CoinSearchTreeBase(), comp_() {
-	candidateList_ = t.getCandidates();
-	std::sort(candidateList_.begin(), candidateList_.end(), comp_);
-	numInserted_ = t.numInserted();
-	size_ = t.size();
-    }
-    virtual ~CoinSearchTree() {}
-    const char* compName() const { return Comp::name(); }
-};
-
-#endif
-
-//#############################################################################
-
-enum CoinNodeAction {
-    CoinAddNodeToCandidates,
-    CoinTestNodeForDiving,
-    CoinDiveIntoNode
-};
-
-class CoinSearchTreeManager
-{
-private:
-    CoinSearchTreeManager(const CoinSearchTreeManager&);
-    CoinSearchTreeManager& operator=(const CoinSearchTreeManager&);
-private:
-    CoinSearchTreeBase* candidates_;
-    int numSolution;
-    /** Whether there is an upper bound or not. The upper bound may have come
-	as input, not necessarily from a solution */
-    bool hasUB_;
-
-    /** variable used to test whether we need to reevaluate search strategy */
-    bool recentlyReevaluatedSearchStrategy_;
-    
-public:
-    CoinSearchTreeManager() :
-	candidates_(NULL),
-	numSolution(0),
-	recentlyReevaluatedSearchStrategy_(true)
-    {}
-    virtual ~CoinSearchTreeManager() {
-	delete candidates_;
-    }
-    
-    inline void setTree(CoinSearchTreeBase* t) {
-	delete candidates_;
-	candidates_ = t;
-    }
-    inline CoinSearchTreeBase* getTree() const {
-	return candidates_;
-    }
-
-    inline bool empty() const { return candidates_->empty(); }
-    inline size_t size() const { return candidates_->size(); }
-    inline size_t numInserted() const { return candidates_->numInserted(); }
-    inline CoinTreeNode* top() const { return candidates_->top(); }
-    inline void pop() { candidates_->pop(); }
-    inline void push(CoinTreeNode* node, const bool incrInserted = true) {
-	candidates_->push(1, &node, incrInserted);
-    }
-    inline void push(const CoinTreeSiblings& s, const bool incrInserted=true) {
-	candidates_->push(s, incrInserted);
-    }
-    inline void push(const int n, CoinTreeNode** nodes,
-		     const bool incrInserted = true) {
-	candidates_->push(n, nodes, incrInserted);
-    }
-
-    inline CoinTreeNode* bestQualityCandidate() const {
-	return candidates_->top();
-    }
-    inline double bestQuality() const {
-	return candidates_->top()->getQuality();
-    }
-    void newSolution(double solValue);
-    void reevaluateSearchStrategy();
-};
-
-//#############################################################################
-
-#endif