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

class OsiSolverInterface;
#include "CoinWarmStartBasis.hpp"
#include "CoinFinite.hpp"

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

/** Solver Branch Class

    This provides information on a branch as a set of tighter bounds on both ways
*/

class OsiSolverBranch  {
  
public:
  ///@name Add and Get methods 
  //@{
  /// Add a simple branch (i.e. first sets ub of floor(value), second lb of ceil(value))
  void addBranch(int iColumn, double value); 
  
  /// Add bounds - way =-1 is first , +1 is second 
  void addBranch(int way,int numberTighterLower, const int * whichLower, const double * newLower,
                 int numberTighterUpper, const int * whichUpper, const double * newUpper);
  /// Add bounds - way =-1 is first , +1 is second 
  void addBranch(int way,int numberColumns,const double * oldLower, const double * newLower,
                 const double * oldUpper, const double * newUpper);
  
  /// Apply bounds
  void applyBounds(OsiSolverInterface & solver,int way) const;
  /// Returns true if current solution satsifies one side of branch
  bool feasibleOneWay(const OsiSolverInterface & solver) const;
  /// Starts
  inline const int * starts() const
  { return start_;}
  /// Which variables
  inline const int * which() const
  { return indices_;}
  /// Bounds
  inline const double * bounds() const
  { return bound_;}
  //@}
  
  
  ///@name Constructors and destructors
  //@{
  /// Default Constructor
  OsiSolverBranch(); 
  
  /// Copy constructor 
  OsiSolverBranch(const OsiSolverBranch & rhs);
  
  /// Assignment operator 
  OsiSolverBranch & operator=(const OsiSolverBranch & rhs);
  
  /// Destructor 
  ~OsiSolverBranch ();
  
  //@}
  
private:
  ///@name Private member data 
  //@{
  /// Start of lower first, upper first, lower second, upper second
  int start_[5];
  /// Column numbers (if >= numberColumns treat as rows)
  int * indices_;
  /// New bounds
  double * bound_;
 //@}
};
//#############################################################################

/** Solver Result Class

    This provides information on a result as a set of tighter bounds on both ways
*/

class OsiSolverResult  {
  
public:
  ///@name Add and Get methods 
  //@{
  /// Create result
  void createResult(const OsiSolverInterface & solver,const double * lowerBefore,
                    const double * upperBefore);
  
  /// Restore result
  void restoreResult(OsiSolverInterface & solver) const;
  
  /// Get basis
  inline const CoinWarmStartBasis & basis() const
  { return basis_;}
  
  /// Objective value (as minimization)
  inline double objectiveValue() const
  { return objectiveValue_;}

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

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

  /// Extra fixed
  inline const OsiSolverBranch & fixed() const
  { return fixed_;}
  //@}
  
  
  ///@name Constructors and destructors
  //@{
  /// Default Constructor
  OsiSolverResult(); 
  
  /// Constructor from solver
  OsiSolverResult(const OsiSolverInterface & solver,const double * lowerBefore,
                  const double * upperBefore); 
  
  /// Copy constructor 
  OsiSolverResult(const OsiSolverResult & rhs);
  
  /// Assignment operator 
  OsiSolverResult & operator=(const OsiSolverResult & rhs);
  
  /// Destructor 
  ~OsiSolverResult ();
  
  //@}
  
private:
  ///@name Private member data 
  //@{
  /// Value of objective (if >= OsiSolverInterface::getInfinity() then infeasible) 
  double objectiveValue_;
  /// Warm start information
  CoinWarmStartBasis basis_;
  /// Primal solution (numberColumns)
  double * primalSolution_;
  /// Dual solution (numberRows)
  double * dualSolution_;
  /// Which extra variables have been fixed (only way==-1 counts)
  OsiSolverBranch fixed_;
 //@}
};
#endif
