OsiChooseVariable.hpp

Go to the documentation of this file.

// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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);
  virtual 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/