CbcModel.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcModel_H
#define CbcModel_H
#include <string>
#include <vector>
#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "OsiBranchingObject.hpp"
#include "OsiCuts.hpp"
#include "CoinWarmStartBasis.hpp"
#include "CbcCompareBase.hpp"
#include "CbcCountRowCut.hpp"
#include "CbcMessage.hpp"
#include "CbcEventHandler.hpp"
#include "ClpDualRowPivot.hpp"
 
class CbcCutGenerator;
class CbcBaseModel;
class OsiRowCut;
class OsiBabSolver;
class OsiRowCutDebugger;
class CglCutGenerator;
class CglStored;
class CbcCutModifier;
class CglTreeProbingInfo;
class CbcHeuristic;
class OsiObject;
class CbcThread;
class CbcTree;
class CbcStrategy;
class CbcSymmetry;
class CbcFeasibilityBase;
class CbcStatistics;
class CbcFullNodeInfo;
class CbcEventHandler;
class CglPreProcess;
class OsiClpSolverInterface;
class ClpNodeStuff;
 
// #define CBC_CHECK_BASIS 1
 
//#############################################################################
 
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
  inline CglPreProcess *preProcess() const
  {
    return preProcess_;
  }
  inline void setPreProcess(CglPreProcess *preProcess)
  {
    preProcess_ = preProcess;
  }
  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();
  const OsiSolverInterface *postProcessedSolver(int solutionType = 1);
 
  void AddIntegers();
  void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible);
  void flipModel();
  int cleanBounds(OsiSolverInterface *solver, char *cleanVariables);
  char *setupCleanVariables();
 
 
  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);
  void addSOSEtcToSolver();
 
#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 bool modelFlipped() const
  {
    return (moreSpecialOptions2_&67108864)!=0;
  }
  inline double trueObjValue(double value) const
  {
    return (moreSpecialOptions2_&67108864)==0 ? value : -value;
  }
  inline double trueBestObjValue() const
  {
    return (moreSpecialOptions2_&67108864)==0 ? bestObjective_ : -bestObjective_;
  }
  inline double trueCutoff() const
  {
    return (moreSpecialOptions2_&67108864)==0 ?
      dblParam_[CbcCurrentCutoff] : -dblParam_[CbcCurrentCutoff]; 
  }
 
  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;
  void lockThread();
  void unlockThread();
  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);
 
  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);
  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_;
  }
  void deleteNode(CbcNode * node);
  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 setSymmetryInfo(CbcSymmetry * info)
  {
    symmetryInfo_ = info;
  }
  void zapSymmetry();
  inline CbcSymmetry *rootSymmetryInfo() const
  {
    return rootSymmetryInfo_;
  }
  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 > > &mipstart)
  {
    this->mipStart_ = mipstart;
  }
 
  void setKeepNamesPreproc( bool _keep ) 
  {
    this->keepNamesPreproc = _keep;
  }
 
  bool getKeepNamesPreproc() const 
  {
    return keepNamesPreproc;
  }
 
  void setMIPStart(int count, const char **colNames, const double colValues[]);
 
 
  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_;
 
  bool keepNamesPreproc;
 
  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_;
  CglPreProcess *preProcess_;
  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_;
  CbcSymmetry *rootSymmetryInfo_;
  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[], CbcModel &babSolver);
// four ways of calling
int callCbc(const char *input2, OsiClpSolverInterface &solver1);
int callCbc(const char *input2);
int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
int callCbc(const std::string input2);
// When we want to load up CbcModel with options first
void CbcMain0(CbcModel &babSolver);
int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
// two ways of calling
int callCbc(const char *input2, CbcModel &babSolver);
int callCbc(const std::string input2, CbcModel &babSolver);
// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
// For uniform setting of cut and heuristic options
void setCutAndHeuristicOptions(CbcModel &model);
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/