CbcModel.hpp

Go to the documentation of this file.

/* $Id: CbcModel.hpp 2206 2015-07-07 20:44:40Z stefan $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcModel_H
#define CbcModel_H
#include <string>
#include <vector>
#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "OsiBranchingObject.hpp"
#include "OsiCuts.hpp"
#include "CoinWarmStartBasis.hpp"
#include "CbcCompareBase.hpp"
#include "CbcCountRowCut.hpp"
#include "CbcMessage.hpp"
#include "CbcEventHandler.hpp"
#include "ClpDualRowPivot.hpp"
 
 
class CbcCutGenerator;
class CbcBaseModel;
class OsiRowCut;
class OsiBabSolver;
class OsiRowCutDebugger;
class CglCutGenerator;
class CglStored;
class CbcCutModifier;
class CglTreeProbingInfo;
class CbcHeuristic;
class OsiObject;
class CbcThread;
class CbcTree;
class CbcStrategy;
class CbcSymmetry;
class CbcFeasibilityBase;
class CbcStatistics;
class CbcFullNodeInfo;
class CbcEventHandler ;
class CglPreProcess;
class OsiClpSolverInterface;
class ClpNodeStuff;
 
// #define CBC_CHECK_BASIS 1
 
//#############################################################################
 
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);
    int makeGlobalCut(const OsiRowCut * cut);
    int makeGlobalCut(const OsiRowCut & cut);
    void makeGlobalCut(const OsiColCut * cut);
    void makeGlobalCut(const OsiColCut & cut);
  void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL);
    void makeGlobalCuts();
    inline const int * whichGenerator() const
    { return whichGenerator_;}
 
 
    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);
    void flipModel();
 
 
 
    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);
 
#ifdef SWITCH_VARIABLES
    int findSwitching();
    int fixAssociated(OsiSolverInterface * solver,int cleanBasis);
    int checkAssociated(const OsiSolverInterface * solver,
                        const double * solution, int printLevel);
#endif
 
 
    //---------------------------------------------------------------------------
 
    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);
    }
    bool canStopOnGap() const;
 
    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_;
    }
    inline void setCurrentPassNumber(int value) {
        currentPassNumber_ = value;
    }
 
    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 const CbcFullNodeInfo * topOfTree() const
    { return topOfTree_;}
    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,
                            int numberGood=COIN_INT_MAX) ;
    OsiRowCut * conflictCut(const OsiSolverInterface * solver, bool & localCuts);
 
    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 getExtraNodeCount() const {
       return numberExtraNodes_;
    }
    inline int getFathomCount() const {
       return numberFathoms_;
    }
    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);
 
    virtual 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;
    void deleteSavedSolution(int which);
 
    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;
    }
    inline CbcModel * heuristicModel() const
    { return heuristicModel_;}
    inline void setHeuristicModel(CbcModel * model)
    { heuristicModel_ = model;}
 
    // 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 strongStrategy() const {
        return strongStrategy_;
    }
    inline void setStrongStrategy(int value) {
        strongStrategy_ = 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 void setNumberHeuristics(int value) {
        numberHeuristics_ = value;
    }
    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 bool defaultHandler() const {
        return defaultHandler_;
    }
    //---------------------------------------------------------------------------
 
 
    inline void setSpecialOptions(int value) {
        specialOptions_ = value;
    }
    inline int specialOptions() const {
        return specialOptions_;
    }
    inline void setRandomSeed(int value) {
        randomSeed_ = value;
    }
    inline int getRandomSeed() const {
        return randomSeed_;
    }
    inline void setMultipleRootTries(int value) {
        multipleRootTries_ = value;
    }
    inline int getMultipleRootTries() const {
        return multipleRootTries_;
    }
    inline void sayEventHappened()
    { eventHappened_=true;}
    inline bool normalSolver() const {
        return (specialOptions_&16) == 0;
    }
    inline bool waitingForMiniBranchAndBound() const {
        return (specialOptions_&1048576) != 0;
    }
    inline void setMoreSpecialOptions(int value) {
        moreSpecialOptions_ = value;
    }
    inline int moreSpecialOptions() const {
        return moreSpecialOptions_;
    }
    inline void setMoreSpecialOptions2(int value) {
        moreSpecialOptions2_ = value;
    }
    inline int moreSpecialOptions2() const {
        return moreSpecialOptions2_;
    }
    inline void setCutoffAsConstraint(bool yesNo) {
      cutoffRowNumber_ = (yesNo) ? -2 : -1;
    }
    inline void setUseElapsedTime(bool yesNo) {
        if (yesNo)
          moreSpecialOptions_ |= 131072;
        else
          moreSpecialOptions_ &= ~131072;
    }
    inline bool useElapsedTime() const {
        return (moreSpecialOptions_&131072)!=0;
    }
    inline void * temporaryPointer() const
    { return temporaryPointer_;}
    inline void setTemporaryPointer(void * pointer)
    { temporaryPointer_=pointer;}
    void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
    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);
 
    virtual CbcModel *clone (bool cloneHandler);
 
    CbcModel & operator=(const CbcModel& rhs);
 
    virtual ~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);
 
 
    static bool haveMultiThreadSupport();
    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;
        }
    }
    inline CbcBaseModel * master() const
    { return master_;}
    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);
#ifdef CLP_RESOLVE
    int resolveClp(OsiClpSolverInterface * solver, int type);
#endif
 
    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 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 CbcRowCuts * globalCuts() {
        return &globalCuts_;
    }
    inline void zapGlobalCuts() {
        globalCuts_ = CbcRowCuts();
    }
    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;
    }
    inline CbcSymmetry * symmetryInfo() const
    { return symmetryInfo_;}  
    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, int fathoms=1) {
        numberExtraNodes_ += nodes;
        numberExtraIterations_ += iterations;
        numberFathoms_ += fathoms;
    }
    inline void zeroExtra() {
        numberExtraNodes_ = 0;
        numberExtraIterations_ = 0;
        numberFathoms_ = 0;
    }
    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();
    
    void setMIPStart( const std::vector< std::pair< std::string, double > > &MIPS ) {
       this->mipStart_ = MIPS;
    }
 
    const std::vector< std::pair< std::string, double > > &getMIPStart() {
       return this->mipStart_;
    }
 
 
//---------------------------------------------------------------------------
 
private:
 
 
    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_;
    std::vector< std::pair< std::string, double > > mipStart_;
    CoinWarmStartBasis bestSolutionBasis_ ;
    CbcRowCuts globalCuts_;
    CbcRowCuts * globalConflictCuts_;
 
    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 cutoffRowNumber_;
    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_;
    int moreSpecialOptions2_;
    CbcCompareBase * nodeCompare_;
    CbcFeasibilityBase * problemFeasibility_;
    CbcTree * tree_;
    CbcFullNodeInfo * topOfTree_;
    CbcModel * subTreeModel_;
    CbcModel * heuristicModel_;
    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_;
    void * temporaryPointer_;
    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_;
    int fastNodeDepth_;
# ifdef CBC_ONLY_CLP
    ClpEventHandler *eventHandler_ ;
# else
    CbcEventHandler *eventHandler_ ;
# endif
    CbcSymmetry * symmetryInfo_;
    int numberObjects_;
 
    OsiObject ** object_;
    bool ownObjects_;
 
    int * originalColumns_;
    int howOftenGlobalScan_;
    int numberGlobalViolations_;
    int numberExtraIterations_;
    int numberExtraNodes_;
    int numberFathoms_;
    double continuousObjective_;
    double originalContinuousObjective_;
    int continuousInfeasibilities_;
    int maximumCutPassesAtRoot_;
    int maximumCutPasses_;
    int preferredWay_;
    int currentPassNumber_;
    int maximumWhich_;
    int maximumRows_;
    int randomSeed_;
    int multipleRootTries_;
    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 strongStrategy_;
    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_;
    int numberGlobalCutsIn_;
    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