casadi 3.7.2__cp314-none-win_amd64.whl

casadi/include/coin/CbcModel.hpp

@@ -0,0 +1,3296 @@
+/* $Id$ */
+// 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
+  /// Returns CglPreProcess used before branch and bound
+  inline CglPreProcess *preProcess() const
+  {
+    return preProcess_;
+  }
+  /// Set CglPreProcess used before branch and bound
+  inline void setPreProcess(CglPreProcess *preProcess)
+  {
+    preProcess_ = preProcess;
+  }
+  /// 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();
+  /** Returns postProcessed solution in solver(called from event handler)
+     Normally used for integer solution (not really tested otherwise)
+    solutionType 1 is best integer so far, 0 is current solution 
+    (may not be integer) */
+  const OsiSolverInterface *postProcessedSolver(int solutionType = 1);
+
+  /**
+      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();
+  /**
+       Clean model i.e. make SOS/integer variables exactly at bound if needed.
+       Only if moreSpecialOptions2_ 15 bit set (32768) as there is a small 
+       overhead (more2 in standalone cbc).
+       Fine tuning can be done in configure with -DCLEAN_INTEGER_VARIABLES
+       and -DZERO_ODD_TOLERANCE=1.0e-nn
+       If CLEAN_INTEGER_VARIABLES not defined then cleaning is only done for 
+       SOS variables.
+       If ZERO_ODD_TOLERANCE not defined then 1.0e-14 used.  You can define as 
+       0.0 if you are paranoid. 
+       Returns number of variables forced out
+       cleanVariables array will be used if exists
+     */
+  int cleanBounds(OsiSolverInterface *solver, char *cleanVariables);
+  /// Sets up cleanVariables array (i.e. ones to be careful about)
+  char *setupCleanVariables();
+  //@}
+
+  /** \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);
+  /** Add SOS info to solver -
+	Overwrites SOS information in solver with information
+	in CbcModel.  Has no effect with some solvers. 
+	Also updates integer info. */
+  void addSOSEtcToSolver();
+
+#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();
+  }
+   /// Return true if model flipped to make minimize (for printing)
+  inline bool modelFlipped() const
+  {
+    return (moreSpecialOptions2_&67108864)!=0;
+  }
+  /// Return objective function value with sign corrected
+  inline double trueObjValue(double value) const
+  {
+    return (moreSpecialOptions2_&67108864)==0 ? value : -value;
+  }
+  inline double trueBestObjValue() const
+  {
+    return (moreSpecialOptions2_&67108864)==0 ? bestObjective_ : -bestObjective_;
+  }
+  /// Return cutoff value with sign corrected
+  inline double trueCutoff() const
+  {
+    return (moreSpecialOptions2_&67108864)==0 ?
+      dblParam_[CbcCurrentCutoff] : -dblParam_[CbcCurrentCutoff]; 
+  }
+
+  /// 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
+	25 bit (33554432) - feasibility pump after root cuts
+	26 bit (67108864) - child model but going for complete search
+    */
+  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)
+	15 bit 32768 - take care of very very small values for Integer/SOS variables
+	24 bit (67108864) - model has been flipped
+    */
+  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;
+  /**
+       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();
+  /** 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);
+
+  /** 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);
+  /// 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_;
+  }
+  /// Delete a node and possibly null out currentNode_
+  void deleteNode(CbcNode * node);
+  /// 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 symmetry information
+  inline void setSymmetryInfo(CbcSymmetry * info)
+  {
+    symmetryInfo_ = info;
+  }
+  /// get rid of all
+  void zapSymmetry();
+  /// Root symmetry information
+  inline CbcSymmetry *rootSymmetryInfo() const
+  {
+    return rootSymmetryInfo_;
+  }
+  /// 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 > > &mipstart)
+  {
+    this->mipStart_ = mipstart;
+  }
+
+  /** if original column names will be preserved in preprocessed problem
+   */
+  void setKeepNamesPreproc( bool _keep ) 
+  {
+    this->keepNamesPreproc = _keep;
+  }
+
+  bool getKeepNamesPreproc() const 
+  {
+    return keepNamesPreproc;
+  }
+
+  /** may be safer to use this overload method: c++ string libraries 
+     * implementation may not be binary compatible */
+  void setMIPStart(int count, const char **colNames, const double colValues[]);
+
+
+  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_;
+
+  /** keepNamesPreproc
+   *  if variables names will be preserved in the pre-processed problem
+   *  (usefull in callbacks)
+   **/
+  bool keepNamesPreproc;
+
+  /** 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_;
+  /// preProcess used before branch and bound (optional)
+  CglPreProcess *preProcess_;
+  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_;
+  /// Root symmetry information
+  CbcSymmetry *rootSymmetryInfo_;
+  /// 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[], 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 (with call back) (see CbcMain1 for whereFrom)
+int callCbc1(const char *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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/