Changeset 462:9b082b3fb33f in lemon1.2 for lemon/clp.cc
 Timestamp:
 01/12/09 13:26:02 (11 years ago)
 Branch:
 default
 Phase:
 public
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

lemon/clp.cc
r461 r462 22 22 namespace lemon { 23 23 24 LpClp::LpClp() {24 ClpLp::ClpLp() { 25 25 _prob = new ClpSimplex(); 26 26 _init_temporals(); … … 28 28 } 29 29 30 LpClp::LpClp(const LpClp& other) {30 ClpLp::ClpLp(const ClpLp& other) { 31 31 _prob = new ClpSimplex(*other._prob); 32 32 rows = other.rows; … … 36 36 } 37 37 38 LpClp::~LpClp() {38 ClpLp::~ClpLp() { 39 39 delete _prob; 40 40 _clear_temporals(); 41 41 } 42 42 43 void LpClp::_init_temporals() {43 void ClpLp::_init_temporals() { 44 44 _primal_ray = 0; 45 45 _dual_ray = 0; 46 46 } 47 47 48 void LpClp::_clear_temporals() {48 void ClpLp::_clear_temporals() { 49 49 if (_primal_ray) { 50 50 delete[] _primal_ray; … … 57 57 } 58 58 59 LpClp* LpClp::_newSolver() const {60 LpClp* newlp = new LpClp;59 ClpLp* ClpLp::_newSolver() const { 60 ClpLp* newlp = new ClpLp; 61 61 return newlp; 62 62 } 63 63 64 LpClp* LpClp::_cloneSolver() const {65 LpClp* copylp = new LpClp(*this);64 ClpLp* ClpLp::_cloneSolver() const { 65 ClpLp* copylp = new ClpLp(*this); 66 66 return copylp; 67 67 } 68 68 69 const char* LpClp::_solverName() const { return "LpClp"; }70 71 int LpClp::_addCol() {69 const char* ClpLp::_solverName() const { return "ClpLp"; } 70 71 int ClpLp::_addCol() { 72 72 _prob>addColumn(0, 0, 0, COIN_DBL_MAX, COIN_DBL_MAX, 0.0); 73 73 return _prob>numberColumns()  1; 74 74 } 75 75 76 int LpClp::_addRow() {76 int ClpLp::_addRow() { 77 77 _prob>addRow(0, 0, 0, COIN_DBL_MAX, COIN_DBL_MAX); 78 78 return _prob>numberRows()  1; … … 80 80 81 81 82 void LpClp::_eraseCol(int c) {82 void ClpLp::_eraseCol(int c) { 83 83 _col_names_ref.erase(_prob>getColumnName(c)); 84 84 _prob>deleteColumns(1, &c); 85 85 } 86 86 87 void LpClp::_eraseRow(int r) {87 void ClpLp::_eraseRow(int r) { 88 88 _row_names_ref.erase(_prob>getRowName(r)); 89 89 _prob>deleteRows(1, &r); 90 90 } 91 91 92 void LpClp::_eraseColId(int i) {92 void ClpLp::_eraseColId(int i) { 93 93 cols.eraseIndex(i); 94 94 cols.shiftIndices(i); 95 95 } 96 96 97 void LpClp::_eraseRowId(int i) {97 void ClpLp::_eraseRowId(int i) { 98 98 rows.eraseIndex(i); 99 99 rows.shiftIndices(i); 100 100 } 101 101 102 void LpClp::_getColName(int c, std::string& name) const {102 void ClpLp::_getColName(int c, std::string& name) const { 103 103 name = _prob>getColumnName(c); 104 104 } 105 105 106 void LpClp::_setColName(int c, const std::string& name) {106 void ClpLp::_setColName(int c, const std::string& name) { 107 107 _prob>setColumnName(c, const_cast<std::string&>(name)); 108 108 _col_names_ref[name] = c; 109 109 } 110 110 111 int LpClp::_colByName(const std::string& name) const {111 int ClpLp::_colByName(const std::string& name) const { 112 112 std::map<std::string, int>::const_iterator it = _col_names_ref.find(name); 113 113 return it != _col_names_ref.end() ? it>second : 1; 114 114 } 115 115 116 void LpClp::_getRowName(int r, std::string& name) const {116 void ClpLp::_getRowName(int r, std::string& name) const { 117 117 name = _prob>getRowName(r); 118 118 } 119 119 120 void LpClp::_setRowName(int r, const std::string& name) {120 void ClpLp::_setRowName(int r, const std::string& name) { 121 121 _prob>setRowName(r, const_cast<std::string&>(name)); 122 122 _row_names_ref[name] = r; 123 123 } 124 124 125 int LpClp::_rowByName(const std::string& name) const {125 int ClpLp::_rowByName(const std::string& name) const { 126 126 std::map<std::string, int>::const_iterator it = _row_names_ref.find(name); 127 127 return it != _row_names_ref.end() ? it>second : 1; … … 129 129 130 130 131 void LpClp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {131 void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) { 132 132 std::map<int, Value> coeffs; 133 133 … … 157 157 } 158 158 159 void LpClp::_getRowCoeffs(int ix, InsertIterator b) const {159 void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const { 160 160 int n = _prob>clpMatrix()>getNumCols(); 161 161 … … 174 174 } 175 175 176 void LpClp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {176 void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) { 177 177 std::map<int, Value> coeffs; 178 178 … … 197 197 } 198 198 199 void LpClp::_getColCoeffs(int ix, InsertIterator b) const {199 void ClpLp::_getColCoeffs(int ix, InsertIterator b) const { 200 200 CoinBigIndex begin = _prob>clpMatrix()>getVectorStarts()[ix]; 201 201 CoinBigIndex end = begin + _prob>clpMatrix()>getVectorLengths()[ix]; … … 210 210 } 211 211 212 void LpClp::_setCoeff(int ix, int jx, Value value) {212 void ClpLp::_setCoeff(int ix, int jx, Value value) { 213 213 _prob>modifyCoefficient(ix, jx, value); 214 214 } 215 215 216 LpClp::Value LpClp::_getCoeff(int ix, int jx) const {216 ClpLp::Value ClpLp::_getCoeff(int ix, int jx) const { 217 217 CoinBigIndex begin = _prob>clpMatrix()>getVectorStarts()[ix]; 218 218 CoinBigIndex end = begin + _prob>clpMatrix()>getVectorLengths()[ix]; … … 229 229 } 230 230 231 void LpClp::_setColLowerBound(int i, Value lo) {231 void ClpLp::_setColLowerBound(int i, Value lo) { 232 232 _prob>setColumnLower(i, lo ==  INF ?  COIN_DBL_MAX : lo); 233 233 } 234 234 235 LpClp::Value LpClp::_getColLowerBound(int i) const {235 ClpLp::Value ClpLp::_getColLowerBound(int i) const { 236 236 double val = _prob>getColLower()[i]; 237 237 return val ==  COIN_DBL_MAX ?  INF : val; 238 238 } 239 239 240 void LpClp::_setColUpperBound(int i, Value up) {240 void ClpLp::_setColUpperBound(int i, Value up) { 241 241 _prob>setColumnUpper(i, up == INF ? COIN_DBL_MAX : up); 242 242 } 243 243 244 LpClp::Value LpClp::_getColUpperBound(int i) const {244 ClpLp::Value ClpLp::_getColUpperBound(int i) const { 245 245 double val = _prob>getColUpper()[i]; 246 246 return val == COIN_DBL_MAX ? INF : val; 247 247 } 248 248 249 void LpClp::_setRowLowerBound(int i, Value lo) {249 void ClpLp::_setRowLowerBound(int i, Value lo) { 250 250 _prob>setRowLower(i, lo ==  INF ?  COIN_DBL_MAX : lo); 251 251 } 252 252 253 LpClp::Value LpClp::_getRowLowerBound(int i) const {253 ClpLp::Value ClpLp::_getRowLowerBound(int i) const { 254 254 double val = _prob>getRowLower()[i]; 255 255 return val ==  COIN_DBL_MAX ?  INF : val; 256 256 } 257 257 258 void LpClp::_setRowUpperBound(int i, Value up) {258 void ClpLp::_setRowUpperBound(int i, Value up) { 259 259 _prob>setRowUpper(i, up == INF ? COIN_DBL_MAX : up); 260 260 } 261 261 262 LpClp::Value LpClp::_getRowUpperBound(int i) const {262 ClpLp::Value ClpLp::_getRowUpperBound(int i) const { 263 263 double val = _prob>getRowUpper()[i]; 264 264 return val == COIN_DBL_MAX ? INF : val; 265 265 } 266 266 267 void LpClp::_setObjCoeffs(ExprIterator b, ExprIterator e) {267 void ClpLp::_setObjCoeffs(ExprIterator b, ExprIterator e) { 268 268 int num = _prob>clpMatrix()>getNumCols(); 269 269 for (int i = 0; i < num; ++i) { … … 275 275 } 276 276 277 void LpClp::_getObjCoeffs(InsertIterator b) const {277 void ClpLp::_getObjCoeffs(InsertIterator b) const { 278 278 int num = _prob>clpMatrix()>getNumCols(); 279 279 for (int i = 0; i < num; ++i) { … … 286 286 } 287 287 288 void LpClp::_setObjCoeff(int i, Value obj_coef) {288 void ClpLp::_setObjCoeff(int i, Value obj_coef) { 289 289 _prob>setObjectiveCoefficient(i, obj_coef); 290 290 } 291 291 292 LpClp::Value LpClp::_getObjCoeff(int i) const {292 ClpLp::Value ClpLp::_getObjCoeff(int i) const { 293 293 return _prob>getObjCoefficients()[i]; 294 294 } 295 295 296 LpClp::SolveExitStatus LpClp::_solve() {296 ClpLp::SolveExitStatus ClpLp::_solve() { 297 297 return _prob>primal() >= 0 ? SOLVED : UNSOLVED; 298 298 } 299 299 300 LpClp::SolveExitStatus LpClp::solvePrimal() {300 ClpLp::SolveExitStatus ClpLp::solvePrimal() { 301 301 return _prob>primal() >= 0 ? SOLVED : UNSOLVED; 302 302 } 303 303 304 LpClp::SolveExitStatus LpClp::solveDual() {304 ClpLp::SolveExitStatus ClpLp::solveDual() { 305 305 return _prob>dual() >= 0 ? SOLVED : UNSOLVED; 306 306 } 307 307 308 LpClp::SolveExitStatus LpClp::solveBarrier() {308 ClpLp::SolveExitStatus ClpLp::solveBarrier() { 309 309 return _prob>barrier() >= 0 ? SOLVED : UNSOLVED; 310 310 } 311 311 312 LpClp::Value LpClp::_getPrimal(int i) const {312 ClpLp::Value ClpLp::_getPrimal(int i) const { 313 313 return _prob>primalColumnSolution()[i]; 314 314 } 315 LpClp::Value LpClp::_getPrimalValue() const {315 ClpLp::Value ClpLp::_getPrimalValue() const { 316 316 return _prob>objectiveValue(); 317 317 } 318 318 319 LpClp::Value LpClp::_getDual(int i) const {319 ClpLp::Value ClpLp::_getDual(int i) const { 320 320 return _prob>dualRowSolution()[i]; 321 321 } 322 322 323 LpClp::Value LpClp::_getPrimalRay(int i) const {323 ClpLp::Value ClpLp::_getPrimalRay(int i) const { 324 324 if (!_primal_ray) { 325 325 _primal_ray = _prob>unboundedRay(); … … 329 329 } 330 330 331 LpClp::Value LpClp::_getDualRay(int i) const {331 ClpLp::Value ClpLp::_getDualRay(int i) const { 332 332 if (!_dual_ray) { 333 333 _dual_ray = _prob>infeasibilityRay(); … … 337 337 } 338 338 339 LpClp::VarStatus LpClp::_getColStatus(int i) const {339 ClpLp::VarStatus ClpLp::_getColStatus(int i) const { 340 340 switch (_prob>getColumnStatus(i)) { 341 341 case ClpSimplex::basic: … … 357 357 } 358 358 359 LpClp::VarStatus LpClp::_getRowStatus(int i) const {359 ClpLp::VarStatus ClpLp::_getRowStatus(int i) const { 360 360 switch (_prob>getColumnStatus(i)) { 361 361 case ClpSimplex::basic: … … 378 378 379 379 380 LpClp::ProblemType LpClp::_getPrimalType() const {380 ClpLp::ProblemType ClpLp::_getPrimalType() const { 381 381 if (_prob>isProvenOptimal()) { 382 382 return OPTIMAL; … … 390 390 } 391 391 392 LpClp::ProblemType LpClp::_getDualType() const {392 ClpLp::ProblemType ClpLp::_getDualType() const { 393 393 if (_prob>isProvenOptimal()) { 394 394 return OPTIMAL; … … 402 402 } 403 403 404 void LpClp::_setSense(LpClp::Sense sense) {404 void ClpLp::_setSense(ClpLp::Sense sense) { 405 405 switch (sense) { 406 406 case MIN: … … 413 413 } 414 414 415 LpClp::Sense LpClp::_getSense() const {415 ClpLp::Sense ClpLp::_getSense() const { 416 416 double dir = _prob>optimizationDirection(); 417 417 if (dir > 0.0) { … … 422 422 } 423 423 424 void LpClp::_clear() {424 void ClpLp::_clear() { 425 425 delete _prob; 426 426 _prob = new ClpSimplex(); … … 431 431 } 432 432 433 void LpClp::messageLevel(MessageLevel m) {433 void ClpLp::messageLevel(MessageLevel m) { 434 434 _prob>setLogLevel(static_cast<int>(m)); 435 435 }
Note: See TracChangeset
for help on using the changeset viewer.