CouenneChooseStrong.hpp

Go to the documentation of this file.

/* $Id: CouenneChooseStrong.hpp 792 2012-01-24 17:24:15Z pbelotti $
 *
 * Name:    CouenneChooseStrong.hpp
 * Authors: Andreas Waechter, IBM Corp.
 * Purpose: Strong branching object for Couenne
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNECHOOSESTRONG_HPP
#define COUENNECHOOSESTRONG_HPP

#include "BonChooseVariable.hpp"
#include "CouenneJournalist.hpp"

namespace Couenne {

class CouenneProblem;

template <class T> class CouenneSolverInterface;

class CouenneChooseStrong : public Bonmin::BonChooseVariable {

public:

  CouenneChooseStrong (Bonmin::BabSetupBase& b, CouenneProblem* problem, JnlstPtr jnlst);

  CouenneChooseStrong (const CouenneChooseStrong &);

  CouenneChooseStrong & operator= (const CouenneChooseStrong& rhs);

  virtual OsiChooseVariable * clone() const;

  virtual ~CouenneChooseStrong ();

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

  // actually setting up the list
  int gutsOfSetupList(OsiBranchingInformation *info, bool initialize);

  virtual int doStrongBranching (OsiSolverInterface * OsiSolver, 
                                 OsiBranchingInformation *info,
                                 int numberToDo, int returnCriterion);

  virtual bool feasibleSolution (const OsiBranchingInformation * info,
                                 const double * solution,
                                 int numberObjects,
                                 const OsiObject ** objects);

  virtual int chooseVariable (OsiSolverInterface * solver,
                              OsiBranchingInformation *info,
                              bool fixVariables);

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

private:

  CouenneChooseStrong ();
  
  // print object violations
  void printObjViol(OsiBranchingInformation *info);

  // Due to possible fixing during strong branching, must check
  // that variable reference vInd for the selected object (if not -1)
  // is not fixed or has a current value inside bounds.
  // Return value is:
  // 0: OsiSimpleInteger with upper[vInd] == lower[vInd]
  // 1: OsiSimpleInteger with upper[vInd] > lower[vInd] and
  //    info->solution[vInd] outside bounds
  // 2: CouenneBranchingObject with upper[vInd] == lower[vInd]
  // 3: otherwise (meaning good object)
  int goodCandidate(OsiSolverInterface *solver, 
                    OsiBranchingInformation *info,
                    OsiObject **object, const int iObject, const double prec);

  bool saveBestCand(OsiObject **object, const int iObject, 
                    const double value, 
                    const double upEstimate, 
                    const double downEstimate,
                    double &bestVal1, 
                    double &bestVal2, int &bestIndex,
                    int &bestWay);

protected:

  int simulateBranch (OsiObject *Object,
                      OsiBranchingInformation *info,
                      OsiBranchingObject *branch,
                      OsiSolverInterface *solver,
                      Bonmin::HotInfo * result,
                      int direction);

  CouenneProblem *problem_;

  bool pseudoUpdateLP_;

  bool estimateProduct_;

  JnlstPtr jnlst_;

  double branchtime_;
};

}

#endif