ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,94 +0,0 @@
-/* $Id: CbcMessage.hpp 1791 2012-06-08 15:15:10Z 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).
-
-#ifndef CbcMessage_H
-#define CbcMessage_H
-
-#if defined(_MSC_VER)
-// Turn off compiler warning about long names
-#  pragma warning(disable:4786)
-#endif
-
-/** This deals with Cbc messages (as against Clp messages etc).
-    CoinMessageHandler.hpp is the general part of message handling.
-    All it has are enum's for the various messages.
-    CbcMessage.cpp has text in various languages.
-
-    It is trivial to use the .hpp and .cpp file as a basis for
-    messages for other components.
- */
-
-#include "CoinMessageHandler.hpp"
-enum CBC_Message {
-    CBC_END_GOOD,
-    CBC_MAXNODES,
-    CBC_MAXTIME,
-    CBC_MAXSOLS,
-    CBC_EVENT,
-    CBC_MAXITERS,
-    CBC_SOLUTION,
-    CBC_END_SOLUTION,
-    CBC_SOLUTION2,
-    CBC_END,
-    CBC_INFEAS,
-    CBC_STRONG,
-    CBC_SOLINDIVIDUAL,
-    CBC_INTEGERINCREMENT,
-    CBC_STATUS,
-    CBC_GAP,
-    CBC_ROUNDING,
-    CBC_TREE_SOL,
-    CBC_ROOT,
-    CBC_GENERATOR,
-    CBC_BRANCH,
-    CBC_STRONGSOL,
-    CBC_NOINT,
-    CBC_VUB_PASS,
-    CBC_VUB_END,
-    CBC_NOTFEAS1,
-    CBC_NOTFEAS2,
-    CBC_NOTFEAS3,
-    CBC_CUTOFF_WARNING1,
-    CBC_ITERATE_STRONG,
-    CBC_PRIORITY,
-    CBC_WARNING_STRONG,
-    CBC_START_SUB,
-    CBC_END_SUB,
-    CBC_THREAD_STATS,
-    CBC_CUTS_STATS,
-    CBC_STRONG_STATS,
-    CBC_UNBOUNDED,
-    CBC_OTHER_STATS,
-    CBC_HEURISTICS_OFF,
-    CBC_STATUS2,
-    CBC_FPUMP1,
-    CBC_FPUMP2,
-    CBC_STATUS3,
-    CBC_OTHER_STATS2,
-    CBC_RELAXED1,
-    CBC_RELAXED2,
-    CBC_RESTART,
-    CBC_GENERAL,
-    CBC_ROOT_DETAIL,
-#ifndef NO_FATHOM_PRINT
-    CBC_FATHOM_CHANGE,
-#endif
-    CBC_DUMMY_END
-};
-
-class CbcMessage : public CoinMessages {
-
-public:
-
-    /**@name Constructors etc */
-    //@{
-    /** Constructor */
-    CbcMessage(Language language = us_en);
-    //@}
-
-};
-
-#endif
-

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

@@ -1,26 +0,0 @@
-#ifndef MIPSTARTIO_HPP_INCLUDED
-#define MIPSTARTIO_HPP_INCLUDED
-
-#include <vector>
-#include <string>
-#include <utility>
-class CbcModel;
-
-class OsiSolverInterface;
-
-/* tries to read mipstart (solution file) from
-   fileName, filling colValues and obj
-   returns 0 with success,
-   1 otherwise */
-int readMIPStart( CbcModel * model, const char *fileName,
-                  std::vector< std::pair< std::string, double > > &colValues,
-                  double &solObj );
-
-/* from a partial list of variables tries to fill the
-   remaining variable values */
-int computeCompleteSolution( CbcModel * model, 
-                             const std::vector< std::string > colNames,
-                             const std::vector< std::pair< std::string, double > > &colValues,
-                             double *sol, double &obj );
-
-#endif // MIPSTARTIO_HPP_INCLUDED

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

@@ -1,2952 +0,0 @@
-/* $Id: CbcModel.hpp 2206 2015-07-07 20:44:40Z 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).
-
-#ifndef CbcModel_H
-#define CbcModel_H
-#include <string>
-#include <vector>
-#include "CoinMessageHandler.hpp"
-#include "OsiSolverInterface.hpp"
-#include "OsiBranchingObject.hpp"
-#include "OsiCuts.hpp"
-#include "CoinWarmStartBasis.hpp"
-#include "CbcCompareBase.hpp"
-#include "CbcCountRowCut.hpp"
-#include "CbcMessage.hpp"
-#include "CbcEventHandler.hpp"
-#include "ClpDualRowPivot.hpp"
-
-
-class CbcCutGenerator;
-class CbcBaseModel;
-class OsiRowCut;
-class OsiBabSolver;
-class OsiRowCutDebugger;
-class CglCutGenerator;
-class CglStored;
-class CbcCutModifier;
-class CglTreeProbingInfo;
-class CbcHeuristic;
-class OsiObject;
-class CbcThread;
-class CbcTree;
-class CbcStrategy;
-class CbcSymmetry;
-class CbcFeasibilityBase;
-class CbcStatistics;
-class CbcFullNodeInfo;
-class CbcEventHandler ;
-class CglPreProcess;
-class OsiClpSolverInterface;
-class ClpNodeStuff;
-
-// #define CBC_CHECK_BASIS 1
-
-//#############################################################################
-
-/** Simple Branch and bound class
-
-  The initialSolve() method solves the initial LP relaxation of the MIP
-  problem. The branchAndBound() method can then be called to finish using
-  a branch and cut algorithm.
-
-  <h3>Search Tree Traversal</h3>
-
-  Subproblems (aka nodes) requiring additional evaluation are stored using
-  the CbcNode and CbcNodeInfo objects. Ancestry linkage is maintained in the
-  CbcNodeInfo object. Evaluation of a subproblem within branchAndBound()
-  proceeds as follows:
-  <ul>
-    <li> The node representing the most promising parent subproblem is popped
-	 from the heap which holds the set of subproblems requiring further
-	 evaluation.
-    <li> Using branching instructions stored in the node, and information in
-	 its ancestors, the model and solver are adjusted to create the
-	 active subproblem.
-    <li> If the parent subproblem will require further evaluation
-	 (<i>i.e.</i>, there are branches remaining) its node is pushed back
-	 on the heap. Otherwise, the node is deleted.  This may trigger
-	 recursive deletion of ancestors.
-    <li> The newly created subproblem is evaluated.
-    <li> If the subproblem requires further evaluation, a node is created.
-	 All information needed to recreate the subproblem (branching
-	 information, row and column cuts) is placed in the node and the node
-	 is added to the set of subproblems awaiting further evaluation.
-  </ul>
-  Note that there is never a node representing the active subproblem; the model
-  and solver represent the active subproblem.
-
-  <h3>Row (Constraint) Cut Handling</h3>
-
-  For a typical subproblem, the sequence of events is as follows:
-  <ul>
-    <li> The subproblem is rebuilt for further evaluation: One result of a
-	 call to addCuts() is a traversal of ancestors, leaving a list of all
-	 cuts used in the ancestors in #addedCuts_. This list is then scanned
-	 to construct a basis that includes only tight cuts. Entries for
-	 loose cuts are set to NULL.
-    <li> The subproblem is evaluated: One result of a call to solveWithCuts()
-         is the return of a set of newly generated cuts for the subproblem.
-	 #addedCuts_ is also kept up-to-date as old cuts become loose.
-    <li> The subproblem is stored for further processing: A call to
-	 CbcNodeInfo::addCuts() adds the newly generated cuts to the
-	 CbcNodeInfo object associated with this node.
-  </ul>
-  See CbcCountRowCut for details of the bookkeeping associated with cut
-  management.
-*/
-
-class CbcModel  {
-
-public:
-
-    enum CbcIntParam {
-        /** The maximum number of nodes before terminating */
-        CbcMaxNumNode = 0,
-        /** The maximum number of solutions before terminating */
-        CbcMaxNumSol,
-        /** Fathoming discipline
-
-          Controls objective function comparisons for purposes of fathoming by bound
-          or determining monotonic variables.
-
-          If 1, action is taken only when the current objective is strictly worse
-          than the target. Implementation is handled by adding a small tolerance to
-          the target.
-        */
-        CbcFathomDiscipline,
-        /** Adjusts printout
-            1 does different node message with number unsatisfied on last branch
-        */
-        CbcPrinting,
-        /** Number of branches (may be more than number of nodes as may
-            include strong branching) */
-        CbcNumberBranches,
-        /** Just a marker, so that a static sized array can store parameters. */
-        CbcLastIntParam
-    };
-
-    enum CbcDblParam {
-        /** The maximum amount the value of an integer variable can vary from
-            integer and still be considered feasible. */
-        CbcIntegerTolerance = 0,
-        /** The objective is assumed to worsen by this amount for each
-            integer infeasibility. */
-        CbcInfeasibilityWeight,
-        /** The amount by which to tighten the objective function cutoff when
-            a new solution is discovered. */
-        CbcCutoffIncrement,
-        /** Stop when the gap between the objective value of the best known solution
-          and the best bound on the objective of any solution is less than this.
-
-          This is an absolute value. Conversion from a percentage is left to the
-          client.
-        */
-        CbcAllowableGap,
-        /** Stop when the gap between the objective value of the best known solution
-          and the best bound on the objective of any solution is less than this
-          fraction of of the absolute value of best known solution.
-
-          Code stops if either this test or CbcAllowableGap test succeeds
-        */
-        CbcAllowableFractionGap,
-        /** \brief The maximum number of seconds before terminating.
-               A double should be adequate! */
-        CbcMaximumSeconds,
-        /// Cutoff - stored for speed
-        CbcCurrentCutoff,
-        /// Optimization direction - stored for speed
-        CbcOptimizationDirection,
-        /// Current objective value
-        CbcCurrentObjectiveValue,
-        /// Current minimization objective value
-        CbcCurrentMinimizationObjectiveValue,
-        /** \brief The time at start of model.
-               So that other pieces of code can access */
-        CbcStartSeconds,
-        /** Stop doing heuristics when the gap between the objective value of the
-            best known solution and the best bound on the objective of any solution
-            is less than this.
-
-          This is an absolute value. Conversion from a percentage is left to the
-          client.
-        */
-        CbcHeuristicGap,
-        /** Stop doing heuristics when the gap between the objective value of the
-            best known solution and the best bound on the objective of any solution
-            is less than this fraction of of the absolute value of best known
-            solution.
-
-          Code stops if either this test or CbcAllowableGap test succeeds
-        */
-        CbcHeuristicFractionGap,
-        /// Smallest non-zero change on a branch
-        CbcSmallestChange,
-        /// Sum of non-zero changes on a branch
-        CbcSumChange,
-        /// Largest non-zero change on a branch
-        CbcLargestChange,
-        /// Small non-zero change on a branch to be used as guess
-        CbcSmallChange,
-        /** Just a marker, so that a static sized array can store parameters. */
-        CbcLastDblParam
-    };
-
-    //---------------------------------------------------------------------------
-
-public:
-    ///@name Solve methods
-    //@{
-    /** \brief Solve the initial LP relaxation
-
-      Invoke the solver's %initialSolve() method.
-    */
-    void initialSolve();
-
-    /** \brief Invoke the branch \& cut algorithm
-
-      The method assumes that initialSolve() has been called to solve the
-      LP relaxation. It processes the root node, then proceeds to explore the
-      branch & cut search tree. The search ends when the tree is exhausted or
-      one of several execution limits is reached.
-      If doStatistics is 1 summary statistics are printed
-      if 2 then also the path to best solution (if found by branching)
-      if 3 then also one line per node
-    */
-    void branchAndBound(int doStatistics = 0);
-private:
-
-    /** \brief Evaluate a subproblem using cutting planes and heuristics
-
-      The method invokes a main loop which generates cuts, applies heuristics,
-      and reoptimises using the solver's native %resolve() method.
-      It returns true if the subproblem remains feasible at the end of the
-      evaluation.
-    */
-    bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
-    /** Generate one round of cuts - serial mode
-      returns -
-      0 - normal
-      1 - must keep going
-      2 - set numberTries to zero
-      -1 - infeasible
-    */
-    int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
-    /** Generate one round of cuts - parallel mode
-        returns -
-        0 - normal
-        1 - must keep going
-        2 - set numberTries to zero
-        -1 - infeasible
-    */
-    int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
-    /** Input one node output N nodes to put on tree and optional solution update
-        This should be able to operate in parallel so is given a solver and is const(ish)
-        However we will need to keep an array of solver_ and bases and more
-        status is 0 for normal, 1 if solution
-        Calling code should always push nodes back on tree
-    */
-    CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
-                            int & numberNodesOutput, int & status) ;
-    /// Update size of whichGenerator
-    void resizeWhichGenerator(int numberNow, int numberAfter);
-public:
-#ifdef CBC_KEEP_DEPRECATED
-    // See if anyone is using these any more!!
-    /** \brief create a clean model from partially fixed problem
-
-      The method creates a new model with given bounds and with no tree.
-    */
-    CbcModel *  cleanModel(const double * lower, const double * upper);
-    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
-
-      The method presolves the given model and does branch and cut. The search
-      ends when the tree is exhausted or maximum nodes is reached.
-
-      If better solution found then it is saved.
-
-      Returns 0 if search completed and solution, 1 if not completed and solution,
-      2 if completed and no solution, 3 if not completed and no solution.
-
-      Normally okay to do cleanModel immediately followed by subBranchandBound
-      (== other form of subBranchAndBound)
-      but may need to get at model for advanced features.
-
-      Deletes model2
-    */
-    int subBranchAndBound(CbcModel * model2,
-                          CbcModel * presolvedModel,
-                          int maximumNodes);
-    /** \brief Invoke the branch \& cut algorithm on partially fixed problem
-
-      The method creates a new model with given bounds, presolves it
-      then proceeds to explore the branch & cut search tree. The search
-      ends when the tree is exhausted or maximum nodes is reached.
-
-      If better solution found then it is saved.
-
-      Returns 0 if search completed and solution, 1 if not completed and solution,
-      2 if completed and no solution, 3 if not completed and no solution.
-
-      This is just subModel immediately followed by other version of
-      subBranchandBound.
-
-    */
-    int subBranchAndBound(const double * lower, const double * upper,
-                          int maximumNodes);
-
-    /** \brief Process root node and return a strengthened model
-
-      The method assumes that initialSolve() has been called to solve the
-      LP relaxation. It processes the root node and then returns a pointer
-      to the strengthened model (or NULL if infeasible)
-    */
-    OsiSolverInterface *  strengthenedModel();
-    /** preProcess problem - replacing solver
-        If makeEquality true then <= cliques converted to ==.
-        Presolve will be done numberPasses times.
-
-        Returns NULL if infeasible
-
-        If makeEquality is 1 add slacks to get cliques,
-        if 2 add slacks to get sos (but only if looks plausible) and keep sos info
-    */
-    CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5,
-                                int tuning = 5);
-    /** Does postprocessing - original solver back.
-        User has to delete process */
-    void postProcess(CglPreProcess * process);
-#endif
-    /// Adds an update information object
-    void addUpdateInformation(const CbcObjectUpdateData & data);
-    /** Do one node - broken out for clarity?
-        also for parallel (when baseModel!=this)
-        Returns 1 if solution found
-        node NULL on return if no branches left
-        newNode NULL if no new node created
-    */
-    int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);
-
-public:
-    /** \brief Reoptimise an LP relaxation
-
-      Invoke the solver's %resolve() method.
-      whereFrom -
-      0 - initial continuous
-      1 - resolve on branch (before new cuts)
-      2 - after new cuts
-      3  - obsolete code or something modified problem in unexpected way
-      10 - after strong branching has fixed variables at root
-      11 - after strong branching has fixed variables in tree
-
-      returns 1 feasible, 0 infeasible, -1 feasible but skip cuts
-    */
-    int resolve(CbcNodeInfo * parent, int whereFrom,
-                double * saveSolution = NULL,
-                double * saveLower = NULL,
-                double * saveUpper = NULL);
-    /// Make given rows (L or G) into global cuts and remove from lp
-    void makeGlobalCuts(int numberRows, const int * which);
-    /// Make given cut into a global cut
-    int makeGlobalCut(const OsiRowCut * cut);
-    /// Make given cut into a global cut
-    int makeGlobalCut(const OsiRowCut & cut);
-    /// Make given column cut into a global cut
-    void makeGlobalCut(const OsiColCut * cut);
-    /// Make given column cut into a global cut
-    void makeGlobalCut(const OsiColCut & cut);
-    /// Make partial cut into a global cut and save
-  void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL);
-    /// Make partial cuts into global cuts
-    void makeGlobalCuts();
-    /// Which cut generator generated this cut
-    inline const int * whichGenerator() const
-    { return whichGenerator_;}
-    //@}
-
-    /** \name Presolve methods */
-    //@{
-
-    /** Identify cliques and construct corresponding objects.
-
-        Find cliques with size in the range
-        [\p atLeastThisMany, \p lessThanThis] and construct corresponding
-        CbcClique objects.
-        If \p makeEquality is true then a new model may be returned if
-        modifications had to be made, otherwise \c this is returned.
-        If the problem is infeasible #numberObjects_ is set to -1.
-        A client must use deleteObjects() before a second call to findCliques().
-        If priorities exist, clique priority is set to the default.
-    */
-    CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
-                           int lessThanThis, int defaultValue = 1000);
-
-    /** Do integer presolve, creating a new (presolved) model.
-
-      Returns the new model, or NULL if feasibility is lost.
-      If weak is true then just does a normal presolve
-
-      \todo It remains to work out the cleanest way of getting a solution to
-            the original problem at the end. So this is very preliminary.
-     */
-    CbcModel * integerPresolve(bool weak = false);
-
-    /** Do integer presolve, modifying the current model.
-
-        Returns true if the model remains feasible after presolve.
-    */
-    bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false);
-
-
-    /// Put back information into the original model after integer presolve.
-    void originalModel(CbcModel * presolvedModel, bool weak);
-
-    /** \brief For variables involved in VUB constraints, see if we can tighten
-           bounds by solving lp's
-
-        Returns false if feasibility is lost.
-        If CglProbing is available, it will be tried as well to see if it can
-        tighten bounds.
-        This routine is just a front end for tightenVubs(int,const int*,double).
-
-        If <tt>type = -1</tt> all variables are processed (could be very slow).
-        If <tt>type = 0</tt> only variables involved in VUBs are processed.
-        If <tt>type = n > 0</tt>, only the n most expensive VUB variables
-        are processed, where it is assumed that x is at its maximum so delta
-        would have to go to 1 (if x not at bound).
-
-        If \p allowMultipleBinary is true, then a VUB constraint is a row with
-        one continuous variable and any number of binary variables.
-
-        If <tt>useCutoff < 1.0e30</tt>, the original objective is installed as a
-        constraint with \p useCutoff as a bound.
-    */
-    bool tightenVubs(int type, bool allowMultipleBinary = false,
-                     double useCutoff = 1.0e50);
-
-    /** \brief For variables involved in VUB constraints, see if we can tighten
-           bounds by solving lp's
-
-      This version is just handed a list of variables to be processed.
-    */
-    bool tightenVubs(int numberVubs, const int * which,
-                     double useCutoff = 1.0e50);
-    /**
-      Analyze problem to find a minimum change in the objective function.
-    */
-    void analyzeObjective();
-
-    /**
-      Add additional integers.
-    */
-    void AddIntegers();
-    /**
-      Save copy of the model.
-    */
-    void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);
-    /**
-      Flip direction of optimization on all models
-    */
-    void flipModel();
-
-    //@}
-
-    /** \name Object manipulation routines
-
-      See OsiObject for an explanation of `object' in the context of CbcModel.
-    */
-    //@{
-
-    /// Get the number of objects
-    inline int numberObjects() const {
-        return numberObjects_;
-    }
-    /// Set the number of objects
-    inline void setNumberObjects(int number) {
-        numberObjects_ = number;
-    }
-
-    /// Get the array of objects
-    inline OsiObject ** objects() const {
-        return object_;
-    }
-
-    /// Get the specified object
-    const inline OsiObject * object(int which) const {
-        return object_[which];
-    }
-    /// Get the specified object
-    inline OsiObject * modifiableObject(int which) const {
-        return object_[which];
-    }
-
-    void setOptionalInteger(int index);
-
-    /// Delete all object information (and just back to integers if true)
-    void deleteObjects(bool findIntegers = true);
-
-    /** Add in object information.
-
-      Objects are cloned; the owner can delete the originals.
-    */
-    void addObjects(int numberObjects, OsiObject ** objects);
-
-    /** Add in object information.
-
-      Objects are cloned; the owner can delete the originals.
-    */
-    void addObjects(int numberObjects, CbcObject ** objects);
-
-    /// Ensure attached objects point to this model.
-    void synchronizeModel() ;
-
-    /** \brief Identify integer variables and create corresponding objects.
-
-      Record integer variables and create an CbcSimpleInteger object for each
-      one.
-      If \p startAgain is true, a new scan is forced, overwriting any existing
-      integer variable information.
-      If type > 0 then 1==PseudoCost, 2 new ones low priority
-    */
-
-    void findIntegers(bool startAgain, int type = 0);
-
-#ifdef SWITCH_VARIABLES
-    /// Convert Dynamic to Switching 
-    int findSwitching();
-    /// Fix associated variables
-    int fixAssociated(OsiSolverInterface * solver,int cleanBasis);
-    /// Debug associated variables
-    int checkAssociated(const OsiSolverInterface * solver,
-			const double * solution, int printLevel);
-#endif
-    //@}
-
-    //---------------------------------------------------------------------------
-
-    /**@name Parameter set/get methods
-
-       The set methods return true if the parameter was set to the given value,
-       false if the value of the parameter is out of range.
-
-       The get methods return the value of the parameter.
-
-    */
-    //@{
-    /// Set an integer parameter
-    inline bool setIntParam(CbcIntParam key, int value) {
-        intParam_[key] = value;
-        return true;
-    }
-    /// Set a double parameter
-    inline bool setDblParam(CbcDblParam key, double value) {
-        dblParam_[key] = value;
-        return true;
-    }
-    /// Get an integer parameter
-    inline int getIntParam(CbcIntParam key) const {
-        return intParam_[key];
-    }
-    /// Get a double parameter
-    inline double getDblParam(CbcDblParam key) const {
-        return dblParam_[key];
-    }
-    /*! \brief Set cutoff bound on the objective function.
-
-      When using strict comparison, the bound is adjusted by a tolerance to
-      avoid accidentally cutting off the optimal solution.
-    */
-    void setCutoff(double value) ;
-
-    /// Get the cutoff bound on the objective function - always as minimize
-    inline double getCutoff() const { //double value ;
-        //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
-        //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
-        return dblParam_[CbcCurrentCutoff];
-    }
-
-    /// Set the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
-    inline bool setMaximumNodes( int value) {
-        return setIntParam(CbcMaxNumNode, value);
-    }
-
-    /// Get the \link CbcModel::CbcMaxNumNode maximum node limit \endlink
-    inline int getMaximumNodes() const {
-        return getIntParam(CbcMaxNumNode);
-    }
-
-    /** Set the
-        \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
-        desired.
-    */
-    inline bool setMaximumSolutions( int value) {
-        return setIntParam(CbcMaxNumSol, value);
-    }
-    /** Get the
-        \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink
-        desired.
-    */
-    inline int getMaximumSolutions() const {
-        return getIntParam(CbcMaxNumSol);
-    }
-    /// Set the printing mode
-    inline bool setPrintingMode( int value) {
-        return setIntParam(CbcPrinting, value);
-    }
-
-    /// Get the printing mode
-    inline int getPrintingMode() const {
-        return getIntParam(CbcPrinting);
-    }
-
-    /** Set the
-        \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
-        desired.
-    */
-    inline bool setMaximumSeconds( double value) {
-        return setDblParam(CbcMaximumSeconds, value);
-    }
-    /** Get the
-        \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink
-        desired.
-    */
-    inline double getMaximumSeconds() const {
-        return getDblParam(CbcMaximumSeconds);
-    }
-    /// Current time since start of branchAndbound
-    double getCurrentSeconds() const ;
-
-    /// Return true if maximum time reached
-    bool maximumSecondsReached() const ;
-
-    /** Set the
-      \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
-    */
-    inline bool setIntegerTolerance( double value) {
-        return setDblParam(CbcIntegerTolerance, value);
-    }
-    /** Get the
-      \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink
-    */
-    inline double getIntegerTolerance() const {
-        return getDblParam(CbcIntegerTolerance);
-    }
-
-    /** Set the
-        \link CbcModel::CbcInfeasibilityWeight
-          weight per integer infeasibility \endlink
-    */
-    inline bool setInfeasibilityWeight( double value) {
-        return setDblParam(CbcInfeasibilityWeight, value);
-    }
-    /** Get the
-        \link CbcModel::CbcInfeasibilityWeight
-          weight per integer infeasibility \endlink
-    */
-    inline double getInfeasibilityWeight() const {
-        return getDblParam(CbcInfeasibilityWeight);
-    }
-
-    /** Set the \link CbcModel::CbcAllowableGap allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline bool setAllowableGap( double value) {
-        return setDblParam(CbcAllowableGap, value);
-    }
-    /** Get the \link CbcModel::CbcAllowableGap allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline double getAllowableGap() const {
-        return getDblParam(CbcAllowableGap);
-    }
-
-    /** Set the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline bool setAllowableFractionGap( double value) {
-        return setDblParam(CbcAllowableFractionGap, value);
-    }
-    /** Get the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline double getAllowableFractionGap() const {
-        return getDblParam(CbcAllowableFractionGap);
-    }
-    /** Set the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline bool setAllowablePercentageGap( double value) {
-        return setDblParam(CbcAllowableFractionGap, value*0.01);
-    }
-    /** Get the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline double getAllowablePercentageGap() const {
-        return 100.0*getDblParam(CbcAllowableFractionGap);
-    }
-    /** Set the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline bool setHeuristicGap( double value) {
-        return setDblParam(CbcHeuristicGap, value);
-    }
-    /** Get the \link CbcModel::CbcHeuristicGap heuristic gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline double getHeuristicGap() const {
-        return getDblParam(CbcHeuristicGap);
-    }
-
-    /** Set the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline bool setHeuristicFractionGap( double value) {
-        return setDblParam(CbcHeuristicFractionGap, value);
-    }
-    /** Get the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink
-        between the best known solution and the best possible solution.
-    */
-    inline double getHeuristicFractionGap() const {
-        return getDblParam(CbcHeuristicFractionGap);
-    }
-    /** Set the
-        \link CbcModel::CbcCutoffIncrement  \endlink
-        desired.
-    */
-    inline bool setCutoffIncrement( double value) {
-        return setDblParam(CbcCutoffIncrement, value);
-    }
-    /** Get the
-        \link CbcModel::CbcCutoffIncrement  \endlink
-        desired.
-    */
-    inline double getCutoffIncrement() const {
-        return getDblParam(CbcCutoffIncrement);
-    }
-    /// See if can stop on gap
-    bool canStopOnGap() const;
-
-    /** Pass in target solution and optional priorities.
-        If priorities then >0 means only branch if incorrect
-        while <0 means branch even if correct. +1 or -1 are
-        highest priority */
-    void setHotstartSolution(const double * solution, const int * priorities = NULL) ;
-
-    /// Set the minimum drop to continue cuts
-    inline void setMinimumDrop(double value) {
-        minimumDrop_ = value;
-    }
-    /// Get the minimum drop to continue cuts
-    inline double getMinimumDrop() const {
-        return minimumDrop_;
-    }
-
-    /** Set the maximum number of cut passes at root node (default 20)
-        Minimum drop can also be used for fine tuning */
-    inline void setMaximumCutPassesAtRoot(int value) {
-        maximumCutPassesAtRoot_ = value;
-    }
-    /** Get the maximum number of cut passes at root node */
-    inline int getMaximumCutPassesAtRoot() const {
-        return maximumCutPassesAtRoot_;
-    }
-
-    /** Set the maximum number of cut passes at other nodes (default 10)
-        Minimum drop can also be used for fine tuning */
-    inline void setMaximumCutPasses(int value) {
-        maximumCutPasses_ = value;
-    }
-    /** Get the maximum number of cut passes at other nodes (default 10) */
-    inline int getMaximumCutPasses() const {
-        return maximumCutPasses_;
-    }
-    /** Get current cut pass number in this round of cuts.
-        (1 is first pass) */
-    inline int getCurrentPassNumber() const {
-        return currentPassNumber_;
-    }
-    /** Set current cut pass number in this round of cuts.
-        (1 is first pass) */
-    inline void setCurrentPassNumber(int value) {
-        currentPassNumber_ = value;
-    }
-
-    /** Set the maximum number of candidates to be evaluated for strong
-      branching.
-
-      A value of 0 disables strong branching.
-    */
-    void setNumberStrong(int number);
-    /** Get the maximum number of candidates to be evaluated for strong
-      branching.
-    */
-    inline int numberStrong() const {
-        return numberStrong_;
-    }
-    /** Set global preferred way to branch
-        -1 down, +1 up, 0 no preference */
-    inline void setPreferredWay(int value) {
-        preferredWay_ = value;
-    }
-    /** Get the preferred way to branch (default 0) */
-    inline int getPreferredWay() const {
-        return preferredWay_;
-    }
-    /// Get at which depths to do cuts
-    inline int whenCuts() const {
-        return whenCuts_;
-    }
-    /// Set at which depths to do cuts
-    inline void setWhenCuts(int value) {
-        whenCuts_ = value;
-    }
-    /** Return true if we want to do cuts
-        If allowForTopOfTree zero then just does on multiples of depth
-        if 1 then allows for doing at top of tree
-        if 2 then says if cuts allowed anywhere apart from root
-    */
-    bool doCutsNow(int allowForTopOfTree) const;
-
-    /** Set the number of branches before pseudo costs believed
-        in dynamic strong branching.
-
-      A value of 0 disables dynamic strong branching.
-    */
-    void setNumberBeforeTrust(int number);
-    /** get the number of branches before pseudo costs believed
-        in dynamic strong branching. */
-    inline int numberBeforeTrust() const {
-        return numberBeforeTrust_;
-    }
-    /** Set the number of variables for which to compute penalties
-        in dynamic strong branching.
-
-      A value of 0 disables penalties.
-    */
-    void setNumberPenalties(int number);
-    /** get the number of variables for which to compute penalties
-        in dynamic strong branching. */
-    inline int numberPenalties() const {
-        return numberPenalties_;
-    }
-    /// Pointer to top of tree
-    inline const CbcFullNodeInfo * topOfTree() const
-    { return topOfTree_;}
-    /// Number of analyze iterations to do
-    inline void setNumberAnalyzeIterations(int number) {
-        numberAnalyzeIterations_ = number;
-    }
-    inline int numberAnalyzeIterations() const {
-        return numberAnalyzeIterations_;
-    }
-    /** Get scale factor to make penalties match strong.
-        Should/will be computed */
-    inline double penaltyScaleFactor() const {
-        return penaltyScaleFactor_;
-    }
-    /** Set scale factor to make penalties match strong.
-        Should/will be computed */
-    void setPenaltyScaleFactor(double value);
-    /** Problem type as set by user or found by analysis.  This will be extended
-        0 - not known
-        1 - Set partitioning <=
-        2 - Set partitioning ==
-        3 - Set covering
-        4 - all +- 1 or all +1 and odd
-    */
-    void inline setProblemType(int number) {
-        problemType_ = number;
-    }
-    inline int problemType() const {
-        return problemType_;
-    }
-    /// Current depth
-    inline int currentDepth() const {
-        return currentDepth_;
-    }
-
-    /// Set how often to scan global cuts
-    void setHowOftenGlobalScan(int number);
-    /// Get how often to scan global cuts
-    inline int howOftenGlobalScan() const {
-        return howOftenGlobalScan_;
-    }
-    /// Original columns as created by integerPresolve or preprocessing
-    inline int * originalColumns() const {
-        return originalColumns_;
-    }
-    /// Set original columns as created by preprocessing
-    void setOriginalColumns(const int * originalColumns,
-			    int numberGood=COIN_INT_MAX) ;
-    /// Create conflict cut (well - most of)
-    OsiRowCut * conflictCut(const OsiSolverInterface * solver, bool & localCuts);
-
-    /** Set the print frequency.
-
-      Controls the number of nodes evaluated between status prints.
-      If <tt>number <=0</tt> the print frequency is set to 100 nodes for large
-      problems, 1000 for small problems.
-      Print frequency has very slight overhead if small.
-    */
-    inline void setPrintFrequency(int number) {
-        printFrequency_ = number;
-    }
-    /// Get the print frequency
-    inline int printFrequency() const {
-        return printFrequency_;
-    }
-    //@}
-
-    //---------------------------------------------------------------------------
-    ///@name Methods returning info on how the solution process terminated
-    //@{
-    /// Are there a numerical difficulties?
-    bool isAbandoned() const;
-    /// Is optimality proven?
-    bool isProvenOptimal() const;
-    /// Is  infeasiblity proven (or none better than cutoff)?
-    bool isProvenInfeasible() const;
-    /// Was continuous solution unbounded
-    bool isContinuousUnbounded() const;
-    /// Was continuous solution unbounded
-    bool isProvenDualInfeasible() const;
-    /// Node limit reached?
-    bool isNodeLimitReached() const;
-    /// Time limit reached?
-    bool isSecondsLimitReached() const;
-    /// Solution limit reached?
-    bool isSolutionLimitReached() const;
-    /// Get how many iterations it took to solve the problem.
-    inline int getIterationCount() const {
-        return numberIterations_;
-    }
-    /// Increment how many iterations it took to solve the problem.
-    inline void incrementIterationCount(int value) {
-        numberIterations_ += value;
-    }
-    /// Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP).
-    inline int getNodeCount() const {
-        return numberNodes_;
-    }
-    /// Increment how many nodes it took to solve the problem.
-    inline void incrementNodeCount(int value) {
-        numberNodes_ += value;
-    }
-    /// Get how many Nodes were enumerated in complete fathoming B&B inside CLP
-    inline int getExtraNodeCount() const {
-       return numberExtraNodes_;
-    }
-    /// Get how many times complete fathoming B&B was done
-    inline int getFathomCount() const {
-       return numberFathoms_;
-    }
-    /** Final status of problem
-        Some of these can be found out by is...... functions
-        -1 before branchAndBound
-        0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
-        (or check value of best solution)
-        1 stopped - on maxnodes, maxsols, maxtime
-        2 difficulties so run was abandoned
-        (5 event user programmed event occurred)
-    */
-    inline int status() const {
-        return status_;
-    }
-    inline void setProblemStatus(int value) {
-        status_ = value;
-    }
-    /** Secondary status of problem
-        -1 unset (status_ will also be -1)
-        0 search completed with solution
-        1 linear relaxation not feasible (or worse than cutoff)
-        2 stopped on gap
-        3 stopped on nodes
-        4 stopped on time
-        5 stopped on user event
-        6 stopped on solutions
-        7 linear relaxation unbounded
-        8 stopped on iteration limit
-    */
-    inline int secondaryStatus() const {
-        return secondaryStatus_;
-    }
-    inline void setSecondaryStatus(int value) {
-        secondaryStatus_ = value;
-    }
-    /// Are there numerical difficulties (for initialSolve) ?
-    bool isInitialSolveAbandoned() const ;
-    /// Is optimality proven (for initialSolve) ?
-    bool isInitialSolveProvenOptimal() const ;
-    /// Is primal infeasiblity proven (for initialSolve) ?
-    bool isInitialSolveProvenPrimalInfeasible() const ;
-    /// Is dual infeasiblity proven (for initialSolve) ?
-    bool isInitialSolveProvenDualInfeasible() const ;
-
-    //@}
-
-    //---------------------------------------------------------------------------
-    /**@name Problem information methods
-
-       These methods call the solver's query routines to return
-       information about the problem referred to by the current object.
-       Querying a problem that has no data associated with it result in
-       zeros for the number of rows and columns, and NULL pointers from
-       the methods that return vectors.
-
-       Const pointers returned from any data-query method are valid as
-       long as the data is unchanged and the solver is not called.
-    */
-    //@{
-    /// Number of rows in continuous (root) problem.
-    inline int numberRowsAtContinuous() const {
-        return numberRowsAtContinuous_;
-    }
-
-    /// Get number of columns
-    inline int getNumCols() const {
-        return solver_->getNumCols();
-    }
-
-    /// Get number of rows
-    inline int getNumRows() const {
-        return solver_->getNumRows();
-    }
-
-    /// Get number of nonzero elements
-    inline CoinBigIndex getNumElements() const {
-        return solver_->getNumElements();
-    }
-
-    /// Number of integers in problem
-    inline int numberIntegers() const {
-        return numberIntegers_;
-    }
-    // Integer variables
-    inline const int * integerVariable() const {
-        return integerVariable_;
-    }
-    /// Whether or not integer
-    inline char integerType(int i) const {
-        assert (integerInfo_);
-        assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
-        return integerInfo_[i];
-    }
-    /// Whether or not integer
-    inline const char * integerType() const {
-        return integerInfo_;
-    }
-
-    /// Get pointer to array[getNumCols()] of column lower bounds
-    inline const double * getColLower() const {
-        return solver_->getColLower();
-    }
-
-    /// Get pointer to array[getNumCols()] of column upper bounds
-    inline const double * getColUpper() const {
-        return solver_->getColUpper();
-    }
-
-    /** Get pointer to array[getNumRows()] of row constraint senses.
-        <ul>
-        <li>'L': <= constraint
-        <li>'E': =  constraint
-        <li>'G': >= constraint
-        <li>'R': ranged constraint
-        <li>'N': free constraint
-        </ul>
-    */
-    inline const char * getRowSense() const {
-        return solver_->getRowSense();
-    }
-
-    /** Get pointer to array[getNumRows()] of rows right-hand sides
-        <ul>
-        <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
-        <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
-        <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
-        <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
-        </ul>
-    */
-    inline const double * getRightHandSide() const {
-        return solver_->getRightHandSide();
-    }
-
-    /** Get pointer to array[getNumRows()] of row ranges.
-        <ul>
-        <li> if rowsense()[i] == 'R' then
-        rowrange()[i] == rowupper()[i] - rowlower()[i]
-        <li> if rowsense()[i] != 'R' then
-        rowrange()[i] is 0.0
-        </ul>
-    */
-    inline const double * getRowRange() const {
-        return solver_->getRowRange();
-    }
-
-    /// Get pointer to array[getNumRows()] of row lower bounds
-    inline const double * getRowLower() const {
-        return solver_->getRowLower();
-    }
-
-    /// Get pointer to array[getNumRows()] of row upper bounds
-    inline const double * getRowUpper() const {
-        return solver_->getRowUpper();
-    }
-
-    /// Get pointer to array[getNumCols()] of objective function coefficients
-    inline const double * getObjCoefficients() const {
-        return solver_->getObjCoefficients();
-    }
-
-    /// Get objective function sense (1 for min (default), -1 for max)
-    inline double getObjSense() const {
-        //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
-        return dblParam_[CbcOptimizationDirection];
-    }
-
-    /// Return true if variable is continuous
-    inline bool isContinuous(int colIndex) const {
-        return solver_->isContinuous(colIndex);
-    }
-
-    /// Return true if variable is binary
-    inline bool isBinary(int colIndex) const {
-        return solver_->isBinary(colIndex);
-    }
-
-    /** Return true if column is integer.
-        Note: This function returns true if the the column
-        is binary or a general integer.
-    */
-    inline bool isInteger(int colIndex) const {
-        return solver_->isInteger(colIndex);
-    }
-
-    /// Return true if variable is general integer
-    inline bool isIntegerNonBinary(int colIndex) const {
-        return solver_->isIntegerNonBinary(colIndex);
-    }
-
-    /// Return true if variable is binary and not fixed at either bound
-    inline bool isFreeBinary(int colIndex) const {
-        return solver_->isFreeBinary(colIndex) ;
-    }
-
-    /// Get pointer to row-wise copy of matrix
-    inline const CoinPackedMatrix * getMatrixByRow() const {
-        return solver_->getMatrixByRow();
-    }
-
-    /// Get pointer to column-wise copy of matrix
-    inline const CoinPackedMatrix * getMatrixByCol() const {
-        return solver_->getMatrixByCol();
-    }
-
-    /// Get solver's value for infinity
-    inline double getInfinity() const {
-        return solver_->getInfinity();
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
-    inline const double * getCbcColLower() const {
-        return cbcColLower_;
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
-    inline const double * getCbcColUpper() const {
-        return cbcColUpper_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
-    inline const double * getCbcRowLower() const {
-        return cbcRowLower_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
-    inline const double * getCbcRowUpper() const {
-        return cbcRowUpper_;
-    }
-    /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
-    inline const double * getCbcColSolution() const {
-        return cbcColSolution_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of dual prices
-    inline const double * getCbcRowPrice() const {
-        return cbcRowPrice_;
-    }
-    /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
-    inline const double * getCbcReducedCost() const {
-        return cbcReducedCost_;
-    }
-    /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
-    inline const double * getCbcRowActivity() const {
-        return cbcRowActivity_;
-    }
-    //@}
-
-
-    /**@name Methods related to querying the solution */
-    //@{
-    /// Holds solution at continuous (after cuts if branchAndBound called)
-    inline double * continuousSolution() const {
-        return continuousSolution_;
-    }
-    /** Array marked whenever a solution is found if non-zero.
-        Code marks if heuristic returns better so heuristic
-        need only mark if it wants to on solutions which
-        are worse than current */
-    inline int * usedInSolution() const {
-        return usedInSolution_;
-    }
-    /// Increases usedInSolution for nonzeros
-    void incrementUsed(const double * solution);
-    /// Record a new incumbent solution and update objectiveValue
-    void setBestSolution(CBC_Message how,
-                         double & objectiveValue, const double *solution,
-                         int fixVariables = 0);
-    /// Just update objectiveValue
-    void setBestObjectiveValue( double objectiveValue);
-    /// Deals with event handler and solution
-    CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
-            double objValue,
-            const double * solution);
-
-    /** Call this to really test if a valid solution can be feasible
-        Solution is number columns in size.
-        If fixVariables true then bounds of continuous solver updated.
-        Returns objective value (worse than cutoff if not feasible)
-        Previously computed objective value is now passed in (in case user does not do solve)
-	virtual so user can override
-    */
-    virtual double checkSolution(double cutoff, double * solution,
-                         int fixVariables, double originalObjValue);
-    /** Test the current solution for feasiblility.
-
-      Scan all objects for indications of infeasibility. This is broken down
-      into simple integer infeasibility (\p numberIntegerInfeasibilities)
-      and all other reports of infeasibility (\p numberObjectInfeasibilities).
-    */
-    bool feasibleSolution(int & numberIntegerInfeasibilities,
-                          int & numberObjectInfeasibilities) const;
-
-    /** Solution to the most recent lp relaxation.
-
-      The solver's solution to the most recent lp relaxation.
-    */
-
-    inline double * currentSolution() const {
-        return currentSolution_;
-    }
-    /** For testing infeasibilities - will point to
-        currentSolution_ or solver-->getColSolution()
-    */
-    inline const double * testSolution() const {
-        return testSolution_;
-    }
-    inline void setTestSolution(const double * solution) {
-        testSolution_ = solution;
-    }
-    /// Make sure region there and optionally copy solution
-    void reserveCurrentSolution(const double * solution = NULL);
-
-    /// Get pointer to array[getNumCols()] of primal solution vector
-    inline const double * getColSolution() const {
-        return solver_->getColSolution();
-    }
-
-    /// Get pointer to array[getNumRows()] of dual prices
-    inline const double * getRowPrice() const {
-        return solver_->getRowPrice();
-    }
-
-    /// Get a pointer to array[getNumCols()] of reduced costs
-    inline const double * getReducedCost() const {
-        return solver_->getReducedCost();
-    }
-
-    /// Get pointer to array[getNumRows()] of row activity levels.
-    inline const double * getRowActivity() const {
-        return solver_->getRowActivity();
-    }
-
-    /// Get current objective function value
-    inline double getCurrentObjValue() const {
-        return dblParam_[CbcCurrentObjectiveValue];
-    }
-    /// Get current minimization objective function value
-    inline double getCurrentMinimizationObjValue() const {
-        return dblParam_[CbcCurrentMinimizationObjectiveValue];
-    }
-
-    /// Get best objective function value as minimization
-    inline double getMinimizationObjValue() const {
-        return bestObjective_;
-    }
-    /// Set best objective function value as minimization
-    inline void setMinimizationObjValue(double value) {
-        bestObjective_ = value;
-    }
-
-    /// Get best objective function value
-    inline double getObjValue() const {
-        return bestObjective_ * solver_->getObjSense() ;
-    }
-    /** Get best possible objective function value.
-        This is better of best possible left on tree
-        and best solution found.
-        If called from within branch and cut may be optimistic.
-    */
-    double getBestPossibleObjValue() const;
-    /// Set best objective function value
-    inline void setObjValue(double value) {
-        bestObjective_ = value * solver_->getObjSense() ;
-    }
-    /// Get solver objective function value (as minimization)
-    inline double getSolverObjValue() const {
-        return solver_->getObjValue() * solver_->getObjSense() ;
-    }
-
-    /** The best solution to the integer programming problem.
-
-      The best solution to the integer programming problem found during
-      the search. If no solution is found, the method returns null.
-    */
-
-    inline double * bestSolution() const {
-        return bestSolution_;
-    }
-    /** User callable setBestSolution.
-        If check false does not check valid
-        If true then sees if feasible and warns if objective value
-        worse than given (so just set to COIN_DBL_MAX if you don't care).
-        If check true then does not save solution if not feasible
-    */
-    void setBestSolution(const double * solution, int numberColumns,
-                         double objectiveValue, bool check = false);
-
-    /// Get number of solutions
-    inline int getSolutionCount() const {
-        return numberSolutions_;
-    }
-
-    /// Set number of solutions (so heuristics will be different)
-    inline void setSolutionCount(int value) {
-        numberSolutions_ = value;
-    }
-    /// Number of saved solutions (including best)
-    int numberSavedSolutions() const;
-    /// Maximum number of extra saved solutions
-    inline int maximumSavedSolutions() const {
-        return maximumSavedSolutions_;
-    }
-    /// Set maximum number of extra saved solutions
-    void setMaximumSavedSolutions(int value);
-    /// Return a saved solution (0==best) - NULL if off end
-    const double * savedSolution(int which) const;
-    /// Return a saved solution objective (0==best) - COIN_DBL_MAX if off end
-    double savedSolutionObjective(int which) const;
-    /// Delete a saved solution and move others up
-    void deleteSavedSolution(int which);
-
-    /** Current phase (so heuristics etc etc can find out).
-        0 - initial solve
-        1 - solve with cuts at root
-        2 - solve with cuts
-        3 - other e.g. strong branching
-        4 - trying to validate a solution
-        5 - at end of search
-    */
-    inline int phase() const {
-        return phase_;
-    }
-
-    /// Get number of heuristic solutions
-    inline int getNumberHeuristicSolutions() const {
-        return numberHeuristicSolutions_;
-    }
-    /// Set number of heuristic solutions
-    inline void setNumberHeuristicSolutions(int value) {
-        numberHeuristicSolutions_ = value;
-    }
-
-    /// Set objective function sense (1 for min (default), -1 for max,)
-    inline void setObjSense(double s) {
-        dblParam_[CbcOptimizationDirection] = s;
-        solver_->setObjSense(s);
-    }
-
-    /// Value of objective at continuous
-    inline double getContinuousObjective() const {
-        return originalContinuousObjective_;
-    }
-    inline void setContinuousObjective(double value) {
-        originalContinuousObjective_ = value;
-    }
-    /// Number of infeasibilities at continuous
-    inline int getContinuousInfeasibilities() const {
-        return continuousInfeasibilities_;
-    }
-    inline void setContinuousInfeasibilities(int value) {
-        continuousInfeasibilities_ = value;
-    }
-    /// Value of objective after root node cuts added
-    inline double rootObjectiveAfterCuts() const {
-        return continuousObjective_;
-    }
-    /// Sum of Changes to objective by first solve
-    inline double sumChangeObjective() const {
-        return sumChangeObjective1_;
-    }
-    /** Number of times global cuts violated.  When global cut pool then this
-        should be kept for each cut and type of cut */
-    inline int numberGlobalViolations() const {
-        return numberGlobalViolations_;
-    }
-    inline void clearNumberGlobalViolations() {
-        numberGlobalViolations_ = 0;
-    }
-    /// Whether to force a resolve after takeOffCuts
-    inline bool resolveAfterTakeOffCuts() const {
-        return resolveAfterTakeOffCuts_;
-    }
-    inline void setResolveAfterTakeOffCuts(bool yesNo) {
-        resolveAfterTakeOffCuts_ = yesNo;
-    }
-    /// Maximum number of rows
-    inline int maximumRows() const {
-        return maximumRows_;
-    }
-    /// Work basis for temporary use
-    inline CoinWarmStartBasis & workingBasis() {
-        return workingBasis_;
-    }
-    /// Get number of "iterations" to stop after
-    inline int getStopNumberIterations() const {
-        return stopNumberIterations_;
-    }
-    /// Set number of "iterations" to stop after
-    inline void setStopNumberIterations(int value) {
-        stopNumberIterations_ = value;
-    }
-    /// A pointer to model from CbcHeuristic
-    inline CbcModel * heuristicModel() const
-    { return heuristicModel_;}
-    /// Set a pointer to model from CbcHeuristic
-    inline void setHeuristicModel(CbcModel * model)
-    { heuristicModel_ = model;}
-    //@}
-
-    /** \name Node selection */
-    //@{
-    // Comparison functions (which may be overridden by inheritance)
-    inline CbcCompareBase * nodeComparison() const {
-        return nodeCompare_;
-    }
-    void setNodeComparison(CbcCompareBase * compare);
-    void setNodeComparison(CbcCompareBase & compare);
-    //@}
-
-    /** \name Problem feasibility checking */
-    //@{
-    // Feasibility functions (which may be overridden by inheritance)
-    inline CbcFeasibilityBase * problemFeasibility() const {
-        return problemFeasibility_;
-    }
-    void setProblemFeasibility(CbcFeasibilityBase * feasibility);
-    void setProblemFeasibility(CbcFeasibilityBase & feasibility);
-    //@}
-
-    /** \name Tree methods and subtree methods */
-    //@{
-    /// Tree method e.g. heap (which may be overridden by inheritance)
-    inline CbcTree * tree() const {
-        return tree_;
-    }
-    /// For modifying tree handling (original is cloned)
-    void passInTreeHandler(CbcTree & tree);
-    /** For passing in an CbcModel to do a sub Tree (with derived tree handlers).
-        Passed in model must exist for duration of branch and bound
-    */
-    void passInSubTreeModel(CbcModel & model);
-    /** For retrieving a copy of subtree model with given OsiSolver.
-        If no subtree model will use self (up to user to reset cutoff etc).
-        If solver NULL uses current
-    */
-    CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
-    /// Returns number of times any subtree stopped on nodes, time etc
-    inline int numberStoppedSubTrees() const {
-        return numberStoppedSubTrees_;
-    }
-    /// Says a sub tree was stopped
-    inline void incrementSubTreeStopped() {
-        numberStoppedSubTrees_++;
-    }
-    /** Whether to automatically do presolve before branch and bound (subTrees).
-        0 - no
-        1 - ordinary presolve
-        2 - integer presolve (dodgy)
-    */
-    inline int typePresolve() const {
-        return presolve_;
-    }
-    inline void setTypePresolve(int value) {
-        presolve_ = value;
-    }
-
-    //@}
-
-    /** \name Branching Decisions
-
-      See the CbcBranchDecision class for additional information.
-    */
-    //@{
-
-    /// Get the current branching decision method.
-    inline CbcBranchDecision * branchingMethod() const {
-        return branchingMethod_;
-    }
-    /// Set the branching decision method.
-    inline void setBranchingMethod(CbcBranchDecision * method) {
-        delete branchingMethod_;
-        branchingMethod_ = method->clone();
-    }
-    /** Set the branching method
-
-      \overload
-    */
-    inline void setBranchingMethod(CbcBranchDecision & method) {
-        delete branchingMethod_;
-        branchingMethod_ = method.clone();
-    }
-    /// Get the current cut modifier method
-    inline CbcCutModifier * cutModifier() const {
-        return cutModifier_;
-    }
-    /// Set the cut modifier method
-    void setCutModifier(CbcCutModifier * modifier);
-    /** Set the cut modifier method
-
-      \overload
-    */
-    void setCutModifier(CbcCutModifier & modifier);
-    //@}
-
-    /** \name Row (constraint) and Column (variable) cut generation */
-    //@{
-
-    /** State of search
-        0 - no solution
-        1 - only heuristic solutions
-        2 - branched to a solution
-        3 - no solution but many nodes
-    */
-    inline int stateOfSearch() const {
-        return stateOfSearch_;
-    }
-    inline void setStateOfSearch(int state) {
-        stateOfSearch_ = state;
-    }
-    /// Strategy worked out - mainly at root node for use by CbcNode
-    inline int searchStrategy() const {
-        return searchStrategy_;
-    }
-    /// Set strategy worked out - mainly at root node for use by CbcNode
-    inline void setSearchStrategy(int value) {
-        searchStrategy_ = value;
-    }
-    /// Stong branching strategy
-    inline int strongStrategy() const {
-        return strongStrategy_;
-    }
-    /// Set strong branching strategy
-    inline void setStrongStrategy(int value) {
-        strongStrategy_ = value;
-    }
-
-    /// Get the number of cut generators
-    inline int numberCutGenerators() const {
-        return numberCutGenerators_;
-    }
-    /// Get the list of cut generators
-    inline CbcCutGenerator ** cutGenerators() const {
-        return generator_;
-    }
-    ///Get the specified cut generator
-    inline CbcCutGenerator * cutGenerator(int i) const {
-        return generator_[i];
-    }
-    ///Get the specified cut generator before any changes
-    inline CbcCutGenerator * virginCutGenerator(int i) const {
-        return virginGenerator_[i];
-    }
-    /** Add one generator - up to user to delete generators.
-        howoften affects how generator is used. 0 or 1 means always,
-        >1 means every that number of nodes.  Negative values have same
-        meaning as positive but they may be switched off (-> -100) by code if
-        not many cuts generated at continuous.  -99 is just done at root.
-        Name is just for printout.
-        If depth >0 overrides how often generator is called (if howOften==-1 or >0).
-    */
-    void addCutGenerator(CglCutGenerator * generator,
-                         int howOften = 1, const char * name = NULL,
-                         bool normal = true, bool atSolution = false,
-                         bool infeasible = false, int howOftenInSub = -100,
-                         int whatDepth = -1, int whatDepthInSub = -1);
-//@}
-    /** \name Strategy and sub models
-
-      See the CbcStrategy class for additional information.
-    */
-    //@{
-
-    /// Get the current strategy
-    inline CbcStrategy * strategy() const {
-        return strategy_;
-    }
-    /// Set the strategy. Clones
-    void setStrategy(CbcStrategy & strategy);
-    /// Set the strategy. assigns
-    inline void setStrategy(CbcStrategy * strategy) {
-        strategy_ = strategy;
-    }
-    /// Get the current parent model
-    inline CbcModel * parentModel() const {
-        return parentModel_;
-    }
-    /// Set the parent model
-    inline void setParentModel(CbcModel & parentModel) {
-        parentModel_ = &parentModel;
-    }
-    //@}
-
-
-    /** \name Heuristics and priorities */
-    //@{
-    /*! \brief Add one heuristic - up to user to delete
-
-      The name is just used for print messages.
-    */
-    void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
-                      int before = -1);
-    ///Get the specified heuristic
-    inline CbcHeuristic * heuristic(int i) const {
-        return heuristic_[i];
-    }
-    /// Get the number of heuristics
-    inline int numberHeuristics() const {
-        return numberHeuristics_;
-    }
-    /// Set the number of heuristics
-    inline void setNumberHeuristics(int value) {
-        numberHeuristics_ = value;
-    }
-    /// Pointer to heuristic solver which found last solution (or NULL)
-    inline CbcHeuristic * lastHeuristic() const {
-        return lastHeuristic_;
-    }
-    /// set last heuristic which found a solution
-    inline void setLastHeuristic(CbcHeuristic * last) {
-        lastHeuristic_ = last;
-    }
-
-    /** Pass in branching priorities.
-
-        If ifClique then priorities are on cliques otherwise priorities are
-        on integer variables.
-        Other type (if exists set to default)
-        1 is highest priority. (well actually -INT_MAX is but that's ugly)
-        If hotstart > 0 then branches are created to force
-        the variable to the value given by best solution.  This enables a
-        sort of hot start.  The node choice should be greatest depth
-        and hotstart should normally be switched off after a solution.
-
-        If ifNotSimpleIntegers true then appended to normal integers
-
-        This is now deprecated except for simple usage.  If user
-        creates Cbcobjects then set priority in them
-
-        \internal Added for Kurt Spielberg.
-    */
-    void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
-
-    /// Returns priority level for an object (or 1000 if no priorities exist)
-    inline int priority(int sequence) const {
-        return object_[sequence]->priority();
-    }
-
-    /*! \brief Set an event handler
-
-      A clone of the handler passed as a parameter is stored in CbcModel.
-    */
-    void passInEventHandler(const CbcEventHandler *eventHandler) ;
-
-    /*! \brief Retrieve a pointer to the event handler */
-    inline CbcEventHandler* getEventHandler() const {
-        return (eventHandler_) ;
-    }
-
-    //@}
-
-    /**@name Setting/Accessing application data */
-    //@{
-    /** Set application data.
-
-    This is a pointer that the application can store into and
-    retrieve from the solver interface.
-    This field is available for the application to optionally
-    define and use.
-    */
-    void setApplicationData (void * appData);
-
-    /// Get application data
-    void * getApplicationData() const;
-    /**
-        For advanced applications you may wish to modify the behavior of Cbc
-        e.g. if the solver is a NLP solver then you may not have an exact
-        optimum solution at each step.  Information could be built into
-        OsiSolverInterface but this is an alternative so that that interface
-        does not have to be changed.  If something similar is useful to
-        enough solvers then it could be migrated
-        You can also pass in by using solver->setAuxiliaryInfo.
-        You should do that if solver is odd - if solver is normal simplex
-        then use this.
-        NOTE - characteristics are not cloned
-    */
-    void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
-    /// Get solver characteristics
-    inline const OsiBabSolver * solverCharacteristics() const {
-        return solverCharacteristics_;
-    }
-    //@}
-
-    //---------------------------------------------------------------------------
-
-    /**@name Message handling etc */
-    //@{
-    /// Pass in Message handler (not deleted at end)
-    void passInMessageHandler(CoinMessageHandler * handler);
-    /// Set language
-    void newLanguage(CoinMessages::Language language);
-    inline void setLanguage(CoinMessages::Language language) {
-        newLanguage(language);
-    }
-    /// Return handler
-    inline CoinMessageHandler * messageHandler() const {
-        return handler_;
-    }
-    /// Return messages
-    inline CoinMessages & messages() {
-        return messages_;
-    }
-    /// Return pointer to messages
-    inline CoinMessages * messagesPointer() {
-        return &messages_;
-    }
-    /// Set log level
-    void setLogLevel(int value);
-    /// Get log level
-    inline int logLevel() const {
-        return handler_->logLevel();
-    }
-    /** Set flag to say if handler_ is the default handler.
-
-      The default handler is deleted when the model is deleted. Other
-      handlers (supplied by the client) will not be deleted.
-    */
-    inline void setDefaultHandler(bool yesNo) {
-        defaultHandler_ = yesNo;
-    }
-    /// Check default handler
-    inline bool defaultHandler() const {
-        return defaultHandler_;
-    }
-    //@}
-    //---------------------------------------------------------------------------
-    ///@name Specialized
-    //@{
-
-    /**
-        Set special options
-        0 bit (1) - check if cuts valid (if on debugger list)
-        1 bit (2) - use current basis to check integer solution (rather than all slack)
-        2 bit (4) - don't check integer solution (by solving LP)
-        3 bit (8) - fast analyze
-        4 bit (16) - non-linear model - so no well defined CoinPackedMatrix
-        5 bit (32) - keep names
-        6 bit (64) - try for dominated columns
-        7 bit (128) - SOS type 1 but all declared integer
-        8 bit (256) - Set to say solution just found, unset by doing cuts
-        9 bit (512) - Try reduced model after 100 nodes
-        10 bit (1024) - Switch on some heuristics even if seems unlikely
-        11 bit (2048) - Mark as in small branch and bound
-        12 bit (4096) - Funny cuts so do slow way (in some places)
-        13 bit (8192) - Funny cuts so do slow way (in other places)
-        14 bit (16384) - Use Cplex! for fathoming
-        15 bit (32768) - Try reduced model after 0 nodes
-        16 bit (65536) - Original model had integer bounds
-        17 bit (131072) - Perturbation switched off
-        18 bit (262144) - donor CbcModel
-        19 bit (524288) - recipient CbcModel
-        20 bit (1048576) - waiting for sub model to return
-	22 bit (4194304) - do not initialize random seed in solver (user has)
-	23 bit (8388608) - leave solver_ with cuts
-	24 bit (16777216) - just get feasible if no cutoff
-    */
-    inline void setSpecialOptions(int value) {
-        specialOptions_ = value;
-    }
-    /// Get special options
-    inline int specialOptions() const {
-        return specialOptions_;
-    }
-    /// Set random seed
-    inline void setRandomSeed(int value) {
-        randomSeed_ = value;
-    }
-    /// Get random seed
-    inline int getRandomSeed() const {
-        return randomSeed_;
-    }
-    /// Set multiple root tries
-    inline void setMultipleRootTries(int value) {
-        multipleRootTries_ = value;
-    }
-    /// Get multiple root tries
-    inline int getMultipleRootTries() const {
-        return multipleRootTries_;
-    }
-    /// Tell model to stop on event
-    inline void sayEventHappened()
-    { eventHappened_=true;}
-    /// Says if normal solver i.e. has well defined CoinPackedMatrix
-    inline bool normalSolver() const {
-        return (specialOptions_&16) == 0;
-    }
-    /** Says if model is sitting there waiting for mini branch and bound to finish
-	This is because an event handler may only have access to parent model in
-	mini branch and bound
-    */
-    inline bool waitingForMiniBranchAndBound() const {
-        return (specialOptions_&1048576) != 0;
-    }
-    /** Set more special options
-        at present bottom 6 bits used for shadow price mode
-        1024 for experimental hotstart
-        2048,4096 breaking out of cuts
-        8192 slowly increase minimum drop
-        16384 gomory
-	32768 more heuristics in sub trees
-	65536 no cuts in preprocessing
-        131072 Time limits elapsed
-        18 bit (262144) - Perturb fathom nodes
-        19 bit (524288) - No limit on fathom nodes
-        20 bit (1048576) - Reduce sum of infeasibilities before cuts
-        21 bit (2097152) - Reduce sum of infeasibilities after cuts
-	22 bit (4194304) - Conflict analysis
-	23 bit (8388608) - Conflict analysis - temporary bit
-	24 bit (16777216) - Add cutoff as LP constraint (out)
-	25 bit (33554432) - diving/reordering
-	26 bit (67108864) - load global cuts from file
-	27 bit (134217728) - append binding global cuts to file
-	28 bit (268435456) - idiot branching
-        29 bit (536870912) - don't make fake objective
-	30 bit (1073741824) - Funny SOS or similar - be careful
-    */
-    inline void setMoreSpecialOptions(int value) {
-        moreSpecialOptions_ = value;
-    }
-    /// Get more special options
-    inline int moreSpecialOptions() const {
-        return moreSpecialOptions_;
-    }
-    /** Set more more special options
-	0 bit (1) - find switching variables
-	1 bit (2) - using fake objective until solution
-	2 bit (4) - switching variables exist
-	3 bit (8) - skip most of setBestSolution checks
-	4 bit (16) - very lightweight preprocessing in smallB&B
-	5 bit (32) - event handler needs to be cloned when parallel
-	6 bit (64) - testing - use probing to make cliques
-	7/8 bit (128) - try orbital branching (if nauty)
-	9 bit (512) - branching on objective (later)
-	10 bit (1024) - branching on constraints (later)
-	11/12 bit 2048 - intermittent cuts
-	13/14 bit 8192 - go to bitter end in strong branching (first time)
-    */
-    inline void setMoreSpecialOptions2(int value) {
-        moreSpecialOptions2_ = value;
-    }
-    /// Get more special options2
-    inline int moreSpecialOptions2() const {
-        return moreSpecialOptions2_;
-    }
-    /// Set cutoff as constraint
-    inline void setCutoffAsConstraint(bool yesNo) {
-      cutoffRowNumber_ = (yesNo) ? -2 : -1;
-    }
-    /// Set time method
-    inline void setUseElapsedTime(bool yesNo) {
-        if (yesNo)
-  	  moreSpecialOptions_ |= 131072;
-	else
-	  moreSpecialOptions_ &= ~131072;
-    }
-    /// Get time method
-    inline bool useElapsedTime() const {
-        return (moreSpecialOptions_&131072)!=0;
-    }
-    /// Get useful temporary pointer
-    inline void * temporaryPointer() const
-    { return temporaryPointer_;}
-    /// Set useful temporary pointer
-    inline void setTemporaryPointer(void * pointer)
-    { temporaryPointer_=pointer;}
-    /// Go to dantzig pivot selection if easy problem (clp only)
-    void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
-    /// Now we may not own objects - just point to solver's objects
-    inline bool ownObjects() const {
-        return ownObjects_;
-    }
-    /// Check original model before it gets messed up
-    void checkModel();
-    //@}
-    //---------------------------------------------------------------------------
-
-    ///@name Constructors and destructors etc
-    //@{
-    /// Default Constructor
-    CbcModel();
-
-    /// Constructor from solver
-    CbcModel(const OsiSolverInterface &);
-
-    /** Assign a solver to the model (model assumes ownership)
-
-      On return, \p solver will be NULL.
-      If deleteSolver then current solver deleted (if model owned)
-
-      \note Parameter settings in the outgoing solver are not inherited by
-        the incoming solver.
-    */
-    void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
-
-    /** \brief Set ownership of solver
-
-      A parameter of false tells CbcModel it does not own the solver and
-      should not delete it. Once you claim ownership of the solver, you're
-      responsible for eventually deleting it. Note that CbcModel clones
-      solvers with abandon.  Unless you have a deep understanding of the
-      workings of CbcModel, the only time you want to claim ownership is when
-      you're about to delete the CbcModel object but want the solver to
-      continue to exist (as, for example, when branchAndBound has finished
-      and you want to hang on to the answer).
-    */
-    inline void setModelOwnsSolver (bool ourSolver) {
-        ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
-    }
-
-    /*! \brief Get ownership of solver
-
-      A return value of true means that CbcModel owns the solver and will
-      take responsibility for deleting it when that becomes necessary.
-    */
-    inline bool modelOwnsSolver () {
-        return ((ownership_&0x80000000) != 0) ;
-    }
-
-    /** Copy constructor .
-      If cloneHandler is true then message handler is cloned
-    */
-    CbcModel(const CbcModel & rhs, bool cloneHandler = false);
-
-    /** Clone */
-    virtual CbcModel *clone (bool cloneHandler);
-
-    /// Assignment operator
-    CbcModel & operator=(const CbcModel& rhs);
-
-    /// Destructor
-    virtual ~CbcModel ();
-
-    /// Returns solver - has current state
-    inline OsiSolverInterface * solver() const {
-        return solver_;
-    }
-
-    /// Returns current solver - sets new one
-    inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
-        OsiSolverInterface * returnSolver = solver_;
-        solver_ = solver;
-        return returnSolver;
-    }
-
-    /// Returns solver with continuous state
-    inline OsiSolverInterface * continuousSolver() const {
-        return continuousSolver_;
-    }
-
-    /// Create solver with continuous state
-    inline void createContinuousSolver() {
-        continuousSolver_ = solver_->clone();
-    }
-    /// Clear solver with continuous state
-    inline void clearContinuousSolver() {
-        delete continuousSolver_;
-        continuousSolver_ = NULL;
-    }
-
-    /// A copy of the solver, taken at constructor or by saveReferenceSolver
-    inline OsiSolverInterface * referenceSolver() const {
-        return referenceSolver_;
-    }
-
-    /// Save a copy of the current solver so can be reset to
-    void saveReferenceSolver();
-
-    /** Uses a copy of reference solver to be current solver.
-        Because of possible mismatches all exotic integer information is loat
-        (apart from normal information in OsiSolverInterface)
-        so SOS etc and priorities will have to be redone
-    */
-    void resetToReferenceSolver();
-
-    /// Clears out as much as possible (except solver)
-    void gutsOfDestructor();
-    /** Clears out enough to reset CbcModel as if no branch and bound done
-     */
-    void gutsOfDestructor2();
-    /** Clears out enough to reset CbcModel cutoff etc
-     */
-    void resetModel();
-    /** Most of copy constructor
-        mode - 0 copy but don't delete before
-               1 copy and delete before
-           2 copy and delete before (but use virgin generators)
-    */
-    void gutsOfCopy(const CbcModel & rhs, int mode = 0);
-    /// Move status, nodes etc etc across
-    void moveInfo(const CbcModel & rhs);
-    //@}
-
-    ///@name Multithreading
-    //@{
-    /// Indicates whether Cbc library has been compiled with multithreading support
-    static bool haveMultiThreadSupport();
-    /// Get pointer to masterthread
-    CbcThread * masterThread() const {
-        return masterThread_;
-    }
-    /// Get pointer to walkback
-    CbcNodeInfo ** walkback() const {
-        return walkback_;
-    }
-    /// Get number of threads
-    inline int getNumberThreads() const {
-        return numberThreads_;
-    }
-    /// Set number of threads
-    inline void setNumberThreads(int value) {
-        numberThreads_ = value;
-    }
-    /// Get thread mode
-    inline int getThreadMode() const {
-        return threadMode_;
-    }
-    /** Set thread mode
-        always use numberThreads for branching
-        1 set then deterministic
-        2 set then use numberThreads for root cuts
-        4 set then use numberThreads in root mini branch and bound
-        8 set and numberThreads - do heuristics numberThreads at a time
-        8 set and numberThreads==0 do all heuristics at once
-        default is 0
-    */
-    inline void setThreadMode(int value) {
-        threadMode_ = value;
-    }
-    /** Return
-        -2 if deterministic threaded and main thread
-        -1 if deterministic threaded and serial thread
-        0 if serial
-        1 if opportunistic threaded
-    */
-    inline int parallelMode() const {
-        if (!numberThreads_) {
-            if ((threadMode_&1) == 0)
-                return 0;
-            else
-                return -1;
-            return 0;
-        } else {
-            if ((threadMode_&1) == 0)
-                return 1;
-            else
-                return -2;
-        }
-    }
-    /// Thread stuff for master
-    inline CbcBaseModel * master() const
-    { return master_;}
-    /// From here to end of section - code in CbcThread.cpp until class changed
-    /// Returns true if locked
-    bool isLocked() const;
-#ifdef CBC_THREAD
-    /**
-       Locks a thread if parallel so that stuff like cut pool
-       can be updated and/or used.
-    */
-    void lockThread();
-    /**
-       Unlocks a thread if parallel to say cut pool stuff not needed
-    */
-    void unlockThread();
-#else
-    inline void lockThread() {}
-    inline void unlockThread() {}
-#endif
-    /** Set information in a child
-        -3 pass pointer to child thread info
-        -2 just stop
-        -1 delete simple child stuff
-        0 delete opportunistic child stuff
-        1 delete deterministic child stuff
-    */
-    void setInfoInChild(int type, CbcThread * info);
-    /** Move/copy information from one model to another
-        -1 - initialization
-        0 - from base model
-        1 - to base model (and reset)
-        2 - add in final statistics etc (and reset so can do clean destruction)
-    */
-    void moveToModel(CbcModel * baseModel, int mode);
-    /// Split up nodes
-    int splitModel(int numberModels, CbcModel ** model,
-                   int numberNodes);
-    /// Start threads
-    void startSplitModel(int numberIterations);
-    /// Merge models
-    void mergeModels(int numberModel, CbcModel ** model,
-                     int numberNodes);
-    //@}
-
-    ///@name semi-private i.e. users should not use
-    //@{
-    /// Get how many Nodes it took to solve the problem.
-    int getNodeCount2() const {
-        return numberNodes2_;
-    }
-    /// Set pointers for speed
-    void setPointers(const OsiSolverInterface * solver);
-    /** Perform reduced cost fixing
-
-      Fixes integer variables at their current value based on reduced cost
-      penalties.  Returns number fixed
-    */
-    int reducedCostFix() ;
-    /** Makes all handlers same.  If makeDefault 1 then makes top level
-        default and rest point to that.  If 2 then each is copy
-    */
-    void synchronizeHandlers(int makeDefault);
-    /// Save a solution to saved list
-    void saveExtraSolution(const double * solution, double objectiveValue);
-    /// Save a solution to best and move current to saved
-    void saveBestSolution(const double * solution, double objectiveValue);
-    /// Delete best and saved solutions
-    void deleteSolutions();
-    /// Encapsulates solver resolve
-    int resolve(OsiSolverInterface * solver);
-#ifdef CLP_RESOLVE
-    /// Special purpose resolve
-    int resolveClp(OsiClpSolverInterface * solver, int type);
-#endif
-
-    /** Encapsulates choosing a variable -
-        anyAction -2, infeasible (-1 round again), 0 done
-    */
-    int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
-                     CbcNode * oldNode, OsiCuts & cuts,
-                     bool & resolved, CoinWarmStartBasis *lastws,
-                     const double * lowerBefore, const double * upperBefore,
-                     OsiSolverBranch * & branches);
-    int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
-
-    /** Return an empty basis object of the specified size
-
-      A useful utility when constructing a basis for a subproblem from scratch.
-      The object returned will be of the requested capacity and appropriate for
-      the solver attached to the model.
-    */
-    CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
-
-    /** Remove inactive cuts from the model
-
-      An OsiSolverInterface is expected to maintain a valid basis, but not a
-      valid solution, when loose cuts are deleted. Restoring a valid solution
-      requires calling the solver to reoptimise. If it's certain the solution
-      will not be required, set allowResolve to false to suppress
-      reoptimisation.
-      If saveCuts then slack cuts will be saved
-      On input current cuts are cuts and newCuts
-      on exit current cuts will be correct.  Returns number dropped
-    */
-    int takeOffCuts(OsiCuts &cuts,
-                    bool allowResolve, OsiCuts * saveCuts,
-                    int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;
-
-    /** Determine and install the active cuts that need to be added for
-      the current subproblem
-
-      The whole truth is a bit more complicated. The first action is a call to
-      addCuts1(). addCuts() then sorts through the list, installs the tight
-      cuts in the model, and does bookkeeping (adjusts reference counts).
-      The basis returned from addCuts1() is adjusted accordingly.
-
-      If it turns out that the node should really be fathomed by bound,
-      addCuts() simply treats all the cuts as loose as it does the bookkeeping.
-
-    */
-    int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws);
-
-    /** Traverse the tree from node to root and prep the model
-
-      addCuts1() begins the job of prepping the model to match the current
-      subproblem. The model is stripped of all cuts, and the search tree is
-      traversed from node to root to determine the changes required. Appropriate
-      bounds changes are installed, a list of cuts is collected but not
-      installed, and an appropriate basis (minus the cuts, but big enough to
-      accommodate them) is constructed.
-
-      Returns true if new problem similar to old
-
-      \todo addCuts1() is called in contexts where it's known in advance that
-        all that's desired is to determine a list of cuts and do the
-        bookkeeping (adjust the reference counts). The work of installing
-        bounds and building a basis goes to waste.
-    */
-    bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
-    /** Returns bounds just before where - initially original bounds.
-        Also sets downstream nodes (lower if force 1, upper if 2)
-    */
-    void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
-                         double & lower, double & upper, int force);
-    /** Set objective value in a node.  This is separated out so that
-       odd solvers can use.  It may look at extra information in
-       solverCharacteriscs_ and will also use bound from parent node
-    */
-    void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
-
-    /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
-        Scan and convert CbcSimpleInteger objects
-    */
-    void convertToDynamic();
-    /// Set numberBeforeTrust in all objects
-    void synchronizeNumberBeforeTrust(int type = 0);
-    /// Zap integer information in problem (may leave object info)
-    void zapIntegerInformation(bool leaveObjects = true);
-    /// Use cliques for pseudocost information - return nonzero if infeasible
-    int cliquePseudoCosts(int doStatistics);
-    /// Fill in useful estimates
-    void pseudoShadow(int type);
-    /** Return pseudo costs
-        If not all integers or not pseudo costs - returns all zero
-        Length of arrays are numberIntegers() and entries
-        correspond to integerVariable()[i]
-        User must allocate arrays before call
-    */
-    void fillPseudoCosts(double * downCosts, double * upCosts,
-                         int * priority = NULL,
-                         int * numberDown = NULL, int * numberUp = NULL,
-                         int * numberDownInfeasible = NULL,
-                         int * numberUpInfeasible = NULL) const;
-    /** Do heuristics at root.
-        0 - don't delete
-        1 - delete
-        2 - just delete - don't even use
-    */
-    void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
-    /// Adjust heuristics based on model
-    void adjustHeuristics();
-    /// Get the hotstart solution
-    inline const double * hotstartSolution() const {
-        return hotstartSolution_;
-    }
-    /// Get the hotstart priorities
-    inline const int * hotstartPriorities() const {
-        return hotstartPriorities_;
-    }
-
-    /// Return the list of cuts initially collected for this subproblem
-    inline CbcCountRowCut ** addedCuts() const {
-        return addedCuts_;
-    }
-    /// Number of entries in the list returned by #addedCuts()
-    inline int currentNumberCuts() const {
-        return currentNumberCuts_;
-    }
-    /// Global cuts
-    inline CbcRowCuts * globalCuts() {
-        return &globalCuts_;
-    }
-    /// Get rid of global cuts
-    inline void zapGlobalCuts() {
-        globalCuts_ = CbcRowCuts();
-    }
-    /// Copy and set a pointer to a row cut which will be added instead of normal branching.
-    void setNextRowCut(const OsiRowCut & cut);
-    /// Get a pointer to current node (be careful)
-    inline CbcNode * currentNode() const {
-        return currentNode_;
-    }
-    /// Get a pointer to probing info
-    inline CglTreeProbingInfo * probingInfo() const {
-        return probingInfo_;
-    }
-    /// Thread specific random number generator
-    inline CoinThreadRandom * randomNumberGenerator() {
-        return &randomNumberGenerator_;
-    }
-    /// Set the number of iterations done in strong branching.
-    inline void setNumberStrongIterations(int number) {
-        numberStrongIterations_ = number;
-    }
-    /// Get the number of iterations done in strong branching.
-    inline int numberStrongIterations() const {
-        return numberStrongIterations_;
-    }
-    /// Get maximum number of iterations (designed to be used in heuristics)
-    inline int maximumNumberIterations() const {
-        return maximumNumberIterations_;
-    }
-    /// Set maximum number of iterations (designed to be used in heuristics)
-    inline void setMaximumNumberIterations(int value) {
-        maximumNumberIterations_ = value;
-    }
-    /// Symmetry information
-    inline CbcSymmetry * symmetryInfo() const
-    { return symmetryInfo_;}  
-    /// Set depth for fast nodes
-    inline void setFastNodeDepth(int value) {
-        fastNodeDepth_ = value;
-    }
-    /// Get depth for fast nodes
-    inline int fastNodeDepth() const {
-        return fastNodeDepth_;
-    }
-    /// Get anything with priority >= this can be treated as continuous
-    inline int continuousPriority() const {
-        return continuousPriority_;
-    }
-    /// Set anything with priority >= this can be treated as continuous
-    inline void setContinuousPriority(int value) {
-        continuousPriority_ = value;
-    }
-    inline void incrementExtra(int nodes, int iterations, int fathoms=1) {
-        numberExtraNodes_ += nodes;
-        numberExtraIterations_ += iterations;
-	numberFathoms_ += fathoms;
-    }
-    /// Zero extra
-    inline void zeroExtra() {
-        numberExtraNodes_ = 0;
-        numberExtraIterations_ = 0;
-	numberFathoms_ = 0;
-    }
-    /// Number of extra iterations
-    inline int numberExtraIterations() const {
-        return numberExtraIterations_;
-    }
-    /// Increment strong info
-    void incrementStrongInfo(int numberTimes, int numberIterations,
-                             int numberFixed, bool ifInfeasible);
-    /// Return strong info
-    inline const int * strongInfo() const {
-        return strongInfo_;
-    }
-
-    /// Return mutable strong info
-    inline int * mutableStrongInfo() {
-        return strongInfo_;
-    }
-    /// Get stored row cuts for donor/recipient CbcModel
-    CglStored * storedRowCuts() const {
-        return storedRowCuts_;
-    }
-    /// Set stored row cuts for donor/recipient CbcModel
-    void setStoredRowCuts(CglStored * cuts) {
-        storedRowCuts_ = cuts;
-    }
-    /// Says whether all dynamic integers
-    inline bool allDynamic () const {
-        return ((ownership_&0x40000000) != 0) ;
-    }
-    /// Create C++ lines to get to current state
-    void generateCpp( FILE * fp, int options);
-    /// Generate an OsiBranchingInformation object
-    OsiBranchingInformation usefulInformation() const;
-    /** Warm start object produced by heuristic or strong branching
-
-        If get a valid integer solution outside branch and bound then it can take
-        a reasonable time to solve LP which produces clean solution.  If this object has
-        any size then it will be used in solve.
-    */
-    inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) {
-        bestSolutionBasis_ = bestSolutionBasis;
-    }
-    /// Redo walkback arrays
-    void redoWalkBack();
-    //@}
-    
-    void setMIPStart( const std::vector< std::pair< std::string, double > > &mips ) {
-       this->mipStart_ = mips;
-    }
-
-    const std::vector< std::pair< std::string, double > > &getMIPStart() {
-       return this->mipStart_;
-    }
-
-
-//---------------------------------------------------------------------------
-
-private:
-    ///@name Private member data
-    //@{
-
-    /// The solver associated with this model.
-    OsiSolverInterface * solver_;
-
-    /** Ownership of objects and other stuff
-
-        0x80000000 model owns solver
-        0x40000000 all variables CbcDynamicPseudoCost
-    */
-    unsigned int ownership_ ;
-
-    /// A copy of the solver, taken at the continuous (root) node.
-    OsiSolverInterface * continuousSolver_;
-
-    /// A copy of the solver, taken at constructor or by saveReferenceSolver
-    OsiSolverInterface * referenceSolver_;
-
-    /// Message handler
-    CoinMessageHandler * handler_;
-
-    /** Flag to say if handler_ is the default handler.
-
-      The default handler is deleted when the model is deleted. Other
-      handlers (supplied by the client) will not be deleted.
-    */
-    bool defaultHandler_;
-
-    /// Cbc messages
-    CoinMessages messages_;
-
-    /// Array for integer parameters
-    int intParam_[CbcLastIntParam];
-
-    /// Array for double parameters
-    double dblParam_[CbcLastDblParam];
-
-    /** Pointer to an empty warm start object
-
-      It turns out to be useful to have this available as a base from
-      which to build custom warm start objects. This is typed as CoinWarmStart
-      rather than CoinWarmStartBasis to allow for the possibility that a
-      client might want to apply a solver that doesn't use a basis-based warm
-      start. See getEmptyBasis for an example of how this field can be used.
-    */
-    mutable CoinWarmStart *emptyWarmStart_ ;
-
-    /// Best objective
-    double bestObjective_;
-    /// Best possible objective
-    double bestPossibleObjective_;
-    /// Sum of Changes to objective by first solve
-    double sumChangeObjective1_;
-    /// Sum of Changes to objective by subsequent solves
-    double sumChangeObjective2_;
-
-    /// Array holding the incumbent (best) solution.
-    double * bestSolution_;
-    /// Arrays holding other solutions.
-    double ** savedSolutions_;
-
-    /** Array holding the current solution.
-
-      This array is used more as a temporary.
-    */
-    double * currentSolution_;
-    /** For testing infeasibilities - will point to
-        currentSolution_ or solver-->getColSolution()
-    */
-    mutable const double * testSolution_;
-    /** MIPstart values
-      values for integer variables which will be converted to a complete integer initial feasible solution
-    */
-    std::vector< std::pair< std::string, double > > mipStart_;
-     /** Warm start object produced by heuristic or strong branching
-
-        If get a valid integer solution outside branch and bound then it can take
-        a reasonable time to solve LP which produces clean solution.  If this object has
-        any size then it will be used in solve.
-    */
-    CoinWarmStartBasis bestSolutionBasis_ ;
-    /// Global cuts
-    CbcRowCuts globalCuts_;
-    /// Global conflict cuts
-    CbcRowCuts * globalConflictCuts_;
-
-    /// Minimum degradation in objective value to continue cut generation
-    double minimumDrop_;
-    /// Number of solutions
-    int numberSolutions_;
-    /// Number of saved solutions
-    int numberSavedSolutions_;
-    /// Maximum number of saved solutions
-    int maximumSavedSolutions_;
-    /** State of search
-        0 - no solution
-        1 - only heuristic solutions
-        2 - branched to a solution
-        3 - no solution but many nodes
-    */
-    int stateOfSearch_;
-    /// At which depths to do cuts
-    int whenCuts_;
-    /// Hotstart solution
-    double * hotstartSolution_;
-    /// Hotstart priorities
-    int * hotstartPriorities_;
-    /// Number of heuristic solutions
-    int numberHeuristicSolutions_;
-    /// Cumulative number of nodes
-    int numberNodes_;
-    /** Cumulative number of nodes for statistics.
-        Must fix to match up
-    */
-    int numberNodes2_;
-    /// Cumulative number of iterations
-    int numberIterations_;
-    /// Cumulative number of solves
-    int numberSolves_;
-    /// Status of problem - 0 finished, 1 stopped, 2 difficulties
-    int status_;
-    /** Secondary status of problem
-        -1 unset (status_ will also be -1)
-        0 search completed with solution
-        1 linear relaxation not feasible (or worse than cutoff)
-        2 stopped on gap
-        3 stopped on nodes
-        4 stopped on time
-        5 stopped on user event
-        6 stopped on solutions
-     */
-    int secondaryStatus_;
-    /// Number of integers in problem
-    int numberIntegers_;
-    /// Number of rows at continuous
-    int numberRowsAtContinuous_;
-    /**
-       -1 - cutoff as constraint not activated
-       -2 - waiting to activate
-       >=0 - activated
-     */
-    int cutoffRowNumber_;
-    /// Maximum number of cuts
-    int maximumNumberCuts_;
-    /** Current phase (so heuristics etc etc can find out).
-        0 - initial solve
-        1 - solve with cuts at root
-        2 - solve with cuts
-        3 - other e.g. strong branching
-        4 - trying to validate a solution
-        5 - at end of search
-    */
-    int phase_;
-
-    /// Number of entries in #addedCuts_
-    int currentNumberCuts_;
-
-    /** Current limit on search tree depth
-
-      The allocated size of #walkback_. Increased as needed.
-    */
-    int maximumDepth_;
-    /** Array used to assemble the path between a node and the search tree root
-
-      The array is resized when necessary. #maximumDepth_  is the current
-      allocated size.
-    */
-    CbcNodeInfo ** walkback_;
-    CbcNodeInfo ** lastNodeInfo_;
-    const OsiRowCut ** lastCut_;
-    int lastDepth_;
-    int lastNumberCuts2_;
-    int maximumCuts_;
-    int * lastNumberCuts_;
-
-    /** The list of cuts initially collected for this subproblem
-
-      When the subproblem at this node is rebuilt, a set of cuts is collected
-      for inclusion in the constraint system. If any of these cuts are
-      subsequently removed because they have become loose, the corresponding
-      entry is set to NULL.
-    */
-    CbcCountRowCut ** addedCuts_;
-
-    /** A pointer to a row cut which will be added instead of normal branching.
-        After use it should be set to NULL.
-    */
-    OsiRowCut * nextRowCut_;
-
-    /// Current node so can be used elsewhere
-    CbcNode * currentNode_;
-
-    /// Indices of integer variables
-    int * integerVariable_;
-    /// Whether of not integer
-    char * integerInfo_;
-    /// Holds solution at continuous (after cuts)
-    double * continuousSolution_;
-    /// Array marked whenever a solution is found if non-zero
-    int * usedInSolution_;
-    /**
-        Special options
-        0 bit (1) - check if cuts valid (if on debugger list)
-        1 bit (2) - use current basis to check integer solution (rather than all slack)
-        2 bit (4) - don't check integer solution (by solving LP)
-        3 bit (8) - fast analyze
-        4 bit (16) - non-linear model - so no well defined CoinPackedMatrix
-        5 bit (32) - keep names
-        6 bit (64) - try for dominated columns
-        7 bit (128) - SOS type 1 but all declared integer
-        8 bit (256) - Set to say solution just found, unset by doing cuts
-        9 bit (512) - Try reduced model after 100 nodes
-        10 bit (1024) - Switch on some heuristics even if seems unlikely
-        11 bit (2048) - Mark as in small branch and bound
-        12 bit (4096) - Funny cuts so do slow way (in some places)
-        13 bit (8192) - Funny cuts so do slow way (in other places)
-        14 bit (16384) - Use Cplex! for fathoming
-        15 bit (32768) - Try reduced model after 0 nodes
-        16 bit (65536) - Original model had integer bounds
-        17 bit (131072) - Perturbation switched off
-        18 bit (262144) - donor CbcModel
-        19 bit (524288) - recipient CbcModel
-        20 bit (1048576) - waiting for sub model to return
-	22 bit (4194304) - do not initialize random seed in solver (user has)
-	23 bit (8388608) - leave solver_ with cuts
-	24 bit (16777216) - just get feasible if no cutoff
-    */
-    int specialOptions_;
-    /** More special options
-        at present bottom 6 bits used for shadow price mode
-        1024 for experimental hotstart
-        2048,4096 breaking out of cuts
-        8192 slowly increase minimum drop
-        16384 gomory
-	32768 more heuristics in sub trees
-	65536 no cuts in preprocessing
-        131072 Time limits elapsed
-        18 bit (262144) - Perturb fathom nodes
-        19 bit (524288) - No limit on fathom nodes
-        20 bit (1048576) - Reduce sum of infeasibilities before cuts
-        21 bit (2097152) - Reduce sum of infeasibilities after cuts
-    */
-    int moreSpecialOptions_;
-    /** More more special options
-	0 bit (1) - find switching variables
-	1 bit (2) - using fake objective until solution
-	2 bit (4) - switching variables exist
-	3 bit (8) - skip most of setBestSolution checks
-	4 bit (16) - very lightweight preprocessing in smallB&B
-	5 bit (32) - event handler needs to be cloned when parallel
-	6 bit (64) - testing - use probing to make cliques
-	7/8 bit (128) - try orbital branching (if nauty)
-	9 bit (512) - branching on objective (later)
-	10 bit (1024) - branching on constraints (later)
-	11/12 bit 2048 - intermittent cuts
-    */
-    int moreSpecialOptions2_;
-    /// User node comparison function
-    CbcCompareBase * nodeCompare_;
-    /// User feasibility function (see CbcFeasibleBase.hpp)
-    CbcFeasibilityBase * problemFeasibility_;
-    /// Tree
-    CbcTree * tree_;
-    /// Pointer to top of tree
-    CbcFullNodeInfo * topOfTree_;
-    /// A pointer to model to be used for subtrees
-    CbcModel * subTreeModel_;
-    /// A pointer to model from CbcHeuristic
-    CbcModel * heuristicModel_;
-    /// Number of times any subtree stopped on nodes, time etc
-    int numberStoppedSubTrees_;
-    /// Variable selection function
-    CbcBranchDecision * branchingMethod_;
-    /// Cut modifier function
-    CbcCutModifier * cutModifier_;
-    /// Strategy
-    CbcStrategy * strategy_;
-    /// Parent model
-    CbcModel * parentModel_;
-    /** Whether to automatically do presolve before branch and bound.
-        0 - no
-        1 - ordinary presolve
-        2 - integer presolve (dodgy)
-    */
-    /// Pointer to array[getNumCols()] (for speed) of column lower bounds
-    const double * cbcColLower_;
-    /// Pointer to array[getNumCols()] (for speed) of column upper bounds
-    const double * cbcColUpper_;
-    /// Pointer to array[getNumRows()] (for speed) of row lower bounds
-    const double * cbcRowLower_;
-    /// Pointer to array[getNumRows()] (for speed) of row upper bounds
-    const double * cbcRowUpper_;
-    /// Pointer to array[getNumCols()] (for speed) of primal solution vector
-    const double * cbcColSolution_;
-    /// Pointer to array[getNumRows()] (for speed) of dual prices
-    const double * cbcRowPrice_;
-    /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
-    const double * cbcReducedCost_;
-    /// Pointer to array[getNumRows()] (for speed) of row activity levels.
-    const double * cbcRowActivity_;
-    /// Pointer to user-defined data structure
-    void * appData_;
-    /// Presolve for CbcTreeLocal
-    int presolve_;
-    /** Maximum number of candidates to consider for strong branching.
-      To disable strong branching, set this to 0.
-    */
-    int numberStrong_;
-    /** \brief The number of branches before pseudo costs believed
-           in dynamic strong branching.
-
-      A value of 0 is  off.
-    */
-    int numberBeforeTrust_;
-    /** \brief The number of variables for which to compute penalties
-           in dynamic strong branching.
-    */
-    int numberPenalties_;
-    /// For threads - stop after this many "iterations"
-    int stopNumberIterations_;
-    /** Scale factor to make penalties match strong.
-        Should/will be computed */
-    double penaltyScaleFactor_;
-    /// Number of analyze iterations to do
-    int numberAnalyzeIterations_;
-    /// Arrays with analysis results
-    double * analyzeResults_;
-    /// Useful temporary pointer
-    void * temporaryPointer_;
-    /// Number of nodes infeasible by normal branching (before cuts)
-    int numberInfeasibleNodes_;
-    /** Problem type as set by user or found by analysis.  This will be extended
-        0 - not known
-        1 - Set partitioning <=
-        2 - Set partitioning ==
-        3 - Set covering
-    */
-    int problemType_;
-    /// Print frequency
-    int printFrequency_;
-    /// Number of cut generators
-    int numberCutGenerators_;
-    // Cut generators
-    CbcCutGenerator ** generator_;
-    // Cut generators before any changes
-    CbcCutGenerator ** virginGenerator_;
-    /// Number of heuristics
-    int numberHeuristics_;
-    /// Heuristic solvers
-    CbcHeuristic ** heuristic_;
-    /// Pointer to heuristic solver which found last solution (or NULL)
-    CbcHeuristic * lastHeuristic_;
-    /// Depth for fast nodes
-    int fastNodeDepth_;
-    /*! Pointer to the event handler */
-# ifdef CBC_ONLY_CLP
-    ClpEventHandler *eventHandler_ ;
-# else
-    CbcEventHandler *eventHandler_ ;
-# endif
-   /// Symmetry information
-    CbcSymmetry * symmetryInfo_;
-    /// Total number of objects
-    int numberObjects_;
-
-    /** \brief Integer and Clique and ... information
-
-      \note The code assumes that the first objects on the list will be
-        SimpleInteger objects for each integer variable, followed by
-        Clique objects. Portions of the code that understand Clique objects
-        will fail if they do not immediately follow the SimpleIntegers.
-        Large chunks of the code will fail if the first objects are not
-        SimpleInteger. As of 2003.08, SimpleIntegers and Cliques are the only
-        objects.
-    */
-    OsiObject ** object_;
-    /// Now we may not own objects - just point to solver's objects
-    bool ownObjects_;
-
-    /// Original columns as created by integerPresolve or preprocessing
-    int * originalColumns_;
-    /// How often to scan global cuts
-    int howOftenGlobalScan_;
-    /** Number of times global cuts violated.  When global cut pool then this
-        should be kept for each cut and type of cut */
-    int numberGlobalViolations_;
-    /// Number of extra iterations in fast lp
-    int numberExtraIterations_;
-    /// Number of extra nodes in fast lp
-    int numberExtraNodes_;
-    /// Number of times fast lp entered
-    int numberFathoms_;
-    /** Value of objective at continuous
-        (Well actually after initial round of cuts)
-    */
-    double continuousObjective_;
-    /** Value of objective before root node cuts added
-    */
-    double originalContinuousObjective_;
-    /// Number of infeasibilities at continuous
-    int continuousInfeasibilities_;
-    /// Maximum number of cut passes at root
-    int maximumCutPassesAtRoot_;
-    /// Maximum number of cut passes
-    int maximumCutPasses_;
-    /// Preferred way of branching
-    int preferredWay_;
-    /// Current cut pass number
-    int currentPassNumber_;
-    /// Maximum number of cuts (for whichGenerator_)
-    int maximumWhich_;
-    /// Maximum number of rows
-    int maximumRows_;
-    /// Random seed
-    int randomSeed_;
-    /// Multiple root tries
-    int multipleRootTries_;
-    /// Current depth
-    int currentDepth_;
-    /// Thread specific random number generator
-    mutable CoinThreadRandom randomNumberGenerator_;
-    /// Work basis for temporary use
-    CoinWarmStartBasis workingBasis_;
-    /// Which cut generator generated this cut
-    int * whichGenerator_;
-    /// Maximum number of statistics
-    int maximumStatistics_;
-    /// statistics
-    CbcStatistics ** statistics_;
-    /// Maximum depth reached
-    int maximumDepthActual_;
-    /// Number of reduced cost fixings
-    double numberDJFixed_;
-    /// Probing info
-    CglTreeProbingInfo * probingInfo_;
-    /// Number of fixed by analyze at root
-    int numberFixedAtRoot_;
-    /// Number fixed by analyze so far
-    int numberFixedNow_;
-    /// Whether stopping on gap
-    bool stoppedOnGap_;
-    /// Whether event happened
-    mutable bool eventHappened_;
-    /// Number of long strong goes
-    int numberLongStrong_;
-    /// Number of old active cuts
-    int numberOldActiveCuts_;
-    /// Number of new cuts
-    int numberNewCuts_;
-    /// Strategy worked out - mainly at root node
-    int searchStrategy_;
-    /** Strategy for strong branching
-	0 - normal
-	when to do all fractional
-	1 - root node
-	2 - depth less than modifier
-	4 - if objective == best possible
-	6 - as 2+4 
-	when to do all including satisfied
-	10 - root node etc.
-	If >=100 then do when depth <= strategy/100 (otherwise 5)
-     */
-    int strongStrategy_;
-    /// Number of iterations in strong branching
-    int numberStrongIterations_;
-    /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible
-        Second group of three is a snapshot at node [6] */
-    int strongInfo_[7];
-    /**
-        For advanced applications you may wish to modify the behavior of Cbc
-        e.g. if the solver is a NLP solver then you may not have an exact
-        optimum solution at each step.  This gives characteristics - just for one BAB.
-        For actually saving/restoring a solution you need the actual solver one.
-    */
-    OsiBabSolver * solverCharacteristics_;
-    /// Whether to force a resolve after takeOffCuts
-    bool resolveAfterTakeOffCuts_;
-    /// Maximum number of iterations (designed to be used in heuristics)
-    int maximumNumberIterations_;
-    /// Anything with priority >= this can be treated as continuous
-    int continuousPriority_;
-    /// Number of outstanding update information items
-    int numberUpdateItems_;
-    /// Maximum number of outstanding update information items
-    int maximumNumberUpdateItems_;
-    /// Update items
-    CbcObjectUpdateData * updateItems_;
-    /// Stored row cuts for donor/recipient CbcModel
-    CglStored * storedRowCuts_;
-    /**
-       Parallel
-       0 - off
-       1 - testing
-       2-99 threads
-       other special meanings
-    */
-    int numberThreads_;
-    /** thread mode
-        always use numberThreads for branching
-        1 set then deterministic
-        2 set then use numberThreads for root cuts
-        4 set then use numberThreads in root mini branch and bound
-        default is 0
-    */
-    int threadMode_;
-    /// Number of global cuts on entry to a node
-    int numberGlobalCutsIn_;
-    /// Thread stuff for master
-    CbcBaseModel * master_;
-    /// Pointer to masterthread
-    CbcThread * masterThread_;
-//@}
-};
-/// So we can use osiObject or CbcObject during transition
-void getIntegerInformation(const OsiObject * object, double & originalLower,
-                           double & originalUpper) ;
-// So we can call from other programs
-// Real main program
-class OsiClpSolverInterface;
-int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
-int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
-// four ways of calling
-int callCbc(const char * input2, OsiClpSolverInterface& solver1);
-int callCbc(const char * input2);
-int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
-int callCbc(const std::string input2) ;
-// When we want to load up CbcModel with options first
-void CbcMain0 (CbcModel & babSolver);
-int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
-// two ways of calling
-int callCbc(const char * input2, CbcModel & babSolver);
-int callCbc(const std::string input2, CbcModel & babSolver);
-// And when CbcMain0 already called to initialize
-int callCbc1(const char * input2, CbcModel & babSolver);
-int callCbc1(const std::string input2, CbcModel & babSolver);
-// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
-int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
-int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
-int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
-// For uniform setting of cut and heuristic options
-void setCutAndHeuristicOptions(CbcModel & model);
-#endif
-