BonChooseVariable.hpp

Go to the documentation of this file.

// Copyright (C) 2006, 2008 International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef BonChooseVariable_H
#define BonChooseVariable_H

#include "OsiChooseVariable.hpp"
#ifdef BONMIN_CURVATURE_BRANCHING
#include "BonCurvatureEstimator.hpp"
#endif
#include "BonOsiTMINLPInterface.hpp"
#include "CoinMessageHandler.hpp"
#include "BonBabSetupBase.hpp"
// Forward declaration
class CbcModel;

#define OLD_USEFULLNESS

namespace Bonmin
{

  class HotInfo : public OsiHotInfo {
    public:
    HotInfo();

    HotInfo( OsiSolverInterface * solver,
             const OsiBranchingInformation *info,
             const OsiObject * const * objects, int whichObject);

    HotInfo(const HotInfo & other);

    HotInfo & operator=(const HotInfo & rhs);

    virtual OsiHotInfo * clone() const;

    virtual ~HotInfo();

    int updateInformation( const OsiSolverInterface * solver, const OsiBranchingInformation * info,
                           OsiChooseVariable * choose);

    double upInfeasibility() const{
     return infeasibilities_[1];
    }

    double downInfeasibility() const{
     return infeasibilities_[0];
    }


    void setUpInfeasibility(double x){
      assert(branchingObject_->numberBranches()==2);
      infeasibilities_[1] = x;
    }

    void setDownInfeasibility(double x){
      assert(branchingObject_->numberBranches()==2);
      infeasibilities_[0] = x;
    }
    private:
    vector<double> infeasibilities_; 
  };

  class BonChooseVariable : public OsiChooseVariable
  {
  protected:
  virtual int doStrongBranching( OsiSolverInterface * solver, 
                                 OsiBranchingInformation *info,
                                 int numberToDo, int returnCriterion);
#ifndef OLD_USEFULLNESS

    enum CandidateSortCriterion {
      DecrPs = 0,
      IncrPs,
      DecrInfeas,
      IncrInfeas};
#endif

    enum StrongStatus{
      NotDone=-1,
      Feasible,
      Infeasible ,
      NotFinished };
  public:
    enum Messages_Types {
      PS_COST_HISTORY = 0,
      PS_COST_MULT,
      PS_COST_ESTIMATES,
      CANDIDATE_LIST,
      CANDIDATE_LIST2,
      CANDIDATE_LIST3,
      SB_START,
      SB_HEADER,
      SB_RES,
      BRANCH_VAR,
      CHOSEN_VAR,
      UPDATE_PS_COST,
      BON_CHOOSE_MESSAGES_DUMMY_END
    };

  class Messages : public CoinMessages
    {
    public:
      Messages();
    };

    void passInMessageHandler(CoinMessageHandler * handler) {
      int logLevel = handler_->logLevel();
      delete handler_;
      handler_ = handler->clone();
      handler_->setLogLevel(logLevel);
    }

    CoinMessageHandler& message(Messages_Types type) const {
      return handler_->message(type, messages_);
    }
    enum DoStrongReturnStatuses{
      provenInfeasible = -1 ,
      doneNoFixing ,
      doneCanFix ,
      interuptedCanFix ,
      maxTime };

    enum chooseVariableReturnStatuses{
      infeasibleNode = -1,
      hasCandidate ,
      feasibleNode ,
      canFixAndStrongBranch ,
      canFixAndBranch,
      canFixNoCandidate 
    };
    BonChooseVariable (BabSetupBase& b, const OsiSolverInterface* solver);

    BonChooseVariable (const BonChooseVariable &);

    BonChooseVariable & operator= (const BonChooseVariable& rhs);

    virtual OsiChooseVariable * clone() const;

    virtual ~BonChooseVariable ();

    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);

    double maxminCrit(const OsiBranchingInformation* info) const;
    void computeMultipliers(double& upMult, double& downMult) const;
    double computeUsefulness(const double MAXMIN_CRITERION,
        const double upMult, const double dowMult,
        const double value,
        const OsiObject* object, int i,
        double& value2) const;

    virtual int setupList ( OsiBranchingInformation *info, bool initialize);

    virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
    virtual void updateInformation(const OsiBranchingInformation *info,
        int branch, OsiHotInfo * hotInfo);
#if 1
    virtual void updateInformation( int whichObject, int branch,
        double changeInObjective, double changeInValue,
        int status);
#endif

    void setCbcModel(CbcModel* cbc_model)
    {
      cbc_model_ = cbc_model;
    }

    void setOnlyPseudoWhenTrusted(bool only_pseudo_when_trusted)
    {
      only_pseudo_when_trusted_ = only_pseudo_when_trusted;
    }


    const OsiPseudoCosts & pseudoCosts() const{
      return pseudoCosts_;}

    OsiPseudoCosts & pseudoCosts() {
      return pseudoCosts_;}
  protected:

    Ipopt::SmartPtr<Ipopt::Journalist> jnlst_;

    int bb_log_level_;

    vector<HotInfo> results_;

    int determineStatus(OsiSolverInterface * solver) const {
      if (solver->isProvenOptimal())
        return 0; // optimal
      else if (solver->isIterationLimitReached()
               &&!solver->isDualObjectiveLimitReached())
        return 2; // unknown 
      else
        return 1; // infeasible
    }

  private:
    BonChooseVariable ();

    double time_limit_;

    double start_time_;
  protected:
    CbcModel* cbc_model_;

    bool only_pseudo_when_trusted_;

    int number_not_trusted_;

    CoinMessageHandler * handler_;

    Messages messages_;
    // ToDo: Make this options
    double maxmin_crit_no_sol_;
    double maxmin_crit_have_sol_;
    double setup_pseudo_frac_;
    int numberBeforeTrustedList_;
    int numberStrongRoot_;
    int numberStrongBackup_;
    int numberLookAhead_;
#ifndef OLD_USEFULLNESS

    CandidateSortCriterion sortCrit_;
#endif

    int minNumberStrongBranch_;
    OsiPseudoCosts pseudoCosts_;
    int trustStrongForPseudoCosts_;
   

    bool isRootNode(const OsiBranchingInformation *info) const;

    static const std::string CNAME;
  };

}
#endif