OsiSolverBranch.hpp

Go to the documentation of this file.

// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef OsiSolverBranch_H
#define OsiSolverBranch_H

class OsiSolverInterface;
#include "CoinWarmStartBasis.hpp"

//#############################################################################

class OsiSolverBranch  {
  
public:

  void addBranch(int iColumn, double value); 
  
  void addBranch(int way,int numberTighterLower, const int * whichLower, const double * newLower,
                 int numberTighterUpper, const int * whichUpper, const double * newUpper);
  void addBranch(int way,int numberColumns,const double * oldLower, const double * newLower,
                 const double * oldUpper, const double * newUpper);
  
  void applyBounds(OsiSolverInterface & solver,int way) const;
  bool feasibleOneWay(const OsiSolverInterface & solver) const;
  inline const int * starts() const
  { return start_;}
  inline const int * which() const
  { return indices_;}
  inline const double * bounds() const
  { return bound_;}
  
  

  OsiSolverBranch(); 
  
  OsiSolverBranch(const OsiSolverBranch & rhs);
  
  OsiSolverBranch & operator=(const OsiSolverBranch & rhs);
  
  ~OsiSolverBranch ();
  
  
private:

  int start_[5];
  int * indices_;
  double * bound_;
};
//#############################################################################

class OsiSolverResult  {
  
public:

  void createResult(const OsiSolverInterface & solver,const double * lowerBefore,
                    const double * upperBefore);
  
  void restoreResult(OsiSolverInterface & solver) const;
  
  inline const CoinWarmStartBasis & basis() const
  { return basis_;}
  
  inline double objectiveValue() const
  { return objectiveValue_;}

  inline const double * primalSolution() const
  { return primalSolution_;}

  inline const double * dualSolution() const
  { return dualSolution_;}

  inline const OsiSolverBranch & fixed() const
  { return fixed_;}
  
  

  OsiSolverResult(); 
  
  OsiSolverResult(const OsiSolverInterface & solver,const double * lowerBefore,
                  const double * upperBefore); 
  
  OsiSolverResult(const OsiSolverResult & rhs);
  
  OsiSolverResult & operator=(const OsiSolverResult & rhs);
  
  ~OsiSolverResult ();
  
  
private:

  double objectiveValue_;
  CoinWarmStartBasis basis_;
  double * primalSolution_;
  double * dualSolution_;
  OsiSolverBranch fixed_;
};
#endif