source: stable/2.8/Cbc/src/CbcModel.hpp @ 2023

/* $Id: CbcModel.hpp 2023 2014-03-25 12:59:22Z forrest $ */
// 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 CbcFeasibilityBase;
class CbcStatistics;
class CbcFullNodeInfo;
class CbcEventHandler ;
class CglPreProcess;
class OsiClpSolverInterface;
class ClpNodeStuff;

// #define CBC_CHECK_BASIS 1

//#############################################################################

/** Simple Branch and bound class

  The initialSolve() method solves the initial LP relaxation of the MIP
  problem. The branchAndBound() method can then be called to finish using
  a branch and cut algorithm.

  <h3>Search Tree Traversal</h3>

  Subproblems (aka nodes) requiring additional evaluation are stored using
  the CbcNode and CbcNodeInfo objects. Ancestry linkage is maintained in the
  CbcNodeInfo object. Evaluation of a subproblem within branchAndBound()
  proceeds as follows:
  <ul>
    <li> The node representing the most promising parent subproblem is popped
         from the heap which holds the set of subproblems requiring further
         evaluation.
    <li> Using branching instructions stored in the node, and information in
         its ancestors, the model and solver are adjusted to create the
         active subproblem.
    <li> If the parent subproblem will require further evaluation
         (<i>i.e.</i>, there are branches remaining) its node is pushed back
         on the heap. Otherwise, the node is deleted.  This may trigger
         recursive deletion of ancestors.
    <li> The newly created subproblem is evaluated.
    <li> If the subproblem requires further evaluation, a node is created.
         All information needed to recreate the subproblem (branching
         information, row and column cuts) is placed in the node and the node
         is added to the set of subproblems awaiting further evaluation.
  </ul>
  Note that there is never a node representing the active subproblem; the model
  and solver represent the active subproblem.

  <h3>Row (Constraint) Cut Handling</h3>

  For a typical subproblem, the sequence of events is as follows:
  <ul>
    <li> The subproblem is rebuilt for further evaluation: One result of a
         call to addCuts() is a traversal of ancestors, leaving a list of all
         cuts used in the ancestors in #addedCuts_. This list is then scanned
         to construct a basis that includes only tight cuts. Entries for
         loose cuts are set to NULL.
    <li> The subproblem is evaluated: One result of a call to solveWithCuts()
         is the return of a set of newly generated cuts for the subproblem.
         #addedCuts_ is also kept up-to-date as old cuts become loose.
    <li> The subproblem is stored for further processing: A call to
         CbcNodeInfo::addCuts() adds the newly generated cuts to the
         CbcNodeInfo object associated with this node.
  </ul>
  See CbcCountRowCut for details of the bookkeeping associated with cut
  management.
*/

class CbcModel  {

public:

    enum CbcIntParam {
        /** The maximum number of nodes before terminating */
        CbcMaxNumNode = 0,
        /** The maximum number of solutions before terminating */
        CbcMaxNumSol,
        /** Fathoming discipline

          Controls objective function comparisons for purposes of fathoming by bound
          or determining monotonic variables.

          If 1, action is taken only when the current objective is strictly worse
          than the target. Implementation is handled by adding a small tolerance to
          the target.
        */
        CbcFathomDiscipline,
        /** Adjusts printout
            1 does different node message with number unsatisfied on last branch
        */
        CbcPrinting,
        /** Number of branches (may be more than number of nodes as may
            include strong branching) */
        CbcNumberBranches,
        /** Just a marker, so that a static sized array can store parameters. */
        CbcLastIntParam
    };

    enum CbcDblParam {
        /** The maximum amount the value of an integer variable can vary from
            integer and still be considered feasible. */
        CbcIntegerTolerance = 0,
        /** The objective is assumed to worsen by this amount for each
            integer infeasibility. */
        CbcInfeasibilityWeight,
        /** The amount by which to tighten the objective function cutoff when
            a new solution is discovered. */
        CbcCutoffIncrement,
        /** Stop when the gap between the objective value of the best known solution
          and the best bound on the objective of any solution is less than this.

          This is an absolute value. Conversion from a percentage is left to the
          client.
        */
        CbcAllowableGap,
        /** Stop when the gap between the objective value of the best known solution
          and the best bound on the objective of any solution is less than this
          fraction of of the absolute value of best known solution.

          Code stops if either this test or CbcAllowableGap test succeeds
        */
        CbcAllowableFractionGap,
        /** \brief The maximum number of seconds before terminating.
               A double should be adequate! */
        CbcMaximumSeconds,
        /// Cutoff - stored for speed
        CbcCurrentCutoff,
        /// Optimization direction - stored for speed
        CbcOptimizationDirection,
        /// Current objective value
        CbcCurrentObjectiveValue,
        /// Current minimization objective value
        CbcCurrentMinimizationObjectiveValue,
        /** \brief The time at start of model.
               So that other pieces of code can access */
        CbcStartSeconds,
        /** Stop doing heuristics when the gap between the objective value of the
            best known solution and the best bound on the objective of any solution
            is less than this.

          This is an absolute value. Conversion from a percentage is left to the
          client.
        */
        CbcHeuristicGap,
        /** Stop doing heuristics when the gap between the objective value of the
            best known solution and the best bound on the objective of any solution
            is less than this fraction of of the absolute value of best known
            solution.

          Code stops if either this test or CbcAllowableGap test succeeds
        */
        CbcHeuristicFractionGap,
        /// Smallest non-zero change on a branch
        CbcSmallestChange,
        /// Sum of non-zero changes on a branch
        CbcSumChange,
        /// Largest non-zero change on a branch
        CbcLargestChange,
        /// Small non-zero change on a branch to be used as guess
        CbcSmallChange,
        /** Just a marker, so that a static sized array can store parameters. */
        CbcLastDblParam
    };

    //---------------------------------------------------------------------------

public:
    ///@name Solve methods
    //@{
    /** \brief Solve the initial LP relaxation

      Invoke the solver's %initialSolve() method.
    */
    void initialSolve();

    /** \brief Invoke the branch \& cut algorithm

      The method assumes that initialSolve() has been called to solve the
      LP relaxation. It processes the root node, then proceeds to explore the
      branch & cut search tree. The search ends when the tree is exhausted or
      one of several execution limits is reached.
      If doStatistics is 1 summary statistics are printed
      if 2 then also the path to best solution (if found by branching)
      if 3 then also one line per node
    */
    void branchAndBound(int doStatistics = 0);
private:

    /** \brief Evaluate a subproblem using cutting planes and heuristics

      The method invokes a main loop which generates cuts, applies heuristics,
      and reoptimises using the solver's native %resolve() method.
      It returns true if the subproblem remains feasible at the end of the
      evaluation.
    */
    bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
    /** Generate one round of cuts - serial mode
      returns -
      0 - normal
      1 - must keep going
      2 - set numberTries to zero
      -1 - infeasible
    */
    int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    /** Generate one round of cuts - parallel mode
        returns -
        0 - normal
        1 - must keep going
        2 - set numberTries to zero
        -1 - infeasible
    */
    int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    /** Input one node output N nodes to put on tree and optional solution update
        This should be able to operate in parallel so is given a solver and is const(ish)
        However we will need to keep an array of solver_ and bases and more
        status is 0 for normal, 1 if solution
        Calling code should always push nodes back on tree
    */
    CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
                            int & numberNodesOutput, int & status) ;
    /// Update size of whichGenerator
    void resizeWhichGenerator(int numberNow, int numberAfter);
public:
#ifdef CBC_KEEP_DEPRECATED
    // See if anyone is using these any more!!
    /** \brief create a clean model from partially fixed problem

      The method creates a new model with given bounds and with no tree.
    */
    CbcModel *  cleanModel(const double * lower, const double * upper);
    /** \brief Invoke the branch \& cut algorithm on partially fixed problem

      The method presolves the given model and does branch and cut. The search
      ends when the tree is exhausted or maximum nodes is reached.

      If better solution found then it is saved.

      Returns 0 if search completed and solution, 1 if not completed and solution,
      2 if completed and no solution, 3 if not completed and no solution.

      Normally okay to do cleanModel immediately followed by subBranchandBound
      (== other form of subBranchAndBound)
      but may need to get at model for advanced features.

      Deletes model2
    */
    int subBranchAndBound(CbcModel * model2,
                          CbcModel * presolvedModel,
                          int maximumNodes);
    /** \brief Invoke the branch \& cut algorithm on partially fixed problem

      The method creates a new model with given bounds, presolves it
      then proceeds to explore the branch & cut search tree. The search
      ends when the tree is exhausted or maximum nodes is reached.

      If better solution found then it is saved.

      Returns 0 if search completed and solution, 1 if not completed and solution,
      2 if completed and no solution, 3 if not completed and no solution.

      This is just subModel immediately followed by other version of
      subBranchandBound.

    */
    int subBranchAndBound(const double * lower, const double * upper,
                          int maximumNodes);

    /** \brief Process root node and return a strengthened model

      The method assumes that initialSolve() has been called to solve the
      LP relaxation. It processes the root node and then returns a pointer
      to the strengthened model (or NULL if infeasible)
    */
    OsiSolverInterface *  strengthenedModel();
    /** preProcess problem - replacing solver
        If makeEquality true then <= cliques converted to ==.
        Presolve will be done numberPasses times.

        Returns NULL if infeasible

        If makeEquality is 1 add slacks to get cliques,
        if 2 add slacks to get sos (but only if looks plausible) and keep sos info
    */
    CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5,
                                int tuning = 5);
    /** Does postprocessing - original solver back.
        User has to delete process */
    void postProcess(CglPreProcess * process);
#endif
    /// Adds an update information object
    void addUpdateInformation(const CbcObjectUpdateData & data);
    /** Do one node - broken out for clarity?
        also for parallel (when baseModel!=this)
        Returns 1 if solution found
        node NULL on return if no branches left
        newNode NULL if no new node created
    */
    int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);

public:
    /** \brief Reoptimise an LP relaxation

      Invoke the solver's %resolve() method.
      whereFrom -
      0 - initial continuous
      1 - resolve on branch (before new cuts)
      2 - after new cuts
      3  - obsolete code or something modified problem in unexpected way
      10 - after strong branching has fixed variables at root
      11 - after strong branching has fixed variables in tree

      returns 1 feasible, 0 infeasible, -1 feasible but skip cuts
    */
    int resolve(CbcNodeInfo * parent, int whereFrom,
                double * saveSolution = NULL,
                double * saveLower = NULL,
                double * saveUpper = NULL);
    /// Make given rows (L or G) into global cuts and remove from lp
    void makeGlobalCuts(int numberRows, const int * which);
    /// Make given cut into a global cut
    void makeGlobalCut(const OsiRowCut * cut);
    /// Make given cut into a global cut
    void makeGlobalCut(const OsiRowCut & cut);
    /// Make given column cut into a global cut
    void makeGlobalCut(const OsiColCut * cut);
    /// Make given column cut into a global cut
    void makeGlobalCut(const OsiColCut & cut);
    /// Make partial cut into a global cut and save
  void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL);
    /// Make partial cuts into global cuts
    void makeGlobalCuts();
    /// Which cut generator generated this cut
    inline const int * whichGenerator() const
    { return whichGenerator_;}
    //@}

    /** \name Presolve methods */
    //@{

    /** Identify cliques and construct corresponding objects.

        Find cliques with size in the range
        [\p atLeastThisMany, \p lessThanThis] and construct corresponding
        CbcClique objects.
        If \p makeEquality is true then a new model may be returned if
        modifications had to be made, otherwise \c this is returned.
        If the problem is infeasible #numberObjects_ is set to -1.
        A client must use deleteObjects() before a second call to findCliques().
        If priorities exist, clique priority is set to the default.
    */
    CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
                           int lessThanThis, int defaultValue = 1000);

    /** Do integer presolve, creating a new (presolved) model.

      Returns the new model, or NULL if feasibility is lost.
      If weak is true then just does a normal presolve

      \todo It remains to work out the cleanest way of getting a solution to
            the original problem at the end. So this is very preliminary.
     */
    CbcModel * integerPresolve(bool weak = false);

    /** Do integer presolve, modifying the current model.

        Returns true if the model remains feasible after presolve.
    */
    bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false);


    /// Put back information into the original model after integer presolve.
    void originalModel(CbcModel * presolvedModel, bool weak);

    /** \brief For variables involved in VUB constraints, see if we can tighten
           bounds by solving lp's

        Returns false if feasibility is lost.
        If CglProbing is available, it will be tried as well to see if it can
        tighten bounds.
        This routine is just a front end for tightenVubs(int,const int*,double).

        If <tt>type = -1</tt> all variables are processed (could be very slow).
        If <tt>type = 0</tt> only variables involved in VUBs are processed.
        If <tt>type = n > 0</tt>, only the n most expensive VUB variables
        are processed, where it is assumed that x is at its maximum so delta
        would have to go to 1 (if x not at bound).

        If \p allowMultipleBinary is true, then a VUB constraint is a row with
        one continuous variable and any number of binary variables.

        If <tt>useCutoff < 1.0e30</tt>, the original objective is installed as a
        constraint with \p useCutoff as a bound.
    */
    bool tightenVubs(int type, bool allowMultipleBinary = false,
                     double useCutoff = 1.0e50);

    /** \brief For variables involved in VUB constraints, see if we can tighten
           bounds by solving lp's

      This version is just handed a list of variables to be processed.
    */
    bool tightenVubs(int numberVubs, const int * which,
                     double useCutoff = 1.0e50);
    /**
      Analyze problem to find a minimum change in the objective function.
    */
    void analyzeObjective();

    /**
      Add additional integers.
    */
    void AddIntegers();
    /**
      Save copy of the model.
    */
    void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);
    /**
      Flip direction of optimization on all models
    */
    void flipModel();

    //@}

    /** \name Object manipulation routines

      See OsiObject for an explanation of `object' in the context of CbcModel.
    */
    //@{

    /// Get the number of objects
    inline int numberObjects() const {
        return numberObjects_;
    }
    /// Set the number of objects
    inline void setNumberObjects(int number) {
        numberObjects_ = number;
    }

    /// Get the array of objects
    inline OsiObject ** objects() const {
        return object_;
    }

    /// Get the specified object
    const inline OsiObject * object(int which) const {
        return object_[which];
    }
    /// Get the specified object
    inline OsiObject * modifiableObject(int which) const {
        return object_[which];
    }

    void setOptionalInteger(int index);

    /// Delete all object information (and just back to integers if true)
    void deleteObjects(bool findIntegers = true);

    /** Add in object information.

      Objects are cloned; the owner can delete the originals.
    */
    void addObjects(int numberObjects, OsiObject ** objects);

    /** Add in object information.

      Objects are cloned; the owner can delete the originals.
    */
    void addObjects(int numberObjects, CbcObject ** objects);

    /// Ensure attached objects point to this model.
    void synchronizeModel() ;

    /** \brief Identify integer variables and create corresponding objects.

      Record integer variables and create an CbcSimpleInteger object for each
      one.
      If \p startAgain is true, a new scan is forced, overwriting any existing
      integer variable information.
      If type > 0 then 1==PseudoCost, 2 new ones low priority
    */

    void findIntegers(bool startAgain, int type = 0);

    //@}

    //---------------------------------------------------------------------------

    /**@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 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_;
    }
    /** Final status of problem
        Some of these can be found out by is...... functions
        -1 before branchAndBound
        0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found
        (or check value of best solution)
        1 stopped - on maxnodes, maxsols, maxtime
        2 difficulties so run was abandoned
        (5 event user programmed event occurred)
    */
    inline int status() const {
        return status_;
    }
    inline void setProblemStatus(int value) {
        status_ = value;
    }
    /** Secondary status of problem
        -1 unset (status_ will also be -1)
        0 search completed with solution
        1 linear relaxation not feasible (or worse than cutoff)
        2 stopped on gap
        3 stopped on nodes
        4 stopped on time
        5 stopped on user event
        6 stopped on solutions
        7 linear relaxation unbounded
        8 stopped on iteration limit
    */
    inline int secondaryStatus() const {
        return secondaryStatus_;
    }
    inline void setSecondaryStatus(int value) {
        secondaryStatus_ = value;
    }
    /// Are there numerical difficulties (for initialSolve) ?
    bool isInitialSolveAbandoned() const ;
    /// Is optimality proven (for initialSolve) ?
    bool isInitialSolveProvenOptimal() const ;
    /// Is primal infeasiblity proven (for initialSolve) ?
    bool isInitialSolveProvenPrimalInfeasible() const ;
    /// Is dual infeasiblity proven (for initialSolve) ?
    bool isInitialSolveProvenDualInfeasible() const ;

    //@}

    //---------------------------------------------------------------------------
    /**@name Problem information methods

       These methods call the solver's query routines to return
       information about the problem referred to by the current object.
       Querying a problem that has no data associated with it result in
       zeros for the number of rows and columns, and NULL pointers from
       the methods that return vectors.

       Const pointers returned from any data-query method are valid as
       long as the data is unchanged and the solver is not called.
    */
    //@{
    /// Number of rows in continuous (root) problem.
    inline int numberRowsAtContinuous() const {
        return numberRowsAtContinuous_;
    }

    /// Get number of columns
    inline int getNumCols() const {
        return solver_->getNumCols();
    }

    /// Get number of rows
    inline int getNumRows() const {
        return solver_->getNumRows();
    }

    /// Get number of nonzero elements
    inline CoinBigIndex getNumElements() const {
        return solver_->getNumElements();
    }

    /// Number of integers in problem
    inline int numberIntegers() const {
        return numberIntegers_;
    }
    // Integer variables
    inline const int * integerVariable() const {
        return integerVariable_;
    }
    /// Whether or not integer
    inline char integerType(int i) const {
        assert (integerInfo_);
        assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
        return integerInfo_[i];
    }
    /// Whether or not integer
    inline const char * integerType() const {
        return integerInfo_;
    }

    /// Get pointer to array[getNumCols()] of column lower bounds
    inline const double * getColLower() const {
        return solver_->getColLower();
    }

    /// Get pointer to array[getNumCols()] of column upper bounds
    inline const double * getColUpper() const {
        return solver_->getColUpper();
    }

    /** Get pointer to array[getNumRows()] of row constraint senses.
        <ul>
        <li>'L': <= constraint
        <li>'E': =  constraint
        <li>'G': >= constraint
        <li>'R': ranged constraint
        <li>'N': free constraint
        </ul>
    */
    inline const char * getRowSense() const {
        return solver_->getRowSense();
    }

    /** Get pointer to array[getNumRows()] of rows right-hand sides
        <ul>
        <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
        <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
        <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
        <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
        </ul>
    */
    inline const double * getRightHandSide() const {
        return solver_->getRightHandSide();
    }

    /** Get pointer to array[getNumRows()] of row ranges.
        <ul>
        <li> if rowsense()[i] == 'R' then
        rowrange()[i] == rowupper()[i] - rowlower()[i]
        <li> if rowsense()[i] != 'R' then
        rowrange()[i] is 0.0
        </ul>
    */
    inline const double * getRowRange() const {
        return solver_->getRowRange();
    }

    /// Get pointer to array[getNumRows()] of row lower bounds
    inline const double * getRowLower() const {
        return solver_->getRowLower();
    }

    /// Get pointer to array[getNumRows()] of row upper bounds
    inline const double * getRowUpper() const {
        return solver_->getRowUpper();
    }

    /// Get pointer to array[getNumCols()] of objective function coefficients
    inline const double * getObjCoefficients() const {
        return solver_->getObjCoefficients();
    }

    /// Get objective function sense (1 for min (default), -1 for max)
    inline double getObjSense() const {
        //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
        return dblParam_[CbcOptimizationDirection];
    }

    /// Return true if variable is continuous
    inline bool isContinuous(int colIndex) const {
        return solver_->isContinuous(colIndex);
    }

    /// Return true if variable is binary
    inline bool isBinary(int colIndex) const {
        return solver_->isBinary(colIndex);
    }

    /** Return true if column is integer.
        Note: This function returns true if the the column
        is binary or a general integer.
    */
    inline bool isInteger(int colIndex) const {
        return solver_->isInteger(colIndex);
    }

    /// Return true if variable is general integer
    inline bool isIntegerNonBinary(int colIndex) const {
        return solver_->isIntegerNonBinary(colIndex);
    }

    /// Return true if variable is binary and not fixed at either bound
    inline bool isFreeBinary(int colIndex) const {
        return solver_->isFreeBinary(colIndex) ;
    }

    /// Get pointer to row-wise copy of matrix
    inline const CoinPackedMatrix * getMatrixByRow() const {
        return solver_->getMatrixByRow();
    }

    /// Get pointer to column-wise copy of matrix
    inline const CoinPackedMatrix * getMatrixByCol() const {
        return solver_->getMatrixByCol();
    }

    /// Get solver's value for infinity
    inline double getInfinity() const {
        return solver_->getInfinity();
    }
    /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
    inline const double * getCbcColLower() const {
        return cbcColLower_;
    }
    /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
    inline const double * getCbcColUpper() const {
        return cbcColUpper_;
    }
    /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
    inline const double * getCbcRowLower() const {
        return cbcRowLower_;
    }
    /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
    inline const double * getCbcRowUpper() const {
        return cbcRowUpper_;
    }
    /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
    inline const double * getCbcColSolution() const {
        return cbcColSolution_;
    }
    /// Get pointer to array[getNumRows()] (for speed) of dual prices
    inline const double * getCbcRowPrice() const {
        return cbcRowPrice_;
    }
    /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
    inline const double * getCbcReducedCost() const {
        return cbcReducedCost_;
    }
    /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
    inline const double * getCbcRowActivity() const {
        return cbcRowActivity_;
    }
    //@}


    /**@name Methods related to querying the solution */
    //@{
    /// Holds solution at continuous (after cuts if branchAndBound called)
    inline double * continuousSolution() const {
        return continuousSolution_;
    }
    /** Array marked whenever a solution is found if non-zero.
        Code marks if heuristic returns better so heuristic
        need only mark if it wants to on solutions which
        are worse than current */
    inline int * usedInSolution() const {
        return usedInSolution_;
    }
    /// Increases usedInSolution for nonzeros
    void incrementUsed(const double * solution);
    /// Record a new incumbent solution and update objectiveValue
    void setBestSolution(CBC_Message how,
                         double & objectiveValue, const double *solution,
                         int fixVariables = 0);
    /// Just update objectiveValue
    void setBestObjectiveValue( double objectiveValue);
    /// Deals with event handler and solution
    CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
            double objValue,
            const double * solution);

    /** Call this to really test if a valid solution can be feasible
        Solution is number columns in size.
        If fixVariables true then bounds of continuous solver updated.
        Returns objective value (worse than cutoff if not feasible)
        Previously computed objective value is now passed in (in case user does not do solve)
        virtual so user can override
    */
    virtual double checkSolution(double cutoff, double * solution,
                         int fixVariables, double originalObjValue);
    /** Test the current solution for feasiblility.

      Scan all objects for indications of infeasibility. This is broken down
      into simple integer infeasibility (\p numberIntegerInfeasibilities)
      and all other reports of infeasibility (\p numberObjectInfeasibilities).
    */
    bool feasibleSolution(int & numberIntegerInfeasibilities,
                          int & numberObjectInfeasibilities) const;

    /** Solution to the most recent lp relaxation.

      The solver's solution to the most recent lp relaxation.
    */

    inline double * currentSolution() const {
        return currentSolution_;
    }
    /** For testing infeasibilities - will point to
        currentSolution_ or solver-->getColSolution()
    */
    inline const double * testSolution() const {
        return testSolution_;
    }
    inline void setTestSolution(const double * solution) {
        testSolution_ = solution;
    }
    /// Make sure region there and optionally copy solution
    void reserveCurrentSolution(const double * solution = NULL);

    /// Get pointer to array[getNumCols()] of primal solution vector
    inline const double * getColSolution() const {
        return solver_->getColSolution();
    }

    /// Get pointer to array[getNumRows()] of dual prices
    inline const double * getRowPrice() const {
        return solver_->getRowPrice();
    }

    /// Get a pointer to array[getNumCols()] of reduced costs
    inline const double * getReducedCost() const {
        return solver_->getReducedCost();
    }

    /// Get pointer to array[getNumRows()] of row activity levels.
    inline const double * getRowActivity() const {
        return solver_->getRowActivity();
    }

    /// Get current objective function value
    inline double getCurrentObjValue() const {
        return dblParam_[CbcCurrentObjectiveValue];
    }
    /// Get current minimization objective function value
    inline double getCurrentMinimizationObjValue() const {
        return dblParam_[CbcCurrentMinimizationObjectiveValue];
    }

    /// Get best objective function value as minimization
    inline double getMinimizationObjValue() const {
        return bestObjective_;
    }
    /// Set best objective function value as minimization
    inline void setMinimizationObjValue(double value) {
        bestObjective_ = value;
    }

    /// Get best objective function value
    inline double getObjValue() const {
        return bestObjective_ * solver_->getObjSense() ;
    }
    /** Get best possible objective function value.
        This is better of best possible left on tree
        and best solution found.
        If called from within branch and cut may be optimistic.
    */
    double getBestPossibleObjValue() const;
    /// Set best objective function value
    inline void setObjValue(double value) {
        bestObjective_ = value * solver_->getObjSense() ;
    }
    /// Get solver objective function value (as minimization)
    inline double getSolverObjValue() const {
        return solver_->getObjValue() * solver_->getObjSense() ;
    }

    /** The best solution to the integer programming problem.

      The best solution to the integer programming problem found during
      the search. If no solution is found, the method returns null.
    */

    inline double * bestSolution() const {
        return bestSolution_;
    }
    /** User callable setBestSolution.
        If check false does not check valid
        If true then sees if feasible and warns if objective value
        worse than given (so just set to COIN_DBL_MAX if you don't care).
        If check true then does not save solution if not feasible
    */
    void setBestSolution(const double * solution, int numberColumns,
                         double objectiveValue, bool check = false);

    /// Get number of solutions
    inline int getSolutionCount() const {
        return numberSolutions_;
    }

    /// Set number of solutions (so heuristics will be different)
    inline void setSolutionCount(int value) {
        numberSolutions_ = value;
    }
    /// Number of saved solutions (including best)
    int numberSavedSolutions() const;
    /// Maximum number of extra saved solutions
    inline int maximumSavedSolutions() const {
        return maximumSavedSolutions_;
    }
    /// Set maximum number of extra saved solutions
    void setMaximumSavedSolutions(int value);
    /// Return a saved solution (0==best) - NULL if off end
    const double * savedSolution(int which) const;
    /// Return a saved solution objective (0==best) - COIN_DBL_MAX if off end
    double savedSolutionObjective(int which) const;
    /// Delete a saved solution and move others up
    void deleteSavedSolution(int which);

    /** Current phase (so heuristics etc etc can find out).
        0 - initial solve
        1 - solve with cuts at root
        2 - solve with cuts
        3 - other e.g. strong branching
        4 - trying to validate a solution
        5 - at end of search
    */
    inline int phase() const {
        return phase_;
    }

    /// Get number of heuristic solutions
    inline int getNumberHeuristicSolutions() const {
        return numberHeuristicSolutions_;
    }
    /// Set number of heuristic solutions
    inline void setNumberHeuristicSolutions(int value) {
        numberHeuristicSolutions_ = value;
    }

    /// Set objective function sense (1 for min (default), -1 for max,)
    inline void setObjSense(double s) {
        dblParam_[CbcOptimizationDirection] = s;
        solver_->setObjSense(s);
    }

    /// Value of objective at continuous
    inline double getContinuousObjective() const {
        return originalContinuousObjective_;
    }
    inline void setContinuousObjective(double value) {
        originalContinuousObjective_ = value;
    }
    /// Number of infeasibilities at continuous
    inline int getContinuousInfeasibilities() const {
        return continuousInfeasibilities_;
    }
    inline void setContinuousInfeasibilities(int value) {
        continuousInfeasibilities_ = value;
    }
    /// Value of objective after root node cuts added
    inline double rootObjectiveAfterCuts() const {
        return continuousObjective_;
    }
    /// Sum of Changes to objective by first solve
    inline double sumChangeObjective() const {
        return sumChangeObjective1_;
    }
    /** Number of times global cuts violated.  When global cut pool then this
        should be kept for each cut and type of cut */
    inline int numberGlobalViolations() const {
        return numberGlobalViolations_;
    }
    inline void clearNumberGlobalViolations() {
        numberGlobalViolations_ = 0;
    }
    /// Whether to force a resolve after takeOffCuts
    inline bool resolveAfterTakeOffCuts() const {
        return resolveAfterTakeOffCuts_;
    }
    inline void setResolveAfterTakeOffCuts(bool yesNo) {
        resolveAfterTakeOffCuts_ = yesNo;
    }
    /// Maximum number of rows
    inline int maximumRows() const {
        return maximumRows_;
    }
    /// Work basis for temporary use
    inline CoinWarmStartBasis & workingBasis() {
        return workingBasis_;
    }
    /// Get number of "iterations" to stop after
    inline int getStopNumberIterations() const {
        return stopNumberIterations_;
    }
    /// Set number of "iterations" to stop after
    inline void setStopNumberIterations(int value) {
        stopNumberIterations_ = value;
    }
    /// A pointer to model from CbcHeuristic
    inline CbcModel * heuristicModel() const
    { return heuristicModel_;}
    /// Set a pointer to model from CbcHeuristic
    inline void setHeuristicModel(CbcModel * model)
    { heuristicModel_ = model;}
    //@}

    /** \name Node selection */
    //@{
    // Comparison functions (which may be overridden by inheritance)
    inline CbcCompareBase * nodeComparison() const {
        return nodeCompare_;
    }
    void setNodeComparison(CbcCompareBase * compare);
    void setNodeComparison(CbcCompareBase & compare);
    //@}

    /** \name Problem feasibility checking */
    //@{
    // Feasibility functions (which may be overridden by inheritance)
    inline CbcFeasibilityBase * problemFeasibility() const {
        return problemFeasibility_;
    }
    void setProblemFeasibility(CbcFeasibilityBase * feasibility);
    void setProblemFeasibility(CbcFeasibilityBase & feasibility);
    //@}

    /** \name Tree methods and subtree methods */
    //@{
    /// Tree method e.g. heap (which may be overridden by inheritance)
    inline CbcTree * tree() const {
        return tree_;
    }
    /// For modifying tree handling (original is cloned)
    void passInTreeHandler(CbcTree & tree);
    /** For passing in an CbcModel to do a sub Tree (with derived tree handlers).
        Passed in model must exist for duration of branch and bound
    */
    void passInSubTreeModel(CbcModel & model);
    /** For retrieving a copy of subtree model with given OsiSolver.
        If no subtree model will use self (up to user to reset cutoff etc).
        If solver NULL uses current
    */
    CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
    /// Returns number of times any subtree stopped on nodes, time etc
    inline int numberStoppedSubTrees() const {
        return numberStoppedSubTrees_;
    }
    /// Says a sub tree was stopped
    inline void incrementSubTreeStopped() {
        numberStoppedSubTrees_++;
    }
    /** Whether to automatically do presolve before branch and bound (subTrees).
        0 - no
        1 - ordinary presolve
        2 - integer presolve (dodgy)
    */
    inline int typePresolve() const {
        return presolve_;
    }
    inline void setTypePresolve(int value) {
        presolve_ = value;
    }

    //@}

    /** \name Branching Decisions

      See the CbcBranchDecision class for additional information.
    */
    //@{

    /// Get the current branching decision method.
    inline CbcBranchDecision * branchingMethod() const {
        return branchingMethod_;
    }
    /// Set the branching decision method.
    inline void setBranchingMethod(CbcBranchDecision * method) {
        delete branchingMethod_;
        branchingMethod_ = method->clone();
    }
    /** Set the branching method

      \overload
    */
    inline void setBranchingMethod(CbcBranchDecision & method) {
        delete branchingMethod_;
        branchingMethod_ = method.clone();
    }
    /// Get the current cut modifier method
    inline CbcCutModifier * cutModifier() const {
        return cutModifier_;
    }
    /// Set the cut modifier method
    void setCutModifier(CbcCutModifier * modifier);
    /** Set the cut modifier method

      \overload
    */
    void setCutModifier(CbcCutModifier & modifier);
    //@}

    /** \name Row (constraint) and Column (variable) cut generation */
    //@{

    /** State of search
        0 - no solution
        1 - only heuristic solutions
        2 - branched to a solution
        3 - no solution but many nodes
    */
    inline int stateOfSearch() const {
        return stateOfSearch_;
    }
    inline void setStateOfSearch(int state) {
        stateOfSearch_ = state;
    }
    /// Strategy worked out - mainly at root node for use by CbcNode
    inline int searchStrategy() const {
        return searchStrategy_;
    }
    /// Set strategy worked out - mainly at root node for use by CbcNode
    inline void setSearchStrategy(int value) {
        searchStrategy_ = value;
    }
    /// Stong branching strategy
    inline int strongStrategy() const {
        return strongStrategy_;
    }
    /// Set strong branching strategy
    inline void setStrongStrategy(int value) {
        strongStrategy_ = value;
    }

    /// Get the number of cut generators
    inline int numberCutGenerators() const {
        return numberCutGenerators_;
    }
    /// Get the list of cut generators
    inline CbcCutGenerator ** cutGenerators() const {
        return generator_;
    }
    ///Get the specified cut generator
    inline CbcCutGenerator * cutGenerator(int i) const {
        return generator_[i];
    }
    ///Get the specified cut generator before any changes
    inline CbcCutGenerator * virginCutGenerator(int i) const {
        return virginGenerator_[i];
    }
    /** Add one generator - up to user to delete generators.
        howoften affects how generator is used. 0 or 1 means always,
        >1 means every that number of nodes.  Negative values have same
        meaning as positive but they may be switched off (-> -100) by code if
        not many cuts generated at continuous.  -99 is just done at root.
        Name is just for printout.
        If depth >0 overrides how often generator is called (if howOften==-1 or >0).
    */
    void addCutGenerator(CglCutGenerator * generator,
                         int howOften = 1, const char * name = NULL,
                         bool normal = true, bool atSolution = false,
                         bool infeasible = false, int howOftenInSub = -100,
                         int whatDepth = -1, int whatDepthInSub = -1);
//@}
    /** \name Strategy and sub models

      See the CbcStrategy class for additional information.
    */
    //@{

    /// Get the current strategy
    inline CbcStrategy * strategy() const {
        return strategy_;
    }
    /// Set the strategy. Clones
    void setStrategy(CbcStrategy & strategy);
    /// Set the strategy. assigns
    inline void setStrategy(CbcStrategy * strategy) {
        strategy_ = strategy;
    }
    /// Get the current parent model
    inline CbcModel * parentModel() const {
        return parentModel_;
    }
    /// Set the parent model
    inline void setParentModel(CbcModel & parentModel) {
        parentModel_ = &parentModel;
    }
    //@}


    /** \name Heuristics and priorities */
    //@{
    /*! \brief Add one heuristic - up to user to delete

      The name is just used for print messages.
    */
    void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
                      int before = -1);
    ///Get the specified heuristic
    inline CbcHeuristic * heuristic(int i) const {
        return heuristic_[i];
    }
    /// Get the number of heuristics
    inline int numberHeuristics() const {
        return numberHeuristics_;
    }
    /// Set the number of heuristics
    inline void setNumberHeuristics(int value) {
        numberHeuristics_ = value;
    }
    /// Pointer to heuristic solver which found last solution (or NULL)
    inline CbcHeuristic * lastHeuristic() const {
        return lastHeuristic_;
    }
    /// set last heuristic which found a solution
    inline void setLastHeuristic(CbcHeuristic * last) {
        lastHeuristic_ = last;
    }

    /** Pass in branching priorities.

        If ifClique then priorities are on cliques otherwise priorities are
        on integer variables.
        Other type (if exists set to default)
        1 is highest priority. (well actually -INT_MAX is but that's ugly)
        If hotstart > 0 then branches are created to force
        the variable to the value given by best solution.  This enables a
        sort of hot start.  The node choice should be greatest depth
        and hotstart should normally be switched off after a solution.

        If ifNotSimpleIntegers true then appended to normal integers

        This is now deprecated except for simple usage.  If user
        creates Cbcobjects then set priority in them

        \internal Added for Kurt Spielberg.
    */
    void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);

    /// Returns priority level for an object (or 1000 if no priorities exist)
    inline int priority(int sequence) const {
        return object_[sequence]->priority();
    }

    /*! \brief Set an event handler

      A clone of the handler passed as a parameter is stored in CbcModel.
    */
    void passInEventHandler(const CbcEventHandler *eventHandler) ;

    /*! \brief Retrieve a pointer to the event handler */
    inline CbcEventHandler* getEventHandler() const {
        return (eventHandler_) ;
    }

    //@}

    /**@name Setting/Accessing application data */
    //@{
    /** Set application data.

    This is a pointer that the application can store into and
    retrieve from the solver interface.
    This field is available for the application to optionally
    define and use.
    */
    void setApplicationData (void * appData);

    /// Get application data
    void * getApplicationData() const;
    /**
        For advanced applications you may wish to modify the behavior of Cbc
        e.g. if the solver is a NLP solver then you may not have an exact
        optimum solution at each step.  Information could be built into
        OsiSolverInterface but this is an alternative so that that interface
        does not have to be changed.  If something similar is useful to
        enough solvers then it could be migrated
        You can also pass in by using solver->setAuxiliaryInfo.
        You should do that if solver is odd - if solver is normal simplex
        then use this.
        NOTE - characteristics are not cloned
    */
    void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
    /// Get solver characteristics
    inline const OsiBabSolver * solverCharacteristics() const {
        return solverCharacteristics_;
    }
    //@}

    //---------------------------------------------------------------------------

    /**@name Message handling etc */
    //@{
    /// Pass in Message handler (not deleted at end)
    void passInMessageHandler(CoinMessageHandler * handler);
    /// Set language
    void newLanguage(CoinMessages::Language language);
    inline void setLanguage(CoinMessages::Language language) {
        newLanguage(language);
    }
    /// Return handler
    inline CoinMessageHandler * messageHandler() const {
        return handler_;
    }
    /// Return messages
    inline CoinMessages & messages() {
        return messages_;
    }
    /// Return pointer to messages
    inline CoinMessages * messagesPointer() {
        return &messages_;
    }
    /// Set log level
    void setLogLevel(int value);
    /// Get log level
    inline int logLevel() const {
        return handler_->logLevel();
    }
    /** Set flag to say if handler_ is the default handler.

      The default handler is deleted when the model is deleted. Other
      handlers (supplied by the client) will not be deleted.
    */
    inline void setDefaultHandler(bool yesNo) {
        defaultHandler_ = yesNo;
    }
    /// Check default handler
    inline bool defaultHandler() const {
        return defaultHandler_;
    }
    //@}
    //---------------------------------------------------------------------------
    ///@name Specialized
    //@{

    /**
        Set special options
        0 bit (1) - check if cuts valid (if on debugger list)
        1 bit (2) - use current basis to check integer solution (rather than all slack)
        2 bit (4) - don't check integer solution (by solving LP)
        3 bit (8) - fast analyze
        4 bit (16) - non-linear model - so no well defined CoinPackedMatrix
        5 bit (32) - keep names
        6 bit (64) - try for dominated columns
        7 bit (128) - SOS type 1 but all declared integer
        8 bit (256) - Set to say solution just found, unset by doing cuts
        9 bit (512) - Try reduced model after 100 nodes
        10 bit (1024) - Switch on some heuristics even if seems unlikely
        11 bit (2048) - Mark as in small branch and bound
        12 bit (4096) - Funny cuts so do slow way (in some places)
        13 bit (8192) - Funny cuts so do slow way (in other places)
        14 bit (16384) - Use Cplex! for fathoming
        15 bit (32768) - Try reduced model after 0 nodes
        16 bit (65536) - Original model had integer bounds
        17 bit (131072) - Perturbation switched off
        18 bit (262144) - donor CbcModel
        19 bit (524288) - recipient CbcModel
        20 bit (1048576) - waiting for sub model to return
        22 bit (4194304) - do not initialize random seed in solver (user has)
        23 bit (8388608) - leave solver_ with cuts
    */
    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
    */
    inline void setMoreSpecialOptions(int value) {
        moreSpecialOptions_ = value;
    }
    /// Get more special options
    inline int moreSpecialOptions() const {
        return moreSpecialOptions_;
    }
    /// Set cutoff as constraint
    inline void setCutoffAsConstraint(bool yesNo) {
      cutoffRowNumber_ = (yesNo) ? -2 : -1;
    }
    /// Set time method
    inline void setUseElapsedTime(bool yesNo) {
        if (yesNo)
          moreSpecialOptions_ |= 131072;
        else
          moreSpecialOptions_ &= ~131072;
    }
    /// Get time method
    inline bool useElapsedTime() const {
        return (moreSpecialOptions_&131072)!=0;
    }
    /// Get useful temporary pointer
    inline void * temporaryPointer() const
    { return temporaryPointer_;}
    /// Set useful temporary pointer
    inline void setTemporaryPointer(void * pointer)
    { temporaryPointer_=pointer;}
    /// Go to dantzig pivot selection if easy problem (clp only)
    void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
    /// Now we may not own objects - just point to solver's objects
    inline bool ownObjects() const {
        return ownObjects_;
    }
    /// Check original model before it gets messed up
    void checkModel();
    //@}
    //---------------------------------------------------------------------------

    ///@name Constructors and destructors etc
    //@{
    /// Default Constructor
    CbcModel();

    /// Constructor from solver
    CbcModel(const OsiSolverInterface &);

    /** Assign a solver to the model (model assumes ownership)

      On return, \p solver will be NULL.
      If deleteSolver then current solver deleted (if model owned)

      \note Parameter settings in the outgoing solver are not inherited by
        the incoming solver.
    */
    void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);

    /** \brief Set ownership of solver

      A parameter of false tells CbcModel it does not own the solver and
      should not delete it. Once you claim ownership of the solver, you're
      responsible for eventually deleting it. Note that CbcModel clones
      solvers with abandon.  Unless you have a deep understanding of the
      workings of CbcModel, the only time you want to claim ownership is when
      you're about to delete the CbcModel object but want the solver to
      continue to exist (as, for example, when branchAndBound has finished
      and you want to hang on to the answer).
    */
    inline void setModelOwnsSolver (bool ourSolver) {
        ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
    }

    /*! \brief Get ownership of solver

      A return value of true means that CbcModel owns the solver and will
      take responsibility for deleting it when that becomes necessary.
    */
    inline bool modelOwnsSolver () {
        return ((ownership_&0x80000000) != 0) ;
    }

    /** Copy constructor .
      If cloneHandler is true then message handler is cloned
    */
    CbcModel(const CbcModel & rhs, bool cloneHandler = false);

    /** Clone */
    virtual CbcModel *clone (bool cloneHandler);

    /// Assignment operator
    CbcModel & operator=(const CbcModel& rhs);

    /// Destructor
    virtual ~CbcModel ();

    /// Returns solver - has current state
    inline OsiSolverInterface * solver() const {
        return solver_;
    }

    /// Returns current solver - sets new one
    inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
        OsiSolverInterface * returnSolver = solver_;
        solver_ = solver;
        return returnSolver;
    }

    /// Returns solver with continuous state
    inline OsiSolverInterface * continuousSolver() const {
        return continuousSolver_;
    }

    /// Create solver with continuous state
    inline void createContinuousSolver() {
        continuousSolver_ = solver_->clone();
    }
    /// Clear solver with continuous state
    inline void clearContinuousSolver() {
        delete continuousSolver_;
        continuousSolver_ = NULL;
    }

    /// A copy of the solver, taken at constructor or by saveReferenceSolver
    inline OsiSolverInterface * referenceSolver() const {
        return referenceSolver_;
    }

    /// Save a copy of the current solver so can be reset to
    void saveReferenceSolver();

    /** Uses a copy of reference solver to be current solver.
        Because of possible mismatches all exotic integer information is loat
        (apart from normal information in OsiSolverInterface)
        so SOS etc and priorities will have to be redone
    */
    void resetToReferenceSolver();

    /// Clears out as much as possible (except solver)
    void gutsOfDestructor();
    /** Clears out enough to reset CbcModel as if no branch and bound done
     */
    void gutsOfDestructor2();
    /** Clears out enough to reset CbcModel cutoff etc
     */
    void resetModel();
    /** Most of copy constructor
        mode - 0 copy but don't delete before
               1 copy and delete before
           2 copy and delete before (but use virgin generators)
    */
    void gutsOfCopy(const CbcModel & rhs, int mode = 0);
    /// Move status, nodes etc etc across
    void moveInfo(const CbcModel & rhs);
    //@}

    ///@name Multithreading
    //@{
    /// Indicates whether Cbc library has been compiled with multithreading support
    static bool haveMultiThreadSupport();
    /// Get pointer to masterthread
    CbcThread * masterThread() const {
        return masterThread_;
    }
    /// Get pointer to walkback
    CbcNodeInfo ** walkback() const {
        return walkback_;
    }
    /// Get number of threads
    inline int getNumberThreads() const {
        return numberThreads_;
    }
    /// Set number of threads
    inline void setNumberThreads(int value) {
        numberThreads_ = value;
    }
    /// Get thread mode
    inline int getThreadMode() const {
        return threadMode_;
    }
    /** Set thread mode
        always use numberThreads for branching
        1 set then deterministic
        2 set then use numberThreads for root cuts
        4 set then use numberThreads in root mini branch and bound
        8 set and numberThreads - do heuristics numberThreads at a time
        8 set and numberThreads==0 do all heuristics at once
        default is 0
    */
    inline void setThreadMode(int value) {
        threadMode_ = value;
    }
    /** Return
        -2 if deterministic threaded and main thread
        -1 if deterministic threaded and serial thread
        0 if serial
        1 if opportunistic threaded
    */
    inline int parallelMode() const {
        if (!numberThreads_) {
            if ((threadMode_&1) == 0)
                return 0;
            else
                return -1;
            return 0;
        } else {
            if ((threadMode_&1) == 0)
                return 1;
            else
                return -2;
        }
    }
    /// Thread stuff for master
    inline CbcBaseModel * master() const
    { return master_;}
    /// From here to end of section - code in CbcThread.cpp until class changed
    /// Returns true if locked
    bool isLocked() const;
#ifdef CBC_THREAD
    /**
       Locks a thread if parallel so that stuff like cut pool
       can be updated and/or used.
    */
    void lockThread();
    /**
       Unlocks a thread if parallel to say cut pool stuff not needed
    */
    void unlockThread();
#else
    inline void lockThread() {}
    inline void unlockThread() {}
#endif
    /** Set information in a child
        -3 pass pointer to child thread info
        -2 just stop
        -1 delete simple child stuff
        0 delete opportunistic child stuff
        1 delete deterministic child stuff
    */
    void setInfoInChild(int type, CbcThread * info);
    /** Move/copy information from one model to another
        -1 - initialization
        0 - from base model
        1 - to base model (and reset)
        2 - add in final statistics etc (and reset so can do clean destruction)
    */
    void moveToModel(CbcModel * baseModel, int mode);
    /// Split up nodes
    int splitModel(int numberModels, CbcModel ** model,
                   int numberNodes);
    /// Start threads
    void startSplitModel(int numberIterations);
    /// Merge models
    void mergeModels(int numberModel, CbcModel ** model,
                     int numberNodes);
    //@}

    ///@name semi-private i.e. users should not use
    //@{
    /// Get how many Nodes it took to solve the problem.
    int getNodeCount2() const {
        return numberNodes2_;
    }
    /// Set pointers for speed
    void setPointers(const OsiSolverInterface * solver);
    /** Perform reduced cost fixing

      Fixes integer variables at their current value based on reduced cost
      penalties.  Returns number fixed
    */
    int reducedCostFix() ;
    /** Makes all handlers same.  If makeDefault 1 then makes top level
        default and rest point to that.  If 2 then each is copy
    */
    void synchronizeHandlers(int makeDefault);
    /// Save a solution to saved list
    void saveExtraSolution(const double * solution, double objectiveValue);
    /// Save a solution to best and move current to saved
    void saveBestSolution(const double * solution, double objectiveValue);
    /// Delete best and saved solutions
    void deleteSolutions();
    /// Encapsulates solver resolve
    int resolve(OsiSolverInterface * solver);
#ifdef CLP_RESOLVE
    /// Special purpose resolve
    int resolveClp(OsiClpSolverInterface * solver, int type);
#endif

    /** Encapsulates choosing a variable -
        anyAction -2, infeasible (-1 round again), 0 done
    */
    int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
                     CbcNode * oldNode, OsiCuts & cuts,
                     bool & resolved, CoinWarmStartBasis *lastws,
                     const double * lowerBefore, const double * upperBefore,
                     OsiSolverBranch * & branches);
    int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);

    /** Return an empty basis object of the specified size

      A useful utility when constructing a basis for a subproblem from scratch.
      The object returned will be of the requested capacity and appropriate for
      the solver attached to the model.
    */
    CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;

    /** Remove inactive cuts from the model

      An OsiSolverInterface is expected to maintain a valid basis, but not a
      valid solution, when loose cuts are deleted. Restoring a valid solution
      requires calling the solver to reoptimise. If it's certain the solution
      will not be required, set allowResolve to false to suppress
      reoptimisation.
      If saveCuts then slack cuts will be saved
      On input current cuts are cuts and newCuts
      on exit current cuts will be correct.  Returns number dropped
    */
    int takeOffCuts(OsiCuts &cuts,
                    bool allowResolve, OsiCuts * saveCuts,
                    int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;

    /** Determine and install the active cuts that need to be added for
      the current subproblem

      The whole truth is a bit more complicated. The first action is a call to
      addCuts1(). addCuts() then sorts through the list, installs the tight
      cuts in the model, and does bookkeeping (adjusts reference counts).
      The basis returned from addCuts1() is adjusted accordingly.

      If it turns out that the node should really be fathomed by bound,
      addCuts() simply treats all the cuts as loose as it does the bookkeeping.

      canFix true if extra information being passed
    */
    int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix);

    /** Traverse the tree from node to root and prep the model

      addCuts1() begins the job of prepping the model to match the current
      subproblem. The model is stripped of all cuts, and the search tree is
      traversed from node to root to determine the changes required. Appropriate
      bounds changes are installed, a list of cuts is collected but not
      installed, and an appropriate basis (minus the cuts, but big enough to
      accommodate them) is constructed.

      Returns true if new problem similar to old

      \todo addCuts1() is called in contexts where it's known in advance that
        all that's desired is to determine a list of cuts and do the
        bookkeeping (adjust the reference counts). The work of installing
        bounds and building a basis goes to waste.
    */
    bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
    /** Returns bounds just before where - initially original bounds.
        Also sets downstream nodes (lower if force 1, upper if 2)
    */
    void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
                         double & lower, double & upper, int force);
    /** Set objective value in a node.  This is separated out so that
       odd solvers can use.  It may look at extra information in
       solverCharacteriscs_ and will also use bound from parent node
    */
    void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;

    /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
        Scan and convert CbcSimpleInteger objects
    */
    void convertToDynamic();
    /// Set numberBeforeTrust in all objects
    void synchronizeNumberBeforeTrust(int type = 0);
    /// Zap integer information in problem (may leave object info)
    void zapIntegerInformation(bool leaveObjects = true);
    /// Use cliques for pseudocost information - return nonzero if infeasible
    int cliquePseudoCosts(int doStatistics);
    /// Fill in useful estimates
    void pseudoShadow(int type);
    /** Return pseudo costs
        If not all integers or not pseudo costs - returns all zero
        Length of arrays are numberIntegers() and entries
        correspond to integerVariable()[i]
        User must allocate arrays before call
    */
    void fillPseudoCosts(double * downCosts, double * upCosts,
                         int * priority = NULL,
                         int * numberDown = NULL, int * numberUp = NULL,
                         int * numberDownInfeasible = NULL,
                         int * numberUpInfeasible = NULL) const;
    /** Do heuristics at root.
        0 - don't delete
        1 - delete
        2 - just delete - don't even use
    */
    void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
    /// Adjust heuristics based on model
    void adjustHeuristics();
    /// Get the hotstart solution
    inline const double * hotstartSolution() const {
        return hotstartSolution_;
    }
    /// Get the hotstart priorities
    inline const int * hotstartPriorities() const {
        return hotstartPriorities_;
    }

    /// Return the list of cuts initially collected for this subproblem
    inline CbcCountRowCut ** addedCuts() const {
        return addedCuts_;
    }
    /// Number of entries in the list returned by #addedCuts()
    inline int currentNumberCuts() const {
        return currentNumberCuts_;
    }
    /// Global cuts
    inline CbcRowCuts * globalCuts() {
        return &globalCuts_;
    }
    /// Copy and set a pointer to a row cut which will be added instead of normal branching.
    void setNextRowCut(const OsiRowCut & cut);
    /// Get a pointer to current node (be careful)
    inline CbcNode * currentNode() const {
        return currentNode_;
    }
    /// Get a pointer to probing info
    inline CglTreeProbingInfo * probingInfo() const {
        return probingInfo_;
    }
    /// Thread specific random number generator
    inline CoinThreadRandom * randomNumberGenerator() {
        return &randomNumberGenerator_;
    }
    /// Set the number of iterations done in strong branching.
    inline void setNumberStrongIterations(int number) {
        numberStrongIterations_ = number;
    }
    /// Get the number of iterations done in strong branching.
    inline int numberStrongIterations() const {
        return numberStrongIterations_;
    }
    /// Get maximum number of iterations (designed to be used in heuristics)
    inline int maximumNumberIterations() const {
        return maximumNumberIterations_;
    }
    /// Set maximum number of iterations (designed to be used in heuristics)
    inline void setMaximumNumberIterations(int value) {
        maximumNumberIterations_ = value;
    }
    /// 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) {
        numberExtraNodes_ += nodes;
        numberExtraIterations_ += iterations;
    }
    /// 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();
    //@}

//---------------------------------------------------------------------------

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_;
    /** Warm start object produced by heuristic or strong branching

        If get a valid integer solution outside branch and bound then it can take
        a reasonable time to solve LP which produces clean solution.  If this object has
        any size then it will be used in solve.
    */
    CoinWarmStartBasis bestSolutionBasis_ ;
    /// Global cuts
    CbcRowCuts globalCuts_;
    /// Global conflict cuts
    CbcRowCuts * globalConflictCuts_;

    /// Minimum degradation in objective value to continue cut generation
    double minimumDrop_;
    /// Number of solutions
    int numberSolutions_;
    /// Number of saved solutions
    int numberSavedSolutions_;
    /// Maximum number of saved solutions
    int maximumSavedSolutions_;
    /** State of search
        0 - no solution
        1 - only heuristic solutions
        2 - branched to a solution
        3 - no solution but many nodes
    */
    int stateOfSearch_;
    /// At which depths to do cuts
    int whenCuts_;
    /// Hotstart solution
    double * hotstartSolution_;
    /// Hotstart priorities
    int * hotstartPriorities_;
    /// Number of heuristic solutions
    int numberHeuristicSolutions_;
    /// Cumulative number of nodes
    int numberNodes_;
    /** Cumulative number of nodes for statistics.
        Must fix to match up
    */
    int numberNodes2_;
    /// Cumulative number of iterations
    int numberIterations_;
    /// Cumulative number of solves
    int numberSolves_;
    /// Status of problem - 0 finished, 1 stopped, 2 difficulties
    int status_;
    /** Secondary status of problem
        -1 unset (status_ will also be -1)
        0 search completed with solution
        1 linear relaxation not feasible (or worse than cutoff)
        2 stopped on gap
        3 stopped on nodes
        4 stopped on time
        5 stopped on user event
        6 stopped on solutions
     */
    int secondaryStatus_;
    /// Number of integers in problem
    int numberIntegers_;
    /// Number of rows at continuous
    int numberRowsAtContinuous_;
    /**
       -1 - cutoff as constraint not activated
       -2 - waiting to activate
       >=0 - activated
     */
    int cutoffRowNumber_;
    /// Maximum number of cuts
    int maximumNumberCuts_;
    /** Current phase (so heuristics etc etc can find out).
        0 - initial solve
        1 - solve with cuts at root
        2 - solve with cuts
        3 - other e.g. strong branching
        4 - trying to validate a solution
        5 - at end of search
    */
    int phase_;

    /// Number of entries in #addedCuts_
    int currentNumberCuts_;

    /** Current limit on search tree depth

      The allocated size of #walkback_. Increased as needed.
    */
    int maximumDepth_;
    /** Array used to assemble the path between a node and the search tree root

      The array is resized when necessary. #maximumDepth_  is the current
      allocated size.
    */
    CbcNodeInfo ** walkback_;
    CbcNodeInfo ** lastNodeInfo_;
    const OsiRowCut ** lastCut_;
    int lastDepth_;
    int lastNumberCuts2_;
    int maximumCuts_;
    int * lastNumberCuts_;

    /** The list of cuts initially collected for this subproblem

      When the subproblem at this node is rebuilt, a set of cuts is collected
      for inclusion in the constraint system. If any of these cuts are
      subsequently removed because they have become loose, the corresponding
      entry is set to NULL.
    */
    CbcCountRowCut ** addedCuts_;

    /** A pointer to a row cut which will be added instead of normal branching.
        After use it should be set to NULL.
    */
    OsiRowCut * nextRowCut_;

    /// Current node so can be used elsewhere
    CbcNode * currentNode_;

    /// Indices of integer variables
    int * integerVariable_;
    /// Whether of not integer
    char * integerInfo_;
    /// Holds solution at continuous (after cuts)
    double * continuousSolution_;
    /// Array marked whenever a solution is found if non-zero
    int * usedInSolution_;
    /**
        Special options
        0 bit (1) - check if cuts valid (if on debugger list)
        1 bit (2) - use current basis to check integer solution (rather than all slack)
        2 bit (4) - don't check integer solution (by solving LP)
        3 bit (8) - fast analyze
        4 bit (16) - non-linear model - so no well defined CoinPackedMatrix
        5 bit (32) - keep names
        6 bit (64) - try for dominated columns
        7 bit (128) - SOS type 1 but all declared integer
        8 bit (256) - Set to say solution just found, unset by doing cuts
        9 bit (512) - Try reduced model after 100 nodes
        10 bit (1024) - Switch on some heuristics even if seems unlikely
        11 bit (2048) - Mark as in small branch and bound
        12 bit (4096) - Funny cuts so do slow way (in some places)
        13 bit (8192) - Funny cuts so do slow way (in other places)
        14 bit (16384) - Use Cplex! for fathoming
        15 bit (32768) - Try reduced model after 0 nodes
        16 bit (65536) - Original model had integer bounds
        17 bit (131072) - Perturbation switched off
        18 bit (262144) - donor CbcModel
        19 bit (524288) - recipient CbcModel
    */
    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_;
    /// 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

    /// 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_;
    /** 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_;
    /// Thread stuff for master
    CbcBaseModel * master_;
    /// Pointer to masterthread
    CbcThread * masterThread_;
//@}
};
/// So we can use osiObject or CbcObject during transition
void getIntegerInformation(const OsiObject * object, double & originalLower,
                           double & originalUpper) ;
// So we can call from other programs
// Real main program
class OsiClpSolverInterface;
int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
// four ways of calling
int callCbc(const char * input2, OsiClpSolverInterface& solver1);
int callCbc(const char * input2);
int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
int callCbc(const std::string input2) ;
// When we want to load up CbcModel with options first
void CbcMain0 (CbcModel & babSolver);
int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
// two ways of calling
int callCbc(const char * input2, CbcModel & babSolver);
int callCbc(const std::string input2, CbcModel & babSolver);
// And when CbcMain0 already called to initialize
int callCbc1(const char * input2, CbcModel & babSolver);
int callCbc1(const std::string input2, CbcModel & babSolver);
// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
// For uniform setting of cut and heuristic options
void setCutAndHeuristicOptions(CbcModel & model);
#endif