lemon-main: comparison lemon/clp.cc

equal deleted inserted replaced

-:adc5521bb5f8
+:de3aa0e8e283
 #include <lemon/clp.h>
 #include <coin/ClpSimplex.hpp>
 namespace lemon {
-LpClp::LpClp() {
+ClpLp::ClpLp() {
 _prob = new ClpSimplex();
 _init_temporals();
 messageLevel(MESSAGE_NO_OUTPUT);
 }
-LpClp::LpClp(const LpClp& other) {
+ClpLp::ClpLp(const ClpLp& other) {
 _prob = new ClpSimplex(*other._prob);
 rows = other.rows;
 cols = other.cols;
 _init_temporals();
 messageLevel(MESSAGE_NO_OUTPUT);
 }
-LpClp::~LpClp() {
+ClpLp::~ClpLp() {
 delete _prob;
 _clear_temporals();
 }
-void LpClp::_init_temporals() {
+void ClpLp::_init_temporals() {
 _primal_ray = 0;
 _dual_ray = 0;
 }
-void LpClp::_clear_temporals() {
+void ClpLp::_clear_temporals() {
 if (_primal_ray) {
 delete[] _primal_ray;
 _primal_ray = 0;
 }
 if (_dual_ray) {
 delete[] _dual_ray;
 _dual_ray = 0;
 }
 }
-LpClp* LpClp::_newSolver() const {
+ClpLp* ClpLp::_newSolver() const {
-LpClp* newlp = new LpClp;
+ClpLp* newlp = new ClpLp;
 return newlp;
 }
-LpClp* LpClp::_cloneSolver() const {
+ClpLp* ClpLp::_cloneSolver() const {
-LpClp* copylp = new LpClp(*this);
+ClpLp* copylp = new ClpLp(*this);
 return copylp;
 }
-const char* LpClp::_solverName() const { return "LpClp"; }
+const char* ClpLp::_solverName() const { return "ClpLp"; }
-int LpClp::_addCol() {
+int ClpLp::_addCol() {
 _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
 return _prob->numberColumns() - 1;
 }
-int LpClp::_addRow() {
+int ClpLp::_addRow() {
 _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
 return _prob->numberRows() - 1;
 }
-void LpClp::_eraseCol(int c) {
+void ClpLp::_eraseCol(int c) {
 _col_names_ref.erase(_prob->getColumnName(c));
 _prob->deleteColumns(1, &c);
 }
-void LpClp::_eraseRow(int r) {
+void ClpLp::_eraseRow(int r) {
 _row_names_ref.erase(_prob->getRowName(r));
 _prob->deleteRows(1, &r);
 }
-void LpClp::_eraseColId(int i) {
+void ClpLp::_eraseColId(int i) {
 cols.eraseIndex(i);
 cols.shiftIndices(i);
 }
-void LpClp::_eraseRowId(int i) {
+void ClpLp::_eraseRowId(int i) {
 rows.eraseIndex(i);
 rows.shiftIndices(i);
 }
-void LpClp::_getColName(int c, std::string& name) const {
+void ClpLp::_getColName(int c, std::string& name) const {
 name = _prob->getColumnName(c);
 }
-void LpClp::_setColName(int c, const std::string& name) {
+void ClpLp::_setColName(int c, const std::string& name) {
 _prob->setColumnName(c, const_cast<std::string&>(name));
 _col_names_ref[name] = c;
 }
-int LpClp::_colByName(const std::string& name) const {
+int ClpLp::_colByName(const std::string& name) const {
 std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);
 return it != _col_names_ref.end() ? it->second : -1;
 }
-void LpClp::_getRowName(int r, std::string& name) const {
+void ClpLp::_getRowName(int r, std::string& name) const {
 name = _prob->getRowName(r);
 }
-void LpClp::_setRowName(int r, const std::string& name) {
+void ClpLp::_setRowName(int r, const std::string& name) {
 _prob->setRowName(r, const_cast<std::string&>(name));
 _row_names_ref[name] = r;
 }
-int LpClp::_rowByName(const std::string& name) const {
+int ClpLp::_rowByName(const std::string& name) const {
 std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);
 return it != _row_names_ref.end() ? it->second : -1;
 }
-void LpClp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
+void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
 std::map<int, Value> coeffs;
 int n = _prob->clpMatrix()->getNumCols();
 const int* indices = _prob->clpMatrix()->getIndices();
 it != coeffs.end(); ++it) {
 _prob->modifyCoefficient(ix, it->first, it->second);
 }
 }
-void LpClp::_getRowCoeffs(int ix, InsertIterator b) const {
+void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const {
 int n = _prob->clpMatrix()->getNumCols();
 const int* indices = _prob->clpMatrix()->getIndices();
 const double* elements = _prob->clpMatrix()->getElements();
 *b = std::make_pair(i, elements[it - indices]);
 }
 }
 }
-void LpClp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
+void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
 std::map<int, Value> coeffs;
 CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
 CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
 it != coeffs.end(); ++it) {
 _prob->modifyCoefficient(it->first, ix, it->second);
 }
 }
-void LpClp::_getColCoeffs(int ix, InsertIterator b) const {
+void ClpLp::_getColCoeffs(int ix, InsertIterator b) const {
 CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
 CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
 const int* indices = _prob->clpMatrix()->getIndices();
 const double* elements = _prob->clpMatrix()->getElements();
 *b = std::make_pair(indices[i], elements[i]);
 ++b;
 }
 }
-void LpClp::_setCoeff(int ix, int jx, Value value) {
+void ClpLp::_setCoeff(int ix, int jx, Value value) {
 _prob->modifyCoefficient(ix, jx, value);
 }
-LpClp::Value LpClp::_getCoeff(int ix, int jx) const {
+ClpLp::Value ClpLp::_getCoeff(int ix, int jx) const {
 CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
 CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
 const int* indices = _prob->clpMatrix()->getIndices();
 const double* elements = _prob->clpMatrix()->getElements();
 } else {
 return 0.0;
 }
 }
-void LpClp::_setColLowerBound(int i, Value lo) {
+void ClpLp::_setColLowerBound(int i, Value lo) {
 _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
 }
-LpClp::Value LpClp::_getColLowerBound(int i) const {
+ClpLp::Value ClpLp::_getColLowerBound(int i) const {
 double val = _prob->getColLower()[i];
 return val == - COIN_DBL_MAX ? - INF : val;
 }
-void LpClp::_setColUpperBound(int i, Value up) {
+void ClpLp::_setColUpperBound(int i, Value up) {
 _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up);
 }
-LpClp::Value LpClp::_getColUpperBound(int i) const {
+ClpLp::Value ClpLp::_getColUpperBound(int i) const {
 double val = _prob->getColUpper()[i];
 return val == COIN_DBL_MAX ? INF : val;
 }
-void LpClp::_setRowLowerBound(int i, Value lo) {
+void ClpLp::_setRowLowerBound(int i, Value lo) {
 _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
 }
-LpClp::Value LpClp::_getRowLowerBound(int i) const {
+ClpLp::Value ClpLp::_getRowLowerBound(int i) const {
 double val = _prob->getRowLower()[i];
 return val == - COIN_DBL_MAX ? - INF : val;
 }
-void LpClp::_setRowUpperBound(int i, Value up) {
+void ClpLp::_setRowUpperBound(int i, Value up) {
 _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up);
 }
-LpClp::Value LpClp::_getRowUpperBound(int i) const {
+ClpLp::Value ClpLp::_getRowUpperBound(int i) const {
 double val = _prob->getRowUpper()[i];
 return val == COIN_DBL_MAX ? INF : val;
 }
-void LpClp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
+void ClpLp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
 int num = _prob->clpMatrix()->getNumCols();
 for (int i = 0; i < num; ++i) {
 _prob->setObjectiveCoefficient(i, 0.0);
 }
 for (ExprIterator it = b; it != e; ++it) {
 _prob->setObjectiveCoefficient(it->first, it->second);
 }
 }
-void LpClp::_getObjCoeffs(InsertIterator b) const {
+void ClpLp::_getObjCoeffs(InsertIterator b) const {
 int num = _prob->clpMatrix()->getNumCols();
 for (int i = 0; i < num; ++i) {
 Value coef = _prob->getObjCoefficients()[i];
 if (coef != 0.0) {
 *b = std::make_pair(i, coef);
 ++b;
 }
 }
 }
-void LpClp::_setObjCoeff(int i, Value obj_coef) {
+void ClpLp::_setObjCoeff(int i, Value obj_coef) {
 _prob->setObjectiveCoefficient(i, obj_coef);
 }
-LpClp::Value LpClp::_getObjCoeff(int i) const {
+ClpLp::Value ClpLp::_getObjCoeff(int i) const {
 return _prob->getObjCoefficients()[i];
 }
-LpClp::SolveExitStatus LpClp::_solve() {
+ClpLp::SolveExitStatus ClpLp::_solve() {
 return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
 }
-LpClp::SolveExitStatus LpClp::solvePrimal() {
+ClpLp::SolveExitStatus ClpLp::solvePrimal() {
 return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
 }
-LpClp::SolveExitStatus LpClp::solveDual() {
+ClpLp::SolveExitStatus ClpLp::solveDual() {
 return _prob->dual() >= 0 ? SOLVED : UNSOLVED;
 }
-LpClp::SolveExitStatus LpClp::solveBarrier() {
+ClpLp::SolveExitStatus ClpLp::solveBarrier() {
 return _prob->barrier() >= 0 ? SOLVED : UNSOLVED;
 }
-LpClp::Value LpClp::_getPrimal(int i) const {
+ClpLp::Value ClpLp::_getPrimal(int i) const {
 return _prob->primalColumnSolution()[i];
 }
-LpClp::Value LpClp::_getPrimalValue() const {
+ClpLp::Value ClpLp::_getPrimalValue() const {
 return _prob->objectiveValue();
 }
-LpClp::Value LpClp::_getDual(int i) const {
+ClpLp::Value ClpLp::_getDual(int i) const {
 return _prob->dualRowSolution()[i];
 }
-LpClp::Value LpClp::_getPrimalRay(int i) const {
+ClpLp::Value ClpLp::_getPrimalRay(int i) const {
 if (!_primal_ray) {
 _primal_ray = _prob->unboundedRay();
 LEMON_ASSERT(_primal_ray != 0, "Primal ray is not provided");
 }
 return _primal_ray[i];
 }
-LpClp::Value LpClp::_getDualRay(int i) const {
+ClpLp::Value ClpLp::_getDualRay(int i) const {
 if (!_dual_ray) {
 _dual_ray = _prob->infeasibilityRay();
 LEMON_ASSERT(_dual_ray != 0, "Dual ray is not provided");
 }
 return _dual_ray[i];
 }
-LpClp::VarStatus LpClp::_getColStatus(int i) const {
+ClpLp::VarStatus ClpLp::_getColStatus(int i) const {
 switch (_prob->getColumnStatus(i)) {
 case ClpSimplex::basic:
 return BASIC;
 case ClpSimplex::isFree:
 return FREE;
 LEMON_ASSERT(false, "Wrong column status");
 return VarStatus();
 }
 }
-LpClp::VarStatus LpClp::_getRowStatus(int i) const {
+ClpLp::VarStatus ClpLp::_getRowStatus(int i) const {
 switch (_prob->getColumnStatus(i)) {
 case ClpSimplex::basic:
 return BASIC;
 case ClpSimplex::isFree:
 return FREE;
 return VarStatus();
 }
 }
-LpClp::ProblemType LpClp::_getPrimalType() const {
+ClpLp::ProblemType ClpLp::_getPrimalType() const {
 if (_prob->isProvenOptimal()) {
 return OPTIMAL;
 } else if (_prob->isProvenPrimalInfeasible()) {
 return INFEASIBLE;
 } else if (_prob->isProvenDualInfeasible()) {
 } else {
 return UNDEFINED;
 }
 }
-LpClp::ProblemType LpClp::_getDualType() const {
+ClpLp::ProblemType ClpLp::_getDualType() const {
 if (_prob->isProvenOptimal()) {
 return OPTIMAL;
 } else if (_prob->isProvenDualInfeasible()) {
 return INFEASIBLE;
 } else if (_prob->isProvenPrimalInfeasible()) {
 } else {
 return UNDEFINED;
 }
 }
-void LpClp::_setSense(LpClp::Sense sense) {
+void ClpLp::_setSense(ClpLp::Sense sense) {
 switch (sense) {
 case MIN:
 _prob->setOptimizationDirection(1);
 break;
 case MAX:
 _prob->setOptimizationDirection(-1);
 break;
 }
 }
-LpClp::Sense LpClp::_getSense() const {
+ClpLp::Sense ClpLp::_getSense() const {
 double dir = _prob->optimizationDirection();
 if (dir > 0.0) {
 return MIN;
 } else {
 return MAX;
 }
 }
-void LpClp::_clear() {
+void ClpLp::_clear() {
 delete _prob;
 _prob = new ClpSimplex();
 rows.clear();
 cols.clear();
 _col_names_ref.clear();
 _clear_temporals();
 }
-void LpClp::messageLevel(MessageLevel m) {
+void ClpLp::messageLevel(MessageLevel m) {
 _prob->setLogLevel(static_cast<int>(m));
 }
 } //END OF NAMESPACE LEMON

changeset 492	b9b3473327e3
parent 461	08d495d48089
child 540	9db62975c32b