/usr/include/coin/CglGomory.hpp is in coinor-libcgl-dev 0.58.4-2ubuntu2.
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 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 | // Copyright (C) 2002, International Business Machines
// Corporation and others. All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
#ifndef CglGomory_H
#define CglGomory_H
#include <string>
#include "CglCutGenerator.hpp"
class CoinWarmStartBasis;
/** Gomory Cut Generator Class */
class CglGomory : public CglCutGenerator {
friend void CglGomoryUnitTest(const OsiSolverInterface * siP,
const std::string mpdDir );
public:
/**@name Generate Cuts */
//@{
/** Generate Mixed Integer Gomory cuts for the model of the
solver interface, si.
Insert the generated cuts into OsiCut, cs.
There is a limit option, which will only generate cuts with
less than this number of entries.
We can also only look at 0-1 variables a certain distance
from integer.
*/
virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
const CglTreeInfo info = CglTreeInfo());
/** Generates cuts given matrix and solution etc,
returns number of cuts generated */
int generateCuts( const OsiRowCutDebugger * debugger,
OsiCuts & cs,
const CoinPackedMatrix & columnCopy,
const CoinPackedMatrix & rowCopy,
const double * colsol,
const double * colLower, const double * colUpper,
const double * rowLower, const double * rowUpper,
const char * intVar ,
const CoinWarmStartBasis* warm,
const CglTreeInfo info = CglTreeInfo());
/** Generates cuts given matrix and solution etc,
returns number of cuts generated (no row copy passed in) */
int generateCuts( const OsiRowCutDebugger * debugger,
OsiCuts & cs,
const CoinPackedMatrix & columnCopy,
const double * colsol,
const double * colLower, const double * colUpper,
const double * rowLower, const double * rowUpper,
const char * intVar ,
const CoinWarmStartBasis* warm,
const CglTreeInfo info = CglTreeInfo());
/// Return true if needs optimal basis to do cuts (will return true)
virtual bool needsOptimalBasis() const { return true; }
//@}
/**@name Change way Gomory works */
//@{
/// Pass in a copy of original solver (clone it)
void passInOriginalSolver(OsiSolverInterface * solver);
/// Returns original solver
inline OsiSolverInterface * originalSolver() const
{ return originalSolver_;}
/// Set type - 0 normal, 1 add original matrix one, 2 replace
inline void setGomoryType(int type)
{ gomoryType_=type;}
/// Return type
inline int gomoryType() const
{ return gomoryType_;}
//@}
/**@name Change limit on how many variables in cut (default 50) */
//@{
/// Set
void setLimit(int limit);
/// Get
int getLimit() const;
/// Set at root (if <normal then use normal)
void setLimitAtRoot(int limit);
/// Get at root
int getLimitAtRoot() const;
/// Return maximum length of cut in tree
virtual int maximumLengthOfCutInTree() const;
//@}
/**@name Change criterion on which variables to look at. All ones
more than "away" away from integrality will be investigated
(default 0.05) */
//@{
/// Set away
void setAway(double value);
/// Get away
double getAway() const;
/// Set away at root
void setAwayAtRoot(double value);
/// Get away at root
double getAwayAtRoot() const;
//@}
/**@name Change criterion on which the cut id relaxed if the code
thinks the factorization has inaccuracies. The relaxation to
RHS is smallest of -
1) 1.0e-4
2) conditionNumberMultiplier * condition number of factorization
3) largestFactorMultiplier * largest (dual*element) forming tableau
row
*/
//@{
/// Set ConditionNumberMultiplier
void setConditionNumberMultiplier(double value);
/// Get ConditionNumberMultiplier
double getConditionNumberMultiplier() const;
/// Set LargestFactorMultiplier
void setLargestFactorMultiplier(double value);
/// Get LargestFactorMultiplier
double getLargestFactorMultiplier() const;
//@}
/**@name change factorization */
//@{
/// Set/unset alternative factorization
inline void useAlternativeFactorization(bool yes=true)
{ alternateFactorization_= (yes) ? 1 : 0;}
/// Get whether alternative factorization being used
inline bool alternativeFactorization() const
{ return (alternateFactorization_!=0);}
//@}
/**@name Constructors and destructors */
//@{
/// Default constructor
CglGomory ();
/// Copy constructor
CglGomory (
const CglGomory &);
/// Clone
virtual CglCutGenerator * clone() const;
/// Assignment operator
CglGomory &
operator=(
const CglGomory& rhs);
/// Destructor
virtual
~CglGomory ();
/// Create C++ lines to get to current state
virtual std::string generateCpp( FILE * fp);
/// This can be used to refresh any inforamtion
virtual void refreshSolver(OsiSolverInterface * solver);
//@}
private:
// Private member methods
// Private member data
/**@name Private member data */
//@{
/// Only investigate if more than this away from integrality
double away_;
/// Only investigate if more than this away from integrality (at root)
double awayAtRoot_;
/// Multiplier for conditionNumber cut relaxation
double conditionNumberMultiplier_;
/// Multiplier for largest factor cut relaxation
double largestFactorMultiplier_;
/// Original solver
OsiSolverInterface * originalSolver_;
/// Limit - only generate if fewer than this in cut
int limit_;
/// Limit - only generate if fewer than this in cut (at root)
int limitAtRoot_;
/// Dynamic limit in tree
int dynamicLimitInTree_;
/// Number of times stalled
int numberTimesStalled_;
/// nonzero to use alternative factorization
int alternateFactorization_;
/// Type - 0 normal, 1 add original matrix one, 2 replace
int gomoryType_;
//@}
};
//#############################################################################
/** A function that tests the methods in the CglGomory class. The
only reason for it not to be a member method is that this way it doesn't
have to be compiled into the library. And that's a gain, because the
library should be compiled with optimization on, but this method should be
compiled with debugging. */
void CglGomoryUnitTest(const OsiSolverInterface * siP,
const std::string mpdDir );
#endif
|