coinor-libosi-dev 0.106.9-2 / usr / include / coin / OsiSolverBranch.hpp

This file is indexed.

/usr/include/coin/OsiSolverBranch.hpp is in coinor-libosi-dev 0.106.9-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
// 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"

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

/** 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

APT Browse - Built by Thomas Orozco.