CbcModel.hpp

Go to the documentation of this file.

/* $Id: CbcModel.hpp 1409 2009-12-21 16:59:56Z forrest $ */
// 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"
#include "CbcEventHandler.hpp"
#include "ClpDualRowPivot.hpp"

//class OsiSolverInterface;

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 CbcEventHandler ;
class CglPreProcess;
# ifdef COIN_HAS_CLP
class ClpNodeStuff;
#endif
// #define CBC_CHECK_BASIS 1

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

class CbcModel  {

public:

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

    enum CbcDblParam {
        CbcIntegerTolerance = 0,
        CbcInfeasibilityWeight,
        CbcCutoffIncrement,
        CbcAllowableGap,
        CbcAllowableFractionGap,
        CbcMaximumSeconds,
        CbcCurrentCutoff,
        CbcOptimizationDirection,
        CbcCurrentObjectiveValue,
        CbcCurrentMinimizationObjectiveValue,
        CbcStartSeconds,
        CbcHeuristicGap,
        CbcHeuristicFractionGap,
        CbcSmallestChange,
        CbcSumChange,
        CbcLargestChange,
        CbcSmallChange,
        CbcLastDblParam
    };

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

public:


    void initialSolve();

    void branchAndBound(int doStatistics = 0);
private:

    bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
    int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
                            int & numberNodesOutput, int & status) ;
    void resizeWhichGenerator(int numberNow, int numberAfter);
public:
#ifdef CBC_KEEP_DEPRECATED
    // See if anyone is using these any more!!
    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);
#endif
    void addUpdateInformation(const CbcObjectUpdateData & data);
    int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);

public:
    int resolve(CbcNodeInfo * parent, int whereFrom,
                double * saveSolution = NULL,
                double * saveLower = NULL,
                double * saveUpper = NULL);
    void makeGlobalCuts(int numberRows, const int * which);
    void makeGlobalCut(const OsiRowCut * cut);
    void makeGlobalCut(const OsiRowCut & cut);
    void makeGlobalCut(const OsiColCut * cut);
    void makeGlobalCut(const OsiColCut & 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();

    void AddIntegers();

    void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);



    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 setOptionalInteger(int index);

    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 ;

    bool maximumSecondsReached() 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 setHeuristicGap( double value) {
        return setDblParam(CbcHeuristicGap, value);
    }
    inline double getHeuristicGap() const {
        return getDblParam(CbcHeuristicGap);
    }

    inline bool setHeuristicFractionGap( double value) {
        return setDblParam(CbcHeuristicFractionGap, value);
    }
    inline double getHeuristicFractionGap() const {
        return getDblParam(CbcHeuristicFractionGap);
    }
    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 int whenCuts() const {
        return whenCuts_;
    }
    inline void setWhenCuts(int value) {
        whenCuts_ = value;
    }
    bool doCutsNow(int allowForTopOfTree) const;

    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_;
    }
    inline int currentDepth() const {
        return currentDepth_;
    }

    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 void incrementIterationCount(int value) {
        numberIterations_ += value;
    }
    inline int getNodeCount() const {
        return numberNodes_;
    }
    inline void incrementNodeCount(int value) {
        numberNodes_ += value;
    }
    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 {
        assert (integerInfo_);
        assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
        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,
                         int fixVariables = 0);
    void setBestObjectiveValue( double objectiveValue);
    CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
            double objValue,
            const double * solution);

    double checkSolution(double cutoff, double * solution,
                         int 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 getSolverObjValue() const {
        return solver_->getObjValue() * solver_->getObjSense() ;
    }

    inline double * bestSolution() const {
        return bestSolution_;
    }
    void setBestSolution(const double * solution, int numberColumns,
                         double objectiveValue, bool check = false);

    inline int getSolutionCount() const {
        return numberSolutions_;
    }

    inline void setSolutionCount(int value) {
        numberSolutions_ = value;
    }
    int numberSavedSolutions() const;
    inline int maximumSavedSolutions() const {
        return maximumSavedSolutions_;
    }
    void setMaximumSavedSolutions(int value);
    const double * savedSolution(int which) const;
    double savedSolutionObjective(int which) const;

    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 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 void setStrategy(CbcStrategy * strategy) {
        strategy_ = strategy;
    }
    inline CbcModel * parentModel() const {
        return parentModel_;
    }
    inline void setParentModel(CbcModel & parentModel) {
        parentModel_ = &parentModel;
    }


    void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
                      int before = -1);
    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 setDefaultHandler(bool yesNo) {
        defaultHandler_ = yesNo;
    }
    //---------------------------------------------------------------------------


    inline void setSpecialOptions(int value) {
        specialOptions_ = value;
    }
    inline int specialOptions() const {
        return specialOptions_;
    }
    inline bool normalSolver() const {
        return (specialOptions_&16) == 0;
    }
    inline void setMoreSpecialOptions(int value) {
        moreSpecialOptions_ = value;
    }
    inline int moreSpecialOptions() const {
        return moreSpecialOptions_;
    }
#ifdef COIN_HAS_CLP
    void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
#endif
    inline bool ownObjects() const {
        return ownObjects_;
    }
    void checkModel();
    //---------------------------------------------------------------------------


    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 cloneHandler = 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 gutsOfCopy(const CbcModel & rhs, int mode = 0);
    void moveInfo(const CbcModel & rhs);


    CbcThread * masterThread() const {
        return masterThread_;
    }
    CbcNodeInfo ** walkback() const {
        return walkback_;
    }
    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 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;
        }
    }
    bool isLocked() const;
#ifdef CBC_THREAD

    void lockThread();
    void unlockThread();
#else
    inline void lockThread() {}
    inline void unlockThread() {}
#endif

    void setInfoInChild(int type, CbcThread * info);
    void moveToModel(CbcModel * baseModel, int mode);
    int splitModel(int numberModels, CbcModel ** model,
                   int numberNodes);
    void startSplitModel(int numberIterations);
    void mergeModels(int numberModel, CbcModel ** model,
                     int numberNodes);


    int getNodeCount2() const {
        return numberNodes2_;
    }
    void setPointers(const OsiSolverInterface * solver);
    int reducedCostFix() ;
    void synchronizeHandlers(int makeDefault);
    void saveExtraSolution(const double * solution, double objectiveValue);
    void saveBestSolution(const double * solution, double objectiveValue);
    void deleteSolutions();
    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 ;

    int takeOffCuts(OsiCuts &cuts,
                    bool allowResolve, OsiCuts * saveCuts,
                    int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;

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

    bool 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 synchronizeNumberBeforeTrust(int type = 0);
    void zapIntegerInformation(bool leaveObjects = true);
    int cliquePseudoCosts(int doStatistics);
    void pseudoShadow(int type);
    void fillPseudoCosts(double * downCosts, double * upCosts,
                         int * priority = NULL,
                         int * numberDown = NULL, int * numberUp = NULL,
                         int * numberDownInfeasible = NULL,
                         int * numberUpInfeasible = NULL) const;
    void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
    void adjustHeuristics();
    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 CoinThreadRandom * randomNumberGenerator() {
        return &randomNumberGenerator_;
    }
    inline void setNumberStrongIterations(int number) {
        numberStrongIterations_ = number;
    }
    inline int numberStrongIterations() const {
        return numberStrongIterations_;
    }
    inline int maximumNumberIterations() const {
        return maximumNumberIterations_;
    }
    inline void setMaximumNumberIterations(int value) {
        maximumNumberIterations_ = value;
    }
# ifdef COIN_HAS_CLP
    inline void setFastNodeDepth(int value) {
        fastNodeDepth_ = value;
    }
    inline int fastNodeDepth() const {
        return fastNodeDepth_;
    }
    inline int continuousPriority() const {
        return continuousPriority_;
    }
    inline void setContinuousPriority(int value) {
        continuousPriority_ = value;
    }
    inline void incrementExtra(int nodes, int iterations) {
        numberExtraNodes_ += nodes;
        numberExtraIterations_ += iterations;
    }
#endif
    inline int numberExtraIterations() const {
        return numberExtraIterations_;
    }
    void incrementStrongInfo(int numberTimes, int numberIterations,
                             int numberFixed, bool ifInfeasible);
    inline const int * strongInfo() const {
        return strongInfo_;
    }

    inline int * mutableStrongInfo() {
        return strongInfo_;
    }
    CglStored * storedRowCuts() const {
        return storedRowCuts_;
    }
    void setStoredRowCuts(CglStored * cuts) {
        storedRowCuts_ = cuts;
    }
    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;
    }
    void redoWalkBack();

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

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 ** savedSolutions_;

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

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

    int currentNumberCuts_;

    int maximumDepth_;
    CbcNodeInfo ** walkback_;
    CbcNodeInfo ** lastNodeInfo_;
    const OsiRowCut ** lastCut_;
    int lastDepth_;
    int lastNumberCuts2_;
    int maximumCuts_;
    int * lastNumberCuts_;

    CbcCountRowCut ** addedCuts_;

    OsiRowCut * nextRowCut_;

    CbcNode * currentNode_;

    int * integerVariable_;
    char * integerInfo_;
    double * continuousSolution_;
    int * usedInSolution_;
    int specialOptions_;
    int moreSpecialOptions_;
    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_;
    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 COIN_HAS_CLP
    int fastNodeDepth_;
#endif

# ifdef CBC_ONLY_CLP
    ClpEventHandler *eventHandler_ ;
# else
    CbcEventHandler *eventHandler_ ;
# endif

    int numberObjects_;

    OsiObject ** object_;
    bool ownObjects_;

    int * originalColumns_;
    int howOftenGlobalScan_;
    int numberGlobalViolations_;
    int numberExtraIterations_;
    int numberExtraNodes_;
    double continuousObjective_;
    double originalContinuousObjective_;
    int continuousInfeasibilities_;
    int maximumCutPassesAtRoot_;
    int maximumCutPasses_;
    int preferredWay_;
    int currentPassNumber_;
    int maximumWhich_;
    int maximumRows_;
    int currentDepth_;
    mutable CoinThreadRandom randomNumberGenerator_;
    CoinWarmStartBasis workingBasis_;
    int * whichGenerator_;
    int maximumStatistics_;
    CbcStatistics ** statistics_;
    int maximumDepthActual_;
    double numberDJFixed_;
    CglTreeProbingInfo * probingInfo_;
    int numberFixedAtRoot_;
    int numberFixedNow_;
    bool stoppedOnGap_;
    mutable bool eventHappened_;
    int numberLongStrong_;
    int numberOldActiveCuts_;
    int numberNewCuts_;
    int searchStrategy_;
    int numberStrongIterations_;
    int strongInfo_[7];
    OsiBabSolver * solverCharacteristics_;
    bool resolveAfterTakeOffCuts_;
    int maximumNumberIterations_;
    int continuousPriority_;
    int numberUpdateItems_;
    int maximumNumberUpdateItems_;
    CbcObjectUpdateData * updateItems_;
    CglStored * storedRowCuts_;
    int numberThreads_;
    int threadMode_;
    CbcBaseModel * master_;
    CbcThread * masterThread_;
};
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