ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,258 +0,0 @@
-/* $Id: CbcStrategy.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// Copyright (C) 2005, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CbcStrategy_H
-#define CbcStrategy_H
-
-#include "CbcModel.hpp"
-class CglPreProcess;
-class CbcNodeInfo;
-class CbcNode;
-class CoinWarmStartDiff;
-
-//#############################################################################
-/** Strategy base class */
-
-class CbcStrategy {
-public:
-    // Default Constructor
-    CbcStrategy ();
-
-    virtual ~CbcStrategy();
-
-    /// Clone
-    virtual CbcStrategy * clone() const = 0;
-
-    /// Setup cut generators
-    virtual void setupCutGenerators(CbcModel & model) = 0;
-    /// Setup heuristics
-    virtual void setupHeuristics(CbcModel & model) = 0;
-    /// Do printing stuff
-    virtual void setupPrinting(CbcModel & model, int modelLogLevel) = 0;
-    /// Other stuff e.g. strong branching and preprocessing
-    virtual void setupOther(CbcModel & model) = 0;
-    /// Set model depth (i.e. how nested)
-    inline void setNested(int depth) {
-        depth_ = depth;
-    }
-    /// Get model depth (i.e. how nested)
-    inline int getNested() const {
-        return depth_;
-    }
-    /// Say preProcessing done
-    inline void setPreProcessState(int state) {
-        preProcessState_ = state;
-    }
-    /// See what sort of preprocessing was done
-    inline int preProcessState() const {
-        return preProcessState_;
-    }
-    /// Pre-processing object
-    inline CglPreProcess * process() const {
-        return process_;
-    }
-    /// Delete pre-processing object to save memory
-    void deletePreProcess();
-    /// Return a new Full node information pointer (descendant of CbcFullNodeInfo)
-    virtual CbcNodeInfo * fullNodeInfo(CbcModel * model, int numberRowsAtContinuous) const;
-    /// Return a new Partial node information pointer (descendant of CbcPartialNodeInfo)
-    virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
-                                          int numberChangedBounds, const int * variables,
-                                          const double * boundChanges,
-                                          const CoinWarmStartDiff *basisDiff) const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * ) {}
-    /** After a CbcModel::resolve this can return a status
-        -1 no effect
-        0 treat as optimal
-        1 as 0 but do not do any more resolves (i.e. no more cuts)
-        2 treat as infeasible
-    */
-    virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
-private:
-
-    /// Illegal Assignment operator
-    CbcStrategy & operator=(const CbcStrategy& rhs);
-protected:
-    // Data
-    /// Model depth
-    int depth_;
-    /** PreProcessing state -
-        -1 infeasible
-        0 off
-        1 was done (so need post-processing)
-    */
-    int preProcessState_;
-    /// If preprocessing then this is object
-    CglPreProcess * process_;
-};
-
-/** Null class
- */
-
-class CbcStrategyNull : public CbcStrategy {
-public:
-
-    // Default Constructor
-    CbcStrategyNull () {}
-
-    // Copy constructor
-    CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {}
-
-    // Destructor
-    ~CbcStrategyNull () {}
-
-    /// Clone
-    virtual CbcStrategy * clone() const {
-        return new CbcStrategyNull(*this);
-    }
-
-    /// Setup cut generators
-    virtual void setupCutGenerators(CbcModel & ) {}
-    /// Setup heuristics
-    virtual void setupHeuristics(CbcModel & ) {}
-    /// Do printing stuff
-    virtual void setupPrinting(CbcModel & , int ) {}
-    /// Other stuff e.g. strong branching
-    virtual void setupOther(CbcModel & ) {}
-
-protected:
-    // Data
-private:
-    /// Illegal Assignment operator
-    CbcStrategyNull & operator=(const CbcStrategyNull& rhs);
-};
-
-/** Default class
- */
-
-class CbcStrategyDefault : public CbcStrategy {
-public:
-
-    // Default Constructor
-    CbcStrategyDefault (int cutsOnlyAtRoot = 1,
-                        int numberStrong = 5,
-                        int numberBeforeTrust = 0,
-                        int printLevel = 0);
-
-    // Copy constructor
-    CbcStrategyDefault ( const CbcStrategyDefault &);
-
-    // Destructor
-    ~CbcStrategyDefault ();
-
-    /// Clone
-    virtual CbcStrategy * clone() const;
-
-    /// Setup cut generators
-    virtual void setupCutGenerators(CbcModel & model);
-    /// Setup heuristics
-    virtual void setupHeuristics(CbcModel & model);
-    /// Do printing stuff
-    virtual void setupPrinting(CbcModel & model, int modelLogLevel) ;
-    /// Other stuff e.g. strong branching
-    virtual void setupOther(CbcModel & model);
-    /// Set up preProcessing - see below
-    inline void setupPreProcessing(int desired = 1, int passes = 10) {
-        desiredPreProcess_ = desired;
-        preProcessPasses_ = passes;
-    }
-    /// See what sort of preprocessing wanted
-    inline int desiredPreProcess() const {
-        return desiredPreProcess_;
-    }
-    /// See how many passes wanted
-    inline int preProcessPasses() const {
-        return preProcessPasses_;
-    }
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp) ;
-
-protected:
-    // Data
-
-    // Whether to do cuts only at root (-1 -> switch off totally)
-    int cutsOnlyAtRoot_;
-
-    // How much strong branching to do
-    int numberStrong_;
-
-    // Number branches needed to trust with dynamic pseudo costs
-    int numberBeforeTrust_;
-
-    // Print level 0 little, 1 medium
-    int printLevel_;
-
-    /** Desired pre-processing
-        0 - none
-        1 - ordinary
-        2 - find sos
-        3 - find cliques
-        4 - more aggressive sos
-        5 - add integer slacks
-    */
-    int desiredPreProcess_;
-    /// Number of pre-processing passes
-    int preProcessPasses_;
-
-private:
-    /// Illegal Assignment operator
-    CbcStrategyDefault & operator=(const CbcStrategyDefault& rhs);
-};
-
-
-/** Default class for sub trees
- */
-
-class CbcStrategyDefaultSubTree : public CbcStrategy {
-public:
-
-    // Default Constructor
-    CbcStrategyDefaultSubTree (CbcModel * parent = NULL, int cutsOnlyAtRoot = 1,
-                               int numberStrong = 5,
-                               int numberBeforeTrust = 0,
-                               int printLevel = 0);
-
-    // Copy constructor
-    CbcStrategyDefaultSubTree ( const CbcStrategyDefaultSubTree &);
-
-    // Destructor
-    ~CbcStrategyDefaultSubTree ();
-
-    /// Clone
-    virtual CbcStrategy * clone() const;
-
-    /// Setup cut generators
-    virtual void setupCutGenerators(CbcModel & model);
-    /// Setup heuristics
-    virtual void setupHeuristics(CbcModel & model);
-    /// Do printing stuff
-    virtual void setupPrinting(CbcModel & model, int modelLogLevel) ;
-    /// Other stuff e.g. strong branching
-    virtual void setupOther(CbcModel & model);
-protected:
-    // Data
-    // Parent model
-    CbcModel * parentModel_;
-    // Whether to do cuts only at root (-1 -> switch off totally)
-    int cutsOnlyAtRoot_;
-
-    // How much strong branching to do
-    int numberStrong_;
-
-    // Number branches needed to trust with dynamic pseudo costs
-    int numberBeforeTrust_;
-
-    // Print level 0 little, 1 medium
-    int printLevel_;
-
-private:
-    /// Illegal Assignment operator
-    CbcStrategyDefaultSubTree & operator=(const CbcStrategyDefaultSubTree& rhs);
-};
-
-
-#endif
-

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

@@ -1,83 +0,0 @@
-// $Id: CbcSubProblem.hpp 1899 2013-04-09 18:12:08Z stefan $
-// 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).
-
-// Edwin 11/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcSubProblem_H
-#define CbcSubProblem_H
-
-#ifdef COIN_HAS_CLP
-#include "ClpSimplex.hpp"
-#include "ClpNode.hpp"
-
-/** Defines a general subproblem
-    Basis will be made more compact later
-*/
-class CoinWarmStartDiff;
-class CbcSubProblem {
-
-public:
-
-    /// Default constructor
-    CbcSubProblem ();
-
-    /// Constructor from model
-    CbcSubProblem (const OsiSolverInterface * solver,
-                   const double * lowerBefore,
-                   const double * upperBefore,
-                   const unsigned char * status,
-                   int depth);
-
-    /// Copy constructor
-    CbcSubProblem ( const CbcSubProblem &);
-
-    /// Assignment operator
-    CbcSubProblem & operator= (const CbcSubProblem& rhs);
-
-    /// Destructor
-    virtual ~CbcSubProblem ();
-
-    /// Take over
-  void takeOver ( CbcSubProblem &, bool cleanup);
-    /// Apply subproblem (1=bounds, 2=basis, 3=both)
-    void apply(OsiSolverInterface * model, int what = 3) const;
-
-public:
-    /// Value of objective
-    double objectiveValue_;
-    /// Sum of infeasibilities
-    double sumInfeasibilities_;
-    /// Branch value
-    double branchValue_;
-    /// Dj on branching variable at end
-    double djValue_;
-    /** Which variable (top bit if upper bound changing)
-        next bit if changing on down branch only */
-    int * variables_;
-    /// New bound
-    double * newBounds_;
-    /// Status
-    mutable CoinWarmStartBasis * status_;
-    /// Depth
-    int depth_;
-    /// Number of Extra bound changes
-    int numberChangedBounds_;
-    /// Number of infeasibilities
-    int numberInfeasibilities_;
-    /** Status 1 bit going up on first, 2 bit set first branch infeasible on second, 4 bit redundant branch,
-	bits after 256 give reason for stopping (just last node)
-	0 - solution
-	1 - infeasible
-	2 - maximum depth
-	>2 - error or max time or something
-    */
-    int problemStatus_;
-    /// Variable branched on
-    int branchVariable_;
-};
-
-#endif //COIN_HAS_CLP
-#endif
-

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

@@ -1,490 +0,0 @@
-/* $Id: CbcTree.hpp 1943 2013-07-21 09:05:45Z forrest $ */
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CbcTree_H
-#define CbcTree_H
-
-#include <vector>
-#include <algorithm>
-#include <cmath>
-
-#include "CoinHelperFunctions.hpp"
-#include "CbcCompare.hpp"
-
-/*! \brief Using MS heap implementation
-
-  It's unclear if this is needed any longer, or even if it should be allowed.
-  Cbc occasionally tries to do things to the tree (typically tweaking the
-  comparison predicate) that can cause a violation of the heap property (parent better
-  than either child). In a debug build, Microsoft's heap implementation does checks that
-  detect this and fail. This symbol switched to an alternate implementation of CbcTree,
-  and there are clearly differences, but no explanation as to why or what for.
-
-  As of 100921, the code is cleaned up to make it through `cbc -unitTest' without
-  triggering `Invalid heap' in an MSVS debug build. The method validateHeap() can
-  be used for debugging if this turns up again.
-*/
-//#define CBC_DUBIOUS_HEAP
-#if defined(_MSC_VER) || defined(__MNO_CYGWIN)
-//#define CBC_DUBIOUS_HEAP
-#endif
-#if 1 //ndef CBC_DUBIOUS_HEAP
-
-/*! \brief Controls search tree debugging
-
-  In order to have validateHeap() available, set CBC_DEBUG_HEAP
-  to 1 or higher.
-
-  - 1 calls validateHeap() after each change to the heap
-  - 2 will print a line for major operations (clean, set comparison, etc.)
-  - 3 will print information about each push and pop
-
-#define CBC_DEBUG_HEAP 1
-*/
-
-
-/*! \class CbcTree
-    \brief Implementation of the live set as a heap.
-
-    This class is used to hold the set of live nodes in the search tree.
-*/
-class CbcTree {
-
-public:
-    /*! \name Constructors and related */
-//@{
-    /// Default Constructor
-    CbcTree ();
-
-    /// Copy constructor
-    CbcTree (const CbcTree &rhs);
-
-    /// = operator
-    CbcTree & operator=(const CbcTree &rhs);
-
-    /// Destructor
-    virtual ~CbcTree();
-
-    /// Clone
-    virtual CbcTree * clone() const;
-
-    /// Create C++ lines to get to current state
-    virtual void generateCpp(FILE *) {}
-//@}
-
-    /*! \name Heap access and maintenance methods */
-//@{
-    /// Set comparison function and resort heap
-    void setComparison(CbcCompareBase &compare);
-
-    /// Return the top node of the heap
-    virtual CbcNode * top() const;
-
-    /// Add a node to the heap
-    virtual void push(CbcNode *x);
-
-    /// Remove the top node from the heap
-    virtual void pop() ;
-
-    /*! \brief Gets best node and takes off heap
-
-      Before returning the node from the top of the heap, the node
-      is offered an opportunity to reevaluate itself. Callers should
-      be prepared to check that the node returned is suitable for use.
-    */
-    virtual CbcNode * bestNode(double cutoff);
-
-    /*! \brief Rebuild the heap */
-    virtual void rebuild() ;
-//@}
-
-    /*! \name Direct node access methods */
-//@{
-    /// Test for an empty tree
-    virtual bool empty() ;
-
-    /// Return size
-    virtual int size() const { return static_cast<int>(nodes_.size()); }
-
-    /// Return a node pointer
-    inline CbcNode * operator [] (int i) const { return nodes_[i]; }
-
-    /// Return a node pointer
-    inline CbcNode * nodePointer (int i) const { return nodes_[i]; }
-    void realpop();
-    /** After changing data in the top node, fix the heap */
-    void fixTop();
-    void realpush(CbcNode * node);
-//@}
-
-    /*! \name Search tree maintenance */
-//@{
-    /*! \brief Prune the tree using an objective function cutoff
-
-      This routine removes all nodes with objective worse than the
-      specified cutoff value. It also sets bestPossibleObjective to
-      the best objective over remaining nodes.
-    */
-    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
-
-    /// Get best on list using alternate method
-    CbcNode * bestAlternate();
-
-    /// We may have got an intelligent tree so give it one more chance
-    virtual void endSearch() {}
-
-    /// Get best possible objective function in the tree
-    virtual double getBestPossibleObjective();
-
-    /// Reset maximum node number
-    inline void resetNodeNumbers() { maximumNodeNumber_ = 0; }
-
-    /// Get maximum node number
-    inline int maximumNodeNumber() const { return maximumNodeNumber_; }
-
-    /// Set number of branches
-    inline void setNumberBranching(int value) { numberBranching_ = value; }
-
-    /// Get number of branches
-    inline int getNumberBranching() const { return numberBranching_; }
-
-    /// Set maximum branches
-    inline void setMaximumBranching(int value) { maximumBranching_ = value; }
-
-    /// Get maximum branches
-    inline int getMaximumBranching() const { return maximumBranching_; }
-
-    /// Get branched variables
-    inline unsigned int * branched() const { return branched_; }
-
-    /// Get bounds
-    inline int * newBounds() const { return newBound_; }
-
-    /// Last objective in branch-and-cut search tree
-    inline double lastObjective() const {
-        return lastObjective_;
-    }
-    /// Last depth in branch-and-cut search tree
-    inline int lastDepth() const {
-        return lastDepth_;
-    }
-    /// Last number of objects unsatisfied
-    inline int lastUnsatisfied() const {
-        return lastUnsatisfied_;
-    }
-    /// Adds branching information to complete state
-    void addBranchingInformation(const CbcModel * model, const CbcNodeInfo * nodeInfo,
-                                 const double * currentLower,
-                                 const double * currentUpper);
-    /// Increase space for data
-    void increaseSpace();
-//@}
-
-# if CBC_DEBUG_HEAP > 0
-  /*! \name Debugging methods */
-  //@{
-    /*! \brief Check that the heap property is satisfied. */
-    void validateHeap() ;
-  //@}
-# endif
-
-protected:
-    /// Storage vector for the heap
-    std::vector <CbcNode *> nodes_;
-    /// Sort predicate for heap ordering.
-    CbcCompare comparison_;
-    /// Maximum "node" number so far to split ties
-    int maximumNodeNumber_;
-    /// Size of variable list
-    int numberBranching_;
-    /// Maximum size of variable list
-    int maximumBranching_;
-    /// Objective of last node pushed on tree
-    double lastObjective_;
-    /// Depth of last node pushed on tree
-    int lastDepth_;
-    /// Number unsatisfied of last node pushed on tree
-    int lastUnsatisfied_;
-    /** Integer variables branched or bounded
-        top bit set if new upper bound
-        next bit set if a branch
-    */
-    unsigned int * branched_;
-    /// New bound
-    int * newBound_;
-};
-
-#ifdef JJF_ZERO // not used
-/*! \brief Implementation of live set as a managed array.
-
-    This class is used to hold the set of live nodes in the search tree.
-*/
-class CbcTreeArray : public CbcTree {
-
-public:
-
-    // Default Constructor
-    CbcTreeArray ();
-
-    // Copy constructor
-    CbcTreeArray ( const CbcTreeArray & rhs);
-    // = operator
-    CbcTreeArray & operator=(const CbcTreeArray & rhs);
-
-    virtual ~CbcTreeArray();
-
-    /// Clone
-    virtual CbcTree * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * ) {}
-
-    /*! \name Heap access and maintenance methods */
-//@{
-
-    /// Set comparison function and resort heap
-    void setComparison(CbcCompareBase  &compare);
-
-    /// Add a node to the heap
-    virtual void push(CbcNode * x);
-
-    /// Gets best node and takes off heap
-    virtual CbcNode * bestNode(double cutoff);
-
-//@}
-    /*! \name vector methods */
-//@{
-
-    /// Test if empty *** note may be overridden
-    virtual bool empty() ;
-
-//@}
-
-    /*! \name Search tree maintenance */
-//@{
-
-    /*! \brief Prune the tree using an objective function cutoff
-
-      This routine removes all nodes with objective worst than the
-      specified cutoff value.
-      It also sets bestPossibleObjective to best
-      of all on tree before deleting.
-    */
-
-    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
-    /// Get best possible objective function in the tree
-    virtual double getBestPossibleObjective();
-//@}
-protected:
-    /// Returns
-    /// Last node
-    CbcNode * lastNode_;
-    /// Last node popped
-    CbcNode * lastNodePopped_;
-    /// Not used yet
-    int switches_;
-
-};
-
-/// New style
-#include "CoinSearchTree.hpp"
-/*! \class tree
-    \brief Implementation of live set as a heap.
-
-    This class is used to hold the set of live nodes in the search tree.
-*/
-
-class CbcNewTree : public CbcTree, public CoinSearchTreeManager {
-
-public:
-
-    // Default Constructor
-    CbcNewTree ();
-
-    // Copy constructor
-    CbcNewTree ( const CbcNewTree & rhs);
-    // = operator
-    CbcNewTree & operator=(const CbcNewTree & rhs);
-
-    virtual ~CbcNewTree();
-
-    /// Clone
-    virtual CbcNewTree * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * ) {}
-
-    /*! \name Heap access and maintenance methods */
-//@{
-
-    /// Set comparison function and resort heap
-    void setComparison(CbcCompareBase  &compare);
-
-    /// Return the top node of the heap
-    virtual CbcNode * top() const;
-
-    /// Add a node to the heap
-    virtual void push(CbcNode * x);
-
-    /// Remove the top node from the heap
-    virtual void pop() ;
-    /// Gets best node and takes off heap
-    virtual CbcNode * bestNode(double cutoff);
-
-//@}
-    /*! \name vector methods */
-//@{
-
-    /// Test if empty *** note may be overridden
-    virtual bool empty() ;
-
-    /// Return size
-    inline int size() const {
-        return nodes_.size();
-    }
-
-    /// [] operator
-    inline CbcNode * operator [] (int i) const {
-        return nodes_[i];
-    }
-
-    /// Return a node pointer
-    inline CbcNode * nodePointer (int i) const {
-        return nodes_[i];
-    }
-
-//@}
-
-    /*! \name Search tree maintenance */
-//@{
-
-    /*! \brief Prune the tree using an objective function cutoff
-
-      This routine removes all nodes with objective worst than the
-      specified cutoff value.
-      It also sets bestPossibleObjective to best
-      of all on tree before deleting.
-    */
-
-    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
-
-    /// Get best on list using alternate method
-    CbcNode * bestAlternate();
-
-    /// We may have got an intelligent tree so give it one more chance
-    virtual void endSearch() {}
-//@}
-protected:
-
-
-};
-#endif
-#else
-/* CBC_DUBIOUS_HEAP is defined
-
-  See note at top of file. This code is highly suspect.
-  -- lh, 100921 --
-*/
-class CbcTree {
-
-public:
-
-    // Default Constructor
-    CbcTree ();
-
-    // Copy constructor
-    CbcTree ( const CbcTree & rhs);
-    // = operator
-    CbcTree & operator=(const CbcTree & rhs);
-
-    virtual ~CbcTree();
-
-    /// Clone
-    virtual CbcTree * clone() const;
-    /// Create C++ lines to get to current state
-    virtual void generateCpp( FILE * fp) {}
-
-    /*! \name Heap access and maintenance methods */
-//@{
-
-    /// Set comparison function and resort heap
-    void setComparison(CbcCompareBase  &compare);
-
-    /// Return the top node of the heap
-    virtual CbcNode * top() const;
-
-    /// Add a node to the heap
-    virtual void push(CbcNode * x);
-
-    /// Remove the top node from the heap
-    virtual void pop() ;
-    /// Gets best node and takes off heap
-    virtual CbcNode * bestNode(double cutoff);
-
-//@}
-    /*! \name vector methods */
-//@{
-
-    /// Test if empty *** note may be overridden
-    //virtual bool empty() ;
-
-    /// Return size
-    inline int size() const {
-        return nodes_.size();
-    }
-
-    /// [] operator
-    inline CbcNode * operator [] (int i) const {
-        return nodes_[i];
-    }
-
-    /// Return a node pointer
-    inline CbcNode * nodePointer (int i) const {
-        return nodes_[i];
-    }
-
-    virtual bool empty();
-    //inline int size() const { return size_; }
-    void realpop();
-    /** After changing data in the top node, fix the heap */
-    void fixTop();
-    void realpush(CbcNode * node);
-//@}
-
-    /*! \name Search tree maintenance */
-//@{
-
-    /*! \brief Prune the tree using an objective function cutoff
-
-      This routine removes all nodes with objective worst than the
-      specified cutoff value.
-      It also sets bestPossibleObjective to best
-      of all on tree before deleting.
-    */
-
-    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
-
-    /// Get best on list using alternate method
-    CbcNode * bestAlternate();
-
-    /// We may have got an intelligent tree so give it one more chance
-    virtual void endSearch() {}
-    /// Reset maximum node number
-    inline void resetNodeNumbers() {
-        maximumNodeNumber_ = 0;
-    }
-
-    /// Get maximum node number
-    inline int maximumNodeNumber() const { return maximumNodeNumber_; }
-//@}
-protected:
-    std::vector <CbcNode *> nodes_;
-    CbcCompare comparison_;	///> Sort function for heap ordering.
-    /// Maximum "node" number so far to split ties
-    int maximumNodeNumber_;
-
-
-};
-#endif
-#endif
-