/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcModel.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcModel_H
#define CbcModel_H
#include <string>
#include <vector>
#include "CoinFinite.hpp"
#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "OsiBranchingObject.hpp"
#include "OsiCuts.hpp"
#include "CoinWarmStartBasis.hpp"
#include "CbcCompareBase.hpp"
#include "CbcMessage.hpp"

//class OsiSolverInterface;

class CbcCutGenerator;
class OsiRowCut;
class OsiBabSolver;
class OsiRowCutDebugger;
class CglCutGenerator;
class CbcCutModifier;
class CglTreeProbingInfo;
class CbcHeuristic;
class OsiObject;
class CbcTree;
class CbcStrategy;
class CbcFeasibilityBase;
class CbcStatistics;
class CbcEventHandler ;
class CglPreProcess;

// #define CBC_CHECK_BASIS 1

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

class CbcModel  {
  
public:

enum CbcIntParam {
  CbcMaxNumNode=0,
  CbcMaxNumSol,
  CbcFathomDiscipline,
  CbcPrinting,
  CbcLastIntParam
};

enum CbcDblParam {
  CbcIntegerTolerance=0,
  CbcInfeasibilityWeight,
  CbcCutoffIncrement,
  CbcAllowableGap,
  CbcAllowableFractionGap,
  CbcMaximumSeconds,
  CbcCurrentCutoff,
  CbcOptimizationDirection,
  CbcCurrentObjectiveValue,
  CbcCurrentMinimizationObjectiveValue,
  CbcStartSeconds,
  CbcLastDblParam
};

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

public:


    void initialSolve(); 

     void branchAndBound(int doStatistics=0);

     CbcModel *  cleanModel(const double * lower, const double * upper);
     int subBranchAndBound(CbcModel * model2,
                           CbcModel * presolvedModel,
                           int maximumNodes);
     int subBranchAndBound(const double * lower, const double * upper,
                            int maximumNodes);

     OsiSolverInterface *  strengthenedModel();
  CglPreProcess * preProcess( int makeEquality=0, int numberPasses=5,
                  int tuning=5);
  void postProcess(CglPreProcess * process);
private:
  bool solveWithCuts(OsiCuts & cuts, int numberTries,CbcNode * node);
  CbcNode ** solveOneNode(int whichSolver,CbcNode * node, 
                          int & numberNodesOutput, int & status) ;
  void resizeWhichGenerator(int numberNow, int numberAfter);
public:
#ifndef CBC_THREAD
#define NEW_UPDATE_OBJECT 0
#else
#define NEW_UPDATE_OBJECT 2
#endif
#if NEW_UPDATE_OBJECT>1
  void addUpdateInformation(const CbcObjectUpdateData & data);
#endif

  int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);

  bool isLocked() const;
#if 0
  int whileIterating(bool & locked, threadId, threadInfo,condition_mutex,condition_main,
                     timeWaiting,threadModel,threadStats,totalTime,cutoff,
                     eventHandler,saveCompare,lastDepth,lastUnsatisfied,createdNode);
#else
  int whileIterating(int numberIterations);
#endif
#ifdef CBC_THREAD

  void lockThread();
  void unlockThread();
#else
  inline void lockThread() {}
  inline void unlockThread() {}
#endif
private:
  void moveToModel(CbcModel * baseModel,int mode);
public:
    int resolve(CbcNodeInfo * parent, int whereFrom);
    void makeGlobalCuts(int numberRows,const int * which); 
    void makeGlobalCut(const OsiRowCut * cut); 
    void makeGlobalCut(const OsiRowCut & cut); 


  CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
                         int lessThanThis, int defaultValue=1000);

  CbcModel * integerPresolve(bool weak=false);

  bool integerPresolveThisModel(OsiSolverInterface * originalSolver,bool weak=false);


  void originalModel(CbcModel * presolvedModel,bool weak);

  bool tightenVubs(int type,bool allowMultipleBinary=false,
                   double useCutoff=1.0e50);
  
  bool tightenVubs(int numberVubs, const int * which,
                   double useCutoff=1.0e50);
  void analyzeObjective();




  inline int numberObjects() const { return numberObjects_;}
  inline void setNumberObjects(int number) 
  {  numberObjects_=number;}

  inline OsiObject ** objects() const { return object_;}

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

  void deleteObjects(bool findIntegers=true);

  void addObjects(int numberObjects, OsiObject ** objects);

  void addObjects(int numberObjects, CbcObject ** objects);

  void synchronizeModel() ;

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


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


  inline bool setIntParam(CbcIntParam key, int value) {
    intParam_[key] = value;
    return true;
  }
  inline bool setDblParam(CbcDblParam key, double value) {
    dblParam_[key] = value;
    return true;
  }
  inline int getIntParam(CbcIntParam key) const {
    return intParam_[key];
  }
  inline double getDblParam(CbcDblParam key) const {
    return dblParam_[key];
  }
  void setCutoff(double value) ;

  inline double getCutoff() const
  { //double value ;
    //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
    //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
    return dblParam_[CbcCurrentCutoff];
  }

  inline bool setMaximumNodes( int value)
  { return setIntParam(CbcMaxNumNode,value); }

  inline int getMaximumNodes() const
  { return getIntParam(CbcMaxNumNode); }

  inline bool setMaximumSolutions( int value) {
    return setIntParam(CbcMaxNumSol,value);
  }
  inline int getMaximumSolutions() const {
    return getIntParam(CbcMaxNumSol);
  }
  inline bool setPrintingMode( int value)
  { return setIntParam(CbcPrinting,value); }

  inline int getPrintingMode() const
  { return getIntParam(CbcPrinting); }

  inline bool setMaximumSeconds( double value) {
    return setDblParam(CbcMaximumSeconds,value);
  }
  inline double getMaximumSeconds() const {
    return getDblParam(CbcMaximumSeconds);
  }
  double getCurrentSeconds() const ;

  inline bool setIntegerTolerance( double value) {
    return setDblParam(CbcIntegerTolerance,value);
  }
  inline double getIntegerTolerance() const {
    return getDblParam(CbcIntegerTolerance);
  }

  inline bool setInfeasibilityWeight( double value) {
    return setDblParam(CbcInfeasibilityWeight,value);
  }
  inline double getInfeasibilityWeight() const {
    return getDblParam(CbcInfeasibilityWeight);
  }

  inline bool setAllowableGap( double value) {
    return setDblParam(CbcAllowableGap,value);
  }
  inline double getAllowableGap() const {
    return getDblParam(CbcAllowableGap);
  }

  inline bool setAllowableFractionGap( double value) {
    return setDblParam(CbcAllowableFractionGap,value);
  }
  inline double getAllowableFractionGap() const {
    return getDblParam(CbcAllowableFractionGap);
  }
  inline bool setAllowablePercentageGap( double value) {
    return setDblParam(CbcAllowableFractionGap,value*0.01);
  }
  inline double getAllowablePercentageGap() const {
    return 100.0*getDblParam(CbcAllowableFractionGap);
  }
  inline bool setCutoffIncrement( double value) {
    return setDblParam(CbcCutoffIncrement,value);
  }
  inline double getCutoffIncrement() const {
    return getDblParam(CbcCutoffIncrement);
  }

  void setHotstartSolution(const double * solution, const int * priorities=NULL) ;
  
  inline void setMinimumDrop(double value)
  {minimumDrop_=value;}
  inline double getMinimumDrop() const
  { return minimumDrop_;}

  inline void setMaximumCutPassesAtRoot(int value)
  {maximumCutPassesAtRoot_=value;}
  inline int getMaximumCutPassesAtRoot() const
  { return maximumCutPassesAtRoot_;}

  inline void setMaximumCutPasses(int value)
  {maximumCutPasses_=value;}
  inline int getMaximumCutPasses() const
  { return maximumCutPasses_;}
  inline int getCurrentPassNumber() const
  { return currentPassNumber_;}

  void setNumberStrong(int number);
  inline int numberStrong() const
  { return numberStrong_;}
  inline void setPreferredWay(int value)
  {preferredWay_=value;}
  inline int getPreferredWay() const
  { return preferredWay_;}
  inline void setSizeMiniTree(int value)
  { sizeMiniTree_=value;}
  inline int sizeMiniTree() const
  { return sizeMiniTree_;}

  void setNumberBeforeTrust(int number);
  inline int numberBeforeTrust() const
  { return numberBeforeTrust_;}
  void setNumberPenalties(int number);
  inline int numberPenalties() const
  { return numberPenalties_;}
  inline void setNumberAnalyzeIterations(int number)
  { numberAnalyzeIterations_=number;}
  inline int numberAnalyzeIterations() const
  { return numberAnalyzeIterations_;}
  inline double penaltyScaleFactor() const
  { return penaltyScaleFactor_;}
  void setPenaltyScaleFactor(double value);
  void inline setProblemType(int number)
  { problemType_=number;}
  inline int problemType() const
  { return problemType_;}

  void setHowOftenGlobalScan(int number);
  inline int howOftenGlobalScan() const
  { return howOftenGlobalScan_;}
  inline int * originalColumns() const
  { return originalColumns_;}
  void setOriginalColumns(const int * originalColumns) ;

  inline void setPrintFrequency(int number)
  { printFrequency_=number;}
  inline int printFrequency() const
  { return printFrequency_;}

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


    bool isAbandoned() const;
    bool isProvenOptimal() const;
    bool isProvenInfeasible() const;
    bool isContinuousUnbounded() const;
    bool isProvenDualInfeasible() const;
    bool isNodeLimitReached() const;
    bool isSecondsLimitReached() const;
    bool isSolutionLimitReached() const;
    inline int getIterationCount() const
    { return numberIterations_;}
    inline int getNodeCount() const
    { return numberNodes_;}
    inline int status() const
    { return status_;}
    inline void setProblemStatus(int value)
    { status_=value;}
    inline int secondaryStatus() const
    { return secondaryStatus_;}
    inline void setSecondaryStatus(int value)
    { secondaryStatus_=value;}
    bool isInitialSolveAbandoned() const ;
    bool isInitialSolveProvenOptimal() const ;
    bool isInitialSolveProvenPrimalInfeasible() const ;
    bool isInitialSolveProvenDualInfeasible() const ;


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

  inline int numberRowsAtContinuous() const
  { return numberRowsAtContinuous_;}

  inline int getNumCols() const
  { return solver_->getNumCols();}
  
  inline int getNumRows() const
  { return solver_->getNumRows();}
  
  inline CoinBigIndex getNumElements() const
  { return solver_->getNumElements();}

  inline int numberIntegers() const
  { return numberIntegers_;}
  // Integer variables
  inline const int * integerVariable() const 
  { return integerVariable_;}
  inline char integerType(int i) const
  { return integerInfo_[i];}
  inline const char * integerType() const
  { return integerInfo_;}

  inline const double * getColLower() const
  { return solver_->getColLower();}
  
  inline const double * getColUpper() const
  { return solver_->getColUpper();}
  
  inline const char * getRowSense() const
  { return solver_->getRowSense();}
  
  inline const double * getRightHandSide() const
  { return solver_->getRightHandSide();}
  
  inline const double * getRowRange() const
  { return solver_->getRowRange();}
  
  inline const double * getRowLower() const
  { return solver_->getRowLower();}
  
  inline const double * getRowUpper() const
  { return solver_->getRowUpper();}
  
  inline const double * getObjCoefficients() const
  { return solver_->getObjCoefficients();}
  
  inline double getObjSense() const
  {
    //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
    return dblParam_[CbcOptimizationDirection];}
  
  inline bool isContinuous(int colIndex) const
  { return solver_->isContinuous(colIndex);}
  
  inline bool isBinary(int colIndex) const
  { return solver_->isBinary(colIndex);}
  
  inline bool isInteger(int colIndex) const
  { return solver_->isInteger(colIndex);}
  
  inline bool isIntegerNonBinary(int colIndex) const
  { return solver_->isIntegerNonBinary(colIndex);}
  
  inline bool isFreeBinary(int colIndex) const
  { return solver_->isFreeBinary(colIndex) ;}
  
  inline const CoinPackedMatrix * getMatrixByRow() const
  { return solver_->getMatrixByRow();}
  
  inline const CoinPackedMatrix * getMatrixByCol() const
  { return solver_->getMatrixByCol();}
  
  inline double getInfinity() const
  { return solver_->getInfinity();}
  inline const double * getCbcColLower() const
  { return cbcColLower_;}
  inline const double * getCbcColUpper() const
  { return cbcColUpper_;}
  inline const double * getCbcRowLower() const
  { return cbcRowLower_;}
  inline const double * getCbcRowUpper() const
  { return cbcRowUpper_;}
  inline const double * getCbcColSolution() const
  { return cbcColSolution_;}
  inline const double * getCbcRowPrice() const
  { return cbcRowPrice_;}
  inline const double * getCbcReducedCost() const
  { return cbcReducedCost_;}
  inline const double * getCbcRowActivity() const
  { return cbcRowActivity_;}
  
  

  inline double * continuousSolution() const
  { return continuousSolution_;}
  inline int * usedInSolution() const
  { return usedInSolution_;}
  void incrementUsed(const double * solution);
  void setBestSolution(CBC_Message how,
                       double & objectiveValue, const double *solution,
                       bool fixVariables=false);
  void setBestObjectiveValue( double objectiveValue);

  double checkSolution(double cutoff, double * solution,
                       bool fixVariables, double originalObjValue);
  bool feasibleSolution(int & numberIntegerInfeasibilities,
                        int & numberObjectInfeasibilities) const;

  inline double * currentSolution() const
  { return currentSolution_;}
  inline const double * testSolution() const
  { return testSolution_;}
  inline void setTestSolution(const double * solution)
  { testSolution_ = solution;}
  void reserveCurrentSolution(const double * solution=NULL);

  inline const double * getColSolution() const
  { return solver_->getColSolution();}
  
  inline const double * getRowPrice() const
  { return solver_->getRowPrice();}
  
  inline const double * getReducedCost() const
  { return solver_->getReducedCost();}
  
  inline const double * getRowActivity() const
  { return solver_->getRowActivity();}
  
  inline double getCurrentObjValue() const
  { return dblParam_[CbcCurrentObjectiveValue]; }
  inline double getCurrentMinimizationObjValue() const
  { return dblParam_[CbcCurrentMinimizationObjectiveValue];}
  
  inline double getMinimizationObjValue() const
  { return bestObjective_;}
  inline void setMinimizationObjValue(double value) 
  { bestObjective_=value;}
  
  inline double getObjValue() const
  { return bestObjective_ * solver_->getObjSense() ; } 
  double getBestPossibleObjValue() const;
  inline void setObjValue(double value) 
  { bestObjective_=value * solver_->getObjSense() ;}
  
  inline double * bestSolution() const
  { return bestSolution_;}
  void setBestSolution(const double * solution,int numberColumns,double objectiveValue);
  
  inline int getSolutionCount() const
  { return numberSolutions_;}
  
  inline void setSolutionCount(int value) 
  { numberSolutions_=value;}
  inline int phase() const
  { return phase_;}
  
  inline int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;}
  inline void setNumberHeuristicSolutions(int value) { numberHeuristicSolutions_=value;}

  inline void setObjSense(double s) { dblParam_[CbcOptimizationDirection]=s;
  solver_->setObjSense(s);}

  inline double getContinuousObjective() const
  { return originalContinuousObjective_;}
  inline void setContinuousObjective(double value)
  { originalContinuousObjective_=value;}
  inline int getContinuousInfeasibilities() const
  { return continuousInfeasibilities_;}
  inline void setContinuousInfeasibilities(int value)
  { continuousInfeasibilities_=value;}
  inline double rootObjectiveAfterCuts() const
  { return continuousObjective_;}
  inline double sumChangeObjective() const
  { return sumChangeObjective1_;}
  inline int numberGlobalViolations() const
  { return numberGlobalViolations_;}
  inline void clearNumberGlobalViolations()
  { numberGlobalViolations_=0;}
  inline bool resolveAfterTakeOffCuts() const
  { return resolveAfterTakeOffCuts_;}
  inline void setResolveAfterTakeOffCuts(bool yesNo)
  { resolveAfterTakeOffCuts_=yesNo;}
  inline int maximumRows() const
  { return maximumRows_;}
  inline CoinWarmStartBasis & workingBasis()
  { return workingBasis_;}
  inline int getNumberThreads() const
  { return numberThreads_;}
  inline void setNumberThreads(int value) 
  { numberThreads_=value;}
  inline int getThreadMode() const
  { return threadMode_;}
  inline void setThreadMode(int value) 
  { threadMode_=value;}
  inline int getStopNumberIterations() const
  { return stopNumberIterations_;}
  inline void setStopNumberIterations(int value) 
  { stopNumberIterations_=value;}

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

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


  inline CbcTree * tree() const
  { return tree_;}
  void passInTreeHandler(CbcTree & tree);
  void passInSubTreeModel(CbcModel & model);
  CbcModel * subTreeModel(OsiSolverInterface * solver=NULL) const;
  inline int numberStoppedSubTrees() const
  { return numberStoppedSubTrees_;}
  inline void incrementSubTreeStopped()
  { numberStoppedSubTrees_++;}
  inline int typePresolve() const
  { return presolve_;}
  inline void setTypePresolve(int value)
  { presolve_=value;}
  


  inline CbcBranchDecision * branchingMethod() const
  { return branchingMethod_;}
  inline void setBranchingMethod(CbcBranchDecision * method)
  { delete branchingMethod_; branchingMethod_ = method->clone();}
  inline void setBranchingMethod(CbcBranchDecision & method)
  { delete branchingMethod_; branchingMethod_ = method.clone();}
  inline CbcCutModifier * cutModifier() const
  { return cutModifier_;}
  void setCutModifier(CbcCutModifier * modifier);
  void setCutModifier(CbcCutModifier & modifier);


  inline int stateOfSearch() const
  { return stateOfSearch_;}
  inline void setStateOfSearch(int state)
  { stateOfSearch_=state;}
  inline int searchStrategy() const
  { return searchStrategy_;}
  inline void setSearchStrategy(int value)
  { searchStrategy_ = value; }

  inline int numberCutGenerators() const
  { return numberCutGenerators_;}
  inline CbcCutGenerator ** cutGenerators() const
  { return generator_;}
  inline CbcCutGenerator * cutGenerator(int i) const
  { return generator_[i];}
  inline CbcCutGenerator * virginCutGenerator(int i) const
  { return virginGenerator_[i];}
  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);


  inline CbcStrategy * strategy() const
  { return strategy_;}
  void setStrategy(CbcStrategy & strategy);
  inline CbcModel * parentModel() const
  { return parentModel_;}
  inline void setParentModel(CbcModel & parentModel)
  { parentModel_ = &parentModel;}


  void addHeuristic(CbcHeuristic * generator, const char *name = NULL);
  inline CbcHeuristic * heuristic(int i) const
  { return heuristic_[i];}
  inline int numberHeuristics() const
  { return numberHeuristics_;}
  inline CbcHeuristic * lastHeuristic() const
  { return lastHeuristic_;}
  inline void setLastHeuristic(CbcHeuristic * last)
  { lastHeuristic_=last;}

  void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);

  inline int priority(int sequence) const
  { return object_[sequence]->priority();}

  void passInEventHandler(const CbcEventHandler *eventHandler) ;

  inline CbcEventHandler* getEventHandler() const
  { return (eventHandler_) ; } 

    
    void setApplicationData (void * appData);

    void * getApplicationData() const;
  void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
  inline const OsiBabSolver * solverCharacteristics() const
  { return solverCharacteristics_;}
  
  //---------------------------------------------------------------------------


  void passInMessageHandler(CoinMessageHandler * handler);
  void newLanguage(CoinMessages::Language language);
  inline void setLanguage(CoinMessages::Language language)
  {newLanguage(language);}
  inline CoinMessageHandler * messageHandler() const
  {return handler_;}
  inline CoinMessages & messages() 
  {return messages_;}
  inline CoinMessages * messagesPointer() 
  {return &messages_;}
  void setLogLevel(int value);
  inline int logLevel() const
  { return handler_->logLevel();}
  //---------------------------------------------------------------------------



  inline void setSpecialOptions(int value)
  { specialOptions_=value;}
  inline int specialOptions() const
  { return specialOptions_;}
  inline bool normalSolver() const
  { return (specialOptions_&16)==0;}
  inline bool ownObjects() const
  { return ownObjects_;}
  inline void * mutex()
  { return mutex_;}
  int splitModel(int numberModels, CbcModel ** model,
                  int numberNodes);
  void startSplitModel(int numberIterations);
  void mergeModels(int numberModel, CbcModel ** model,
                   int numberNodes);
  //---------------------------------------------------------------------------



    CbcModel(); 
    
    CbcModel(const OsiSolverInterface &);
  
    void assignSolver(OsiSolverInterface *&solver,bool deleteSolver=true);

    inline void setModelOwnsSolver (bool ourSolver)
  { ownership_ = ourSolver ? (ownership_ |0x80000000) : (ownership_ & (~0x80000000)) ; } 

  inline bool modelOwnsSolver () { return ((ownership_&0x80000000)!=0) ; } 
  
    CbcModel(const CbcModel & rhs, bool noTree=false);
  
    CbcModel & operator=(const CbcModel& rhs);
  
     ~CbcModel ();

    inline OsiSolverInterface * solver() const
    { return solver_;}

    inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) 
    { OsiSolverInterface * returnSolver = solver_; solver_ = solver; return returnSolver;}

    inline OsiSolverInterface * continuousSolver() const
    { return continuousSolver_;}

    inline void createContinuousSolver()
    { continuousSolver_ = solver_->clone();}
    inline void clearContinuousSolver()
    { delete continuousSolver_; continuousSolver_ = NULL;}

  inline OsiSolverInterface * referenceSolver() const
  { return referenceSolver_;}

  void saveReferenceSolver();

  void resetToReferenceSolver();

  void gutsOfDestructor();
  void gutsOfDestructor2();
  void resetModel();
  void moveInfo(const CbcModel & rhs);



    int getNodeCount2() const
    { return numberNodes2_;}
  void setPointers(const OsiSolverInterface * solver);
  int reducedCostFix() ;
  int resolve(OsiSolverInterface * solver);

  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);

  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;

  void takeOffCuts(OsiCuts &cuts, 
                     bool allowResolve,OsiCuts * saveCuts) ;

  int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws,bool canFix);

  void addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
  void previousBounds (CbcNode * node, CbcNodeInfo * where,int iColumn,
                       double & lower, double & upper,int force);
  void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;

  void convertToDynamic();
  void zapIntegerInformation(bool leaveObjects=true);
  int cliquePseudoCosts(int doStatistics);
  void pseudoShadow(double * down, double * up);
  void fillPseudoCosts(double * downCosts, double * upCosts) const;
  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0);
  inline const double * hotstartSolution() const
  { return hotstartSolution_;}
  inline const int * hotstartPriorities() const
  { return hotstartPriorities_;}

  inline CbcCountRowCut ** addedCuts() const
  { return addedCuts_;}
  inline int currentNumberCuts() const
  { return currentNumberCuts_;}
  inline OsiCuts * globalCuts() 
  { return &globalCuts_;}
  void setNextRowCut(const OsiRowCut & cut);
  inline CbcNode * currentNode() const
  { return currentNode_;}
  inline CglTreeProbingInfo * probingInfo() const
  { return probingInfo_;}
  inline void setNumberStrongIterations(int number)
  { numberStrongIterations_ = number;}
  inline int numberStrongIterations() const
  { return numberStrongIterations_;}
  void incrementStrongInfo(int numberTimes, int numberIterations,
                           int numberFixed, bool ifInfeasible);
  inline bool allDynamic () const { return ((ownership_&0x40000000)!=0) ; } 
  void generateCpp( FILE * fp,int options);
  OsiBranchingInformation usefulInformation() const;
  inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis)
  { bestSolutionBasis_ = bestSolutionBasis;}

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

private:


  OsiSolverInterface * solver_;

  unsigned int ownership_ ;

  OsiSolverInterface * continuousSolver_;

  OsiSolverInterface * referenceSolver_;

  CoinMessageHandler * handler_;

  bool defaultHandler_;

  CoinMessages messages_;

  int intParam_[CbcLastIntParam];

  double dblParam_[CbcLastDblParam];

  mutable CoinWarmStart *emptyWarmStart_ ;

  double bestObjective_;
  double bestPossibleObjective_;
  double sumChangeObjective1_;
  double sumChangeObjective2_;

  double * bestSolution_;

  double * currentSolution_;
  mutable const double * testSolution_;
  CoinWarmStartBasis bestSolutionBasis_ ;
  OsiCuts globalCuts_;

  double minimumDrop_;
  int numberSolutions_;
  int stateOfSearch_;
  double * hotstartSolution_;
  int * hotstartPriorities_;
  int numberHeuristicSolutions_;
  int numberNodes_;
  int numberNodes2_;
  int numberIterations_;
  int status_;
  int secondaryStatus_;
  int numberIntegers_;
  int numberRowsAtContinuous_;
  int maximumNumberCuts_;
  int phase_;

  int currentNumberCuts_;

  int maximumDepth_;
  CbcNodeInfo ** walkback_;

  CbcCountRowCut ** addedCuts_;

  OsiRowCut * nextRowCut_;

  CbcNode * currentNode_;

  int * integerVariable_;
  char * integerInfo_;
  double * continuousSolution_;
  int * usedInSolution_;
  int specialOptions_;
  CbcCompareBase * nodeCompare_;
  CbcFeasibilityBase * problemFeasibility_;
  CbcTree * tree_;
  CbcModel * subTreeModel_;
  int numberStoppedSubTrees_;
  CbcBranchDecision * branchingMethod_;
  CbcCutModifier * cutModifier_;
  CbcStrategy * strategy_;
  CbcModel * parentModel_;

  const double * cbcColLower_;
  const double * cbcColUpper_;
  const double * cbcRowLower_;
  const double * cbcRowUpper_;
  const double * cbcColSolution_;
  const double * cbcRowPrice_;
  const double * cbcReducedCost_;
  const double * cbcRowActivity_;
  void * appData_;
  void * mutex_;
  int presolve_;
  int numberStrong_;
  int numberBeforeTrust_;
  int numberPenalties_;
  int stopNumberIterations_;
  double penaltyScaleFactor_;
  int numberAnalyzeIterations_;
  double * analyzeResults_;
  int numberInfeasibleNodes_;
  int problemType_;
  int printFrequency_;
  int numberCutGenerators_;
  // Cut generators
  CbcCutGenerator ** generator_;
  // Cut generators before any changes
  CbcCutGenerator ** virginGenerator_;
  int numberHeuristics_;
  CbcHeuristic ** heuristic_;
  CbcHeuristic * lastHeuristic_;
# ifdef CBC_ONLY_CLP
  ClpEventHandler *eventHandler_ ;
# else
  CbcEventHandler *eventHandler_ ;
# endif

  int numberObjects_;

  OsiObject ** object_;
  bool ownObjects_;
  
  int * originalColumns_;
  int howOftenGlobalScan_;
  int numberGlobalViolations_;
  double continuousObjective_;
  double originalContinuousObjective_;
  int continuousInfeasibilities_;
  int maximumCutPassesAtRoot_;
  int maximumCutPasses_;
  int preferredWay_;
  int currentPassNumber_;
  int maximumWhich_;
  int maximumRows_;
  CoinWarmStartBasis workingBasis_;
  int * whichGenerator_;
  int maximumStatistics_;
  CbcStatistics ** statistics_;
  int maximumDepthActual_;
  double numberDJFixed_;
  CglTreeProbingInfo * probingInfo_;
  int numberFixedAtRoot_;
  int numberFixedNow_;
  bool stoppedOnGap_;
  bool eventHappened_;
  int numberLongStrong_;
  int numberOldActiveCuts_;
  int numberNewCuts_;
  int sizeMiniTree_;
  int searchStrategy_;
  int numberStrongIterations_;
  int strongInfo_[3];
  OsiBabSolver * solverCharacteristics_;
  bool resolveAfterTakeOffCuts_;
#if NEW_UPDATE_OBJECT>1
  int numberUpdateItems_;
  int maximumNumberUpdateItems_;
  CbcObjectUpdateData * updateItems_;
#endif

  int numberThreads_;
  int threadMode_;
};
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

---