SbbModel.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef SbbModel_H
#define SbbModel_H

#include <string>
#include <vector>

#include "CoinFinite.hpp"
#include "CoinMessageHandler.hpp"
#include "OsiSolverInterface.hpp"
#include "OsiCuts.hpp"
#include "CoinWarmStartBasis.hpp"
#include "SbbCompareBase.hpp"
#include "SbbMessage.hpp"

//class OsiSolverInterface;

class SbbCutGenerator;
class OsiRowCut;
class OsiRowCutDebugger;
class CglCutGenerator;
class SbbHeuristic;
class SbbObject;

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

class SbbModel  {
  
public:

enum SbbIntParam {
  SbbMaxNumNode=0,
  SbbMaxNumSol,
  SbbFathomDiscipline,
  SbbLastIntParam
};

enum SbbDblParam {
  SbbIntegerTolerance=0,
  SbbInfeasibilityWeight,
  SbbCutoffIncrement,
  SbbAllowableGap,
  SbbMaximumSeconds,
  SbbLastDblParam
};

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

public:


    void initialSolve(); 

     void branchAndBound();

    bool solveWithCuts(OsiCuts & cuts, int numberTries,SbbNode * node,
                       int & numberOldActiveCuts, int & numberNewCuts,
                       int & maximumWhich, int * & whichGenerator);

    bool resolve();


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

  SbbModel * integerPresolve(bool weak=false);

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


  void originalModel(SbbModel * 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);




  inline int numberObjects() const { return numberObjects_;};

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

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

  void deleteObjects();

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

  void synchronizeModel() ;

  void findIntegers(bool startAgain);
  

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


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

  inline double getCutoff() const
  { double value ;
    solver_->getDblParam(OsiDualObjectiveLimit,value) ;
    return value * solver_->getObjSense() ; } ;

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

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

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

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

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

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

  void setForcePriority(int value) 
  { forcePriority_=value;};
  int getForcePriority() const
  { return forcePriority_;};
  
  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_;};

  void setNumberStrong(int number);
  inline int numberStrong() const
  { return numberStrong_;};

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

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


    bool isAbandoned() const;
    bool isProvenOptimal() const;
    bool isProvenInfeasible() const;
    bool isNodeLimitReached() const;
    bool isSolutionLimitReached() const;
    int getIterationCount() const
    { return solver_->getIterationCount();};
    int getNodeCount() const
    { return numberNodes_;};
    inline int status() const
    { return status_;};
  

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

  int numberRowsAtContinuous() const
  { return numberRowsAtContinuous_;};

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

  inline int numberIntegers() const
  { return numberIntegers_;};
  // Integer variables
  inline const int * integerVariable() const 
  { return integerVariable_;};
  
  const double * getColLower() const
  { return solver_->getColLower();};
  
  const double * getColUpper() const
  { return solver_->getColUpper();};
  
  const char * getRowSense() const
  { return solver_->getRowSense();};
  
  const double * getRightHandSide() const
  { return solver_->getRightHandSide();};
  
  const double * getRowRange() const
  { return solver_->getRowRange();};
  
  const double * getRowLower() const
  { return solver_->getRowLower();};
  
  const double * getRowUpper() const
  { return solver_->getRowUpper();};
  
  const double * getObjCoefficients() const
  { return solver_->getObjCoefficients();};
  
  double getObjSense() const
  { return solver_->getObjSense();};
  
  bool isContinuous(int colIndex) const
  { return solver_->isContinuous(colIndex);};
  
  bool isBinary(int colIndex) const
  { return solver_->isBinary(colIndex);};
  
  bool isInteger(int colIndex) const
  { return solver_->isInteger(colIndex);};
  
  bool isIntegerNonBinary(int colIndex) const
  { return solver_->isIntegerNonBinary(colIndex);};
  
  bool isFreeBinary(int colIndex) const
  { return solver_->isFreeBinary(colIndex) ;};
  
  const CoinPackedMatrix * getMatrixByRow() const
  { return solver_->getMatrixByRow();};
  
  const CoinPackedMatrix * getMatrixByCol() const
  { return solver_->getMatrixByCol();};
  
  double getInfinity() const
  { return solver_->getInfinity();};
  
  

  void setBestSolution(SBB_Message how,
                       double & objectiveValue, const double *solution,
                       bool fixVariables=false);

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

  inline double * currentSolution() const
  { return currentSolution_;};

  const double * getColSolution() const
  { return solver_->getColSolution();};
  
  const double * getRowPrice() const
  { return solver_->getRowPrice();};
  
  const double * getReducedCost() const
  { return solver_->getReducedCost();};
  
  const double * getRowActivity() const
  { return solver_->getRowActivity();};
  
  double getCurrentObjValue() const
  { return solver_->getObjValue();};
  
  double getObjValue() const
  { return bestObjective_;};
  
  const double * bestSolution() const
  { return bestSolution_;};
  
  int getSolutionCount() const
  { return numberSolutions_;};
  
  void setSolutionCount(int value) 
  { numberSolutions_=value;};
  
  int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;};

  void setObjSense(double s) { solver_->setObjSense(s);};

  inline double getContinuousObjective() const
  { return continuousObjective_;};
  inline void setContinuousObjective(double value)
  { continuousObjective_=value;};
  inline int getContinuousInfeasibilities() const
  { return continuousInfeasibilities_;};
  inline void setContinuousInfeasibilities(int value)
  { continuousInfeasibilities_=value;};

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


  inline SbbBranchDecision * branchingMethod() const
  { return branchingMethod_;};
  inline void setBranchingMethod(SbbBranchDecision * method)
  { branchingMethod_ = method;};
  inline void setBranchingMethod(SbbBranchDecision & method)
  { branchingMethod_ = &method;};


  void reducedCostFix() ;

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

  void takeOffCuts(OsiCuts &cuts, int *whichGenerator,
                     int &numberOldActiveCuts, int &numberNewCuts,
                     bool allowResolve) ;

  int addCuts(SbbNode * node, CoinWarmStartBasis *&lastws);

  void addCuts1(SbbNode * node, CoinWarmStartBasis *&lastws);

  SbbCountRowCut ** addedCuts() const
  { return addedCuts_;};
  int currentNumberCuts() const
  { return currentNumberCuts_;};

  inline int numberCutGenerators() const
  { return numberCutGenerators_;};
  inline SbbCutGenerator ** cutGenerators() const
  { return generator_;};
  inline SbbCutGenerator * cutGenerator(int i) const
  { return generator_[i];};
  void addCutGenerator(CglCutGenerator * generator,
                  int howOften=1, const char * name=NULL,
                  bool normal=true, bool atSolution=false, 
                  bool infeasible=false);


  void addHeuristic(SbbHeuristic * generator);

  void passInPriorities(const int * priorities, bool ifClique,
                        int defaultValue=1000);

  inline const int * priority() const { return priority_;};

  inline int priority(int sequence) const
  { 
    if (priority_)
      return priority_[sequence];
    else
      return 1000;
  };
    
  
  //---------------------------------------------------------------------------


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




    SbbModel(); 
    
    SbbModel(const OsiSolverInterface &);
  
    void assignSolver(OsiSolverInterface *&solver);
  
    SbbModel(const SbbModel &);
  
    SbbModel & operator=(const SbbModel& rhs);
  
     ~SbbModel ();

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

    OsiSolverInterface * continuousSolver() const
    { return continuousSolver_;};
  void gutsOfDestructor();

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

private:


  OsiSolverInterface * solver_;

  bool ourSolver_ ;

  OsiSolverInterface * continuousSolver_;

  CoinMessageHandler * handler_;

  bool defaultHandler_;

  CoinMessages messages_;

  int intParam_[SbbLastIntParam];

  double dblParam_[SbbLastDblParam];

  mutable CoinWarmStart *emptyWarmStart_ ;

  CoinWarmStartBasis *basis_;

  double bestObjective_;

  double * bestSolution_;

  double * currentSolution_;

  OsiCuts globalCuts_;

  double minimumDrop_;
  int numberSolutions_;
  int forcePriority_;
  int numberHeuristicSolutions_;
  int numberNodes_;
  int numberIterations_;
  int status_;
  int numberIntegers_;
  int numberRowsAtContinuous_;
  int maximumNumberCuts_;

  int currentNumberCuts_;

  int maximumDepth_;
  SbbNodeInfo ** walkback_;

  SbbCountRowCut ** addedCuts_;

  int * integerVariable_;
  int strategy_;
  SbbCompareBase * nodeCompare_;
  SbbBranchDecision * branchingMethod_;

  int numberStrong_;

  int printFrequency_;
  int numberCutGenerators_;
  // Cut generators
  SbbCutGenerator ** generator_;
  int numberHeuristics_;
  // Heuristic solvers
  SbbHeuristic ** heuristic_;

  int numberObjects_;

  SbbObject ** object_;

  int * originalColumns_;
  int * priority_;
  int howOftenGlobalScan_;
  double continuousObjective_;
  int continuousInfeasibilities_;
  int maximumCutPassesAtRoot_;
  int maximumCutPasses_;
};

#endif

---