/home/coin/SVN-release/CoinAll-1.1.0/Osi/src/OsiChooseVariable.hpp

Go to the documentation of this file.

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

#include <string>
#include <vector>

#include "CoinWarmStartBasis.hpp"
#include "OsiBranchingObject.hpp"

class OsiSolverInterface;
class OsiHotInfo;

class OsiChooseVariable  {
 
public:
    
  OsiChooseVariable ();

  OsiChooseVariable (const OsiSolverInterface * solver);

  OsiChooseVariable (const OsiChooseVariable &);
   
  OsiChooseVariable & operator= (const OsiChooseVariable& rhs);

  virtual OsiChooseVariable * clone() const;

  virtual ~OsiChooseVariable ();

  virtual int setupList ( OsiBranchingInformation *info, bool initialize);
  virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
  bool feasibleSolution(const OsiBranchingInformation * info,
                        const double * solution,
                        int numberObjects,
                        const OsiObject ** objects);
  void saveSolution(const OsiSolverInterface * solver);
  void clearGoodSolution();
  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
  inline double goodObjectiveValue() const
  { return goodObjectiveValue_;}
  inline double upChange() const
  { return upChange_;}
  inline double downChange() const
  { return downChange_;}
  inline const double * goodSolution() const
  { return goodSolution_;}
  inline int bestObjectIndex() const
  { return bestObjectIndex_;}
  inline void setBestObjectIndex(int value)
  { bestObjectIndex_ = value;}
  inline int bestWhichWay() const
  { return bestWhichWay_;}
  inline void setBestWhichWay(int value)
  { bestWhichWay_ = value;}
  inline int firstForcedObjectIndex() const
  { return firstForcedObjectIndex_;}
  inline void setFirstForcedObjectIndex(int value)
  { firstForcedObjectIndex_ = value;}
  inline int firstForcedWhichWay() const
  { return firstForcedWhichWay_;}
  inline void setFirstForcedWhichWay(int value)
  { firstForcedWhichWay_ = value;}
  inline int numberUnsatisfied() const
  {return numberUnsatisfied_;}
  inline int numberStrong() const
  { return numberStrong_;}
  inline void setNumberStrong(int value)
  { numberStrong_ = value;}
  inline int numberOnList() const
  { return numberOnList_;}
  inline int numberStrongDone() const
  { return numberStrongDone_;}
  inline int numberStrongIterations() const
  { return numberStrongIterations_;}
  inline int numberStrongFixed() const
  { return numberStrongFixed_;}
  inline const int * candidates() const
  { return list_;}
  inline bool trustStrongForBound() const
  { return trustStrongForBound_;}
  inline void setTrustStrongForBound(bool yesNo)
  { trustStrongForBound_ = yesNo;}
  inline bool trustStrongForSolution() const
  { return trustStrongForSolution_;}
  inline void setTrustStrongForSolution(bool yesNo)
  { trustStrongForSolution_ = yesNo;}
  void setSolver (const OsiSolverInterface * solver);
  inline int status() const
  { return status_;}
  inline void setStatus(int value)
  { status_ = value;}


protected:
  // Data
  double goodObjectiveValue_;
  double upChange_;
  double downChange_;
  double * goodSolution_;
  int * list_;
  double * useful_;
  const OsiSolverInterface * solver_;
  /* Status -
     -1 Node is infeasible
     0  Normal termination - we have a candidate
     1  All looks satisfied - no candidate
     2  We can change the bound on a variable - but we also have a strong branching candidate
     3  We can change the bound on a variable - but we have a non-strong branching candidate
     4  We can change the bound on a variable - no other candidates
  */
  int status_;
  int bestObjectIndex_;
  int bestWhichWay_;
  int firstForcedObjectIndex_;
  int firstForcedWhichWay_;
  int numberUnsatisfied_;
  int numberStrong_;
  int numberOnList_;
  int numberStrongDone_;
  int numberStrongIterations_;
  int numberStrongFixed_;
  bool trustStrongForBound_;
  bool trustStrongForSolution_;
};

class OsiPseudoCosts {
protected:
   // Data
  double * upTotalChange_;
  double * downTotalChange_;
  int * upNumber_;
  int * downNumber_;
  int numberObjects_;
  int numberBeforeTrusted_;

private:
  void gutsOfDelete();
  void gutsOfCopy(const OsiPseudoCosts& rhs);

public:
  OsiPseudoCosts();
  virtual ~OsiPseudoCosts();
  OsiPseudoCosts(const OsiPseudoCosts& rhs);
  OsiPseudoCosts& operator=(const OsiPseudoCosts& rhs);

  inline int numberBeforeTrusted() const
  { return numberBeforeTrusted_; }
  inline void setNumberBeforeTrusted(int value)
  { numberBeforeTrusted_ = value; }
  void initialize(int n);
  inline int numberObjects() const
  { return numberObjects_; }

  inline double* upTotalChange()               { return upTotalChange_; }
  inline const double* upTotalChange() const   { return upTotalChange_; }

  inline double* downTotalChange()             { return downTotalChange_; }
  inline const double* downTotalChange() const { return downTotalChange_; }

  inline int* upNumber()                       { return upNumber_; }
  inline const int* upNumber() const           { return upNumber_; }

  inline int* downNumber()                     { return downNumber_; }
  inline const int* downNumber() const         { return downNumber_; }

  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
};

class OsiChooseStrong  : public OsiChooseVariable {
 
public:
    
  OsiChooseStrong ();

  OsiChooseStrong (const OsiSolverInterface * solver);

  OsiChooseStrong (const OsiChooseStrong &);
   
  OsiChooseStrong & operator= (const OsiChooseStrong& rhs);

  virtual OsiChooseVariable * clone() const;

  virtual ~OsiChooseStrong ();

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

  inline int shadowPriceMode() const
  { return shadowPriceMode_;}
  inline void setShadowPriceMode(int value)
  { shadowPriceMode_ = value;}

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

  OsiPseudoCosts& pseudoCosts()
  { return pseudoCosts_; }

  inline int numberBeforeTrusted() const {
    return pseudoCosts_.numberBeforeTrusted(); }
  inline void setNumberBeforeTrusted(int value) {
    pseudoCosts_.setNumberBeforeTrusted(value); }
  inline int numberObjects() const {
    return pseudoCosts_.numberObjects(); }

protected:

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

  void resetResults(int num);

protected:
  int shadowPriceMode_;

  OsiPseudoCosts pseudoCosts_;

  OsiHotInfo* results_;
  int numResults_;
};

class OsiHotInfo  {
 
public:
    
  OsiHotInfo ();

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

  OsiHotInfo (const OsiHotInfo &);
   
  OsiHotInfo & operator= (const OsiHotInfo& rhs);

  virtual OsiHotInfo * clone() const;

  virtual ~OsiHotInfo ();

  int updateInformation( const OsiSolverInterface * solver, const OsiBranchingInformation * info,
                         OsiChooseVariable * choose);
  inline double originalObjectiveValue() const
  { return originalObjectiveValue_;}
  inline double upChange() const
  { assert (branchingObject_->numberBranches()==2); return changes_[1];}
  inline double downChange() const
  { assert (branchingObject_->numberBranches()==2); return changes_[0];}
  inline void setUpChange(double value)
  { assert (branchingObject_->numberBranches()==2); changes_[1] = value;}
  inline void setDownChange(double value)
  { assert (branchingObject_->numberBranches()==2); changes_[0] = value;}
  inline double change(int k) const
  { return changes_[k];}

  inline int upIterationCount() const
  { assert (branchingObject_->numberBranches()==2); return iterationCounts_[1];}
  inline int downIterationCount() const
  { assert (branchingObject_->numberBranches()==2); return iterationCounts_[0];}
  inline int iterationCount(int k) const
  { return iterationCounts_[k];}

  inline int upStatus() const
  { assert (branchingObject_->numberBranches()==2); return statuses_[1];}
  inline int downStatus() const
  { assert (branchingObject_->numberBranches()==2); return statuses_[0];}
  inline void setUpStatus(int value)
  { assert (branchingObject_->numberBranches()==2); statuses_[1] = value;}
  inline void setDownStatus(int value)
  { assert (branchingObject_->numberBranches()==2); statuses_[0] = value;}
  inline int status(int k) const
  { return statuses_[k];}
  inline OsiBranchingObject * branchingObject() const
  { return branchingObject_;}
  inline int whichObject() const
  { return whichObject_;}

protected:
  // Data
  double originalObjectiveValue_;
  double * changes_;
  int * iterationCounts_;
  int * statuses_;
  OsiBranchingObject * branchingObject_;
  int whichObject_;
};


#endif

---