OsiAuxInfo.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 OsiAuxInfo_H
#define OsiAuxInfo_H
 
class OsiSolverInterface;
 
//#############################################################################
class OsiAuxInfo {
public:
  // Default Constructor
  OsiAuxInfo(void *appData = NULL);
 
  // Copy Constructor
  OsiAuxInfo(const OsiAuxInfo &rhs);
  // Destructor
  virtual ~OsiAuxInfo();
 
  virtual OsiAuxInfo *clone() const;
  OsiAuxInfo &operator=(const OsiAuxInfo &rhs);
 
  inline void *getApplicationData() const
  {
    return appData_;
  }
 
protected:
  void *appData_;
};
//#############################################################################
class OsiBabSolver : public OsiAuxInfo {
public:
  // Default Constructor
  OsiBabSolver(int solverType = 0);
 
  // Copy Constructor
  OsiBabSolver(const OsiBabSolver &rhs);
  // Destructor
  virtual ~OsiBabSolver();
 
  virtual OsiAuxInfo *clone() const;
  OsiBabSolver &operator=(const OsiBabSolver &rhs);
 
  inline void setSolver(const OsiSolverInterface *solver)
  {
    solver_ = solver;
  }
  inline void setSolver(const OsiSolverInterface &solver)
  {
    solver_ = &solver;
  }
 
  int solution(double &objectiveValue,
    double *newSolution, int numberColumns);
  void setSolution(const double *solution, int numberColumns, double objectiveValue);
 
  bool hasSolution(double &solutionValue, double *solution);
 
  inline void setSolverType(int value)
  {
    solverType_ = value;
  }
  inline int solverType() const
  {
    return solverType_;
  }
  inline bool solutionAddsCuts() const
  {
    return solverType_ == 3;
  }
  inline bool alwaysTryCutsAtRootNode() const
  {
    return solverType_ == 4;
  }
  inline bool solverAccurate() const
  {
    return solverType_ == 0 || solverType_ == 2 || solverType_ == 4;
  }
  inline bool reducedCostsAccurate() const
  {
    return solverType_ == 0 || solverType_ == 4;
  }
  double mipBound() const;
  bool mipFeasible() const;
  inline void setMipBound(double value)
  {
    mipBound_ = value;
  }
  inline double bestObjectiveValue() const
  {
    return bestObjectiveValue_;
  }
  inline bool tryCuts() const
  {
    return solverType_ != 2;
  }
  inline bool warmStart() const
  {
    return solverType_ != 2;
  }
  inline int extraCharacteristics() const
  {
    return extraCharacteristics_;
  }
  inline void setExtraCharacteristics(int value)
  {
    extraCharacteristics_ = value;
  }
  inline const double *beforeLower() const
  {
    return beforeLower_;
  }
  inline void setBeforeLower(const double *array)
  {
    beforeLower_ = array;
  }
  inline const double *beforeUpper() const
  {
    return beforeUpper_;
  }
  inline void setBeforeUpper(const double *array)
  {
    beforeUpper_ = array;
  }
  inline void setExtraPointer(void *extraInfo)
  {
    extraInfo_ = extraInfo;
  }
  inline void *getExtraPointer() const
  {
    return extraInfo_;
  }
 
protected:
  double bestObjectiveValue_;
  double mipBound_;
  const OsiSolverInterface *solver_;
  double *bestSolution_;
  const double *beforeLower_;
  const double *beforeUpper_;
  void *extraInfo_;
  int solverType_;
  int sizeSolution_;
  int extraCharacteristics_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/