double port_impl::col_val(int i) const {
ASSERT(i<=M); // X.size() == N
double val = X.at(i-1);
const double lb = col_lb(i);
const double ub = col_ub(i);
ASSERT2(lb<ub,"lb, ub: "<<lb<<", "<<ub);
if ((val+1.0e-4 < lb) || (val > ub+1.0e-4)) {
ASSERT(false);
//throw numerical_problems();
}
if (val < lb) {
val = lb;
}
else if (val > ub) {
val = ub;
}
return val;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const unsigned int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const Mat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation ( >= & <=).
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
Vec temp = A.row(i);
CoinPackedVector row;
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL )
{
int coef = 1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
indexRow++;
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL )
{
int coef = -1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
indexRow++;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[0].first;
col_ub[i] = cstraints.vec_bounds_[0].second;
}
}
else // each parameter have it's own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints.vec_cost_.empty() ? NULL : &cstraints.vec_cost_[0], &row_lb[0], &row_ub[0] );
delete matrix;
return bOk;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints_Sparse & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const sRMat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation (>= & <=)
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t rowindex = 0;
for (int i=0; i < A.rows(); ++i)
{
std::vector<int> vec_colno;
std::vector<double> vec_value;
for (sRMat::InnerIterator it(A,i); it; ++it)
{
vec_colno.push_back(it.col());
vec_value.push_back(it.value());
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL )
{
int coef = 1;
row_lb[rowindex] = -1.0 * si->getInfinity();
row_ub[rowindex] = coef * cstraints.constraint_objective_(i);
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
rowindex++;
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL )
{
int coef = -1;
for ( std::vector<double>::iterator iter_val = vec_value.begin();
iter_val != vec_value.end();
iter_val++)
{
*iter_val *= coef;
}
row_lb[rowindex] = -1.0 * si->getInfinity();
row_ub[rowindex] = coef * cstraints.constraint_objective_(i);
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
rowindex++;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[0].first;
col_ub[i] = cstraints.vec_bounds_[0].second;
}
}
else // each parameter have it's own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(
*matrix,
&col_lb[0],
&col_ub[0],
cstraints.vec_cost_.empty() ? NULL : &cstraints.vec_cost_[0],
&row_lb[0],
&row_ub[0]);
delete matrix;
return bOk;
}
bool OSI_X_SolverWrapper::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
if ( si == nullptr )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const unsigned int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double>
col_lb(NUMVAR), // the column lower bounds
col_ub(NUMVAR); // the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const Mat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation ( >= & <=).
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
// Define default lower and upper bound to [-inf, inf]
std::vector<double>
row_lb(nbLine, -si->getInfinity()), // the row lower bounds
row_ub(nbLine, si->getInfinity()); // the row upper bounds
std::unique_ptr<CoinPackedMatrix> matrix(new CoinPackedMatrix(false,0,0));
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
const Vec temp = A.row(i);
CoinPackedVector row;
if (cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL)
{
const int coef = 1;
for ( int j = 0; j < A.cols(); ++j )
{
row.insert(j, coef * temp.data()[j]);
}
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
++indexRow;
}
if (cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL)
{
const int coef = -1;
for ( int j = 0; j < A.cols(); ++j )
{
row.insert(j, coef * temp.data()[j]);
}
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
++indexRow;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
std::fill(col_lb.begin(), col_lb.end(), cstraints.vec_bounds_[0].first);
std::fill(col_ub.begin(), col_ub.end(), cstraints.vec_bounds_[0].second);
}
else // each parameter have its own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints.vec_cost_.empty() ? nullptr : &cstraints.vec_cost_[0], &row_lb[0], &row_ub[0] );
return true;
}
bool OSI_X_SolverWrapper::setup(const LP_Constraints_Sparse & cstraints) //cstraints <-> constraints
{
if ( si == nullptr )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double>
col_lb(NUMVAR), // the column lower bounds
col_ub(NUMVAR); // the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const sRMat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation (>= & <=)
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
// Define default lower and upper bound to [-inf, inf]
std::vector<double>
row_lb(nbLine, -si->getInfinity()), // the row lower bounds
row_ub(nbLine, si->getInfinity()); // the row upper bounds
std::unique_ptr<CoinPackedMatrix> matrix(new CoinPackedMatrix(false,0,0));
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t rowindex = 0;
for (int i=0; i < A.rows(); ++i)
{
std::vector<int> vec_colno;
std::vector<double> vec_value;
for (sRMat::InnerIterator it(A,i); it; ++it)
{
vec_colno.push_back(it.col());
vec_value.push_back(it.value());
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL )
{
const int coef = 1;
row_ub[rowindex] = coef * cstraints.constraint_objective_(i);
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
++rowindex;
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL )
{
const int coef = -1;
for (auto & iter_val : vec_value)
{
iter_val *= coef;
}
row_ub[rowindex] = coef * cstraints.constraint_objective_(i);
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
++rowindex;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
std::fill(col_lb.begin(), col_lb.end(), cstraints.vec_bounds_[0].first);
std::fill(col_ub.begin(), col_ub.end(), cstraints.vec_bounds_[0].second);
}
else // each parameter have its own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(
*matrix,
&col_lb[0],
&col_ub[0],
cstraints.vec_cost_.empty() ? nullptr : &cstraints.vec_cost_[0],
&row_lb[0],
&row_ub[0]);
return true;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(_nbParams == cstraints._nbParams);
int NUMVAR = cstraints._constraintMat.cols();
int NUMCON = cstraints._constraintMat.rows();
int NUMANZ = cstraints._constraintMat.cols() * cstraints._constraintMat.rows(); //DENSE MATRIX
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->_nbParams = NUMVAR;
if (cstraints._bminimize)
{
si->setObjSense( 1 );
}
else
{
si->setObjSense( -1 );
}
const Mat & A = cstraints._constraintMat;
//Equality constraint will be handked by two constraintsdue to the API limitation.
size_t nbLine = A.rows() + std::count(cstraints._vec_sign.begin(), cstraints._vec_sign.end(), EQ);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
Vec temp = A.row(i);
CoinPackedVector row;
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == LE )
{
int coef = 1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints._Cst_objective(i);
matrix->appendRow(row);
indexRow++;
}
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == GE )
{
int coef = -1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints._Cst_objective(i);
matrix->appendRow(row);
indexRow++;
}
}
//-- Setup bounds
if (cstraints._vec_bounds.size() == 1)
{
// Setup the same bound for all the parameter
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[0].first;
col_ub[i] = cstraints._vec_bounds[0].second;
}
}
else
{
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[i].first;
col_ub[i] = cstraints._vec_bounds[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints._vec_cost.empty() ? NULL : &cstraints._vec_cost[0], &row_lb[0], &row_ub[0] );
delete matrix;
return bOk;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints_Sparse & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(_nbParams == cstraints._nbParams);
int NUMVAR = cstraints._constraintMat.cols();
int NUMCON = cstraints._constraintMat.rows();
int NUMANZ = cstraints._constraintMat.cols() * cstraints._constraintMat.rows(); //DENSE MATRIX
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->_nbParams = NUMVAR;
if (cstraints._bminimize)
{
si->setObjSense( 1 );
}
else
{
si->setObjSense( -1 );
}
const sRMat & A = cstraints._constraintMat;
//Equality constraint will be handked by two constraintsdue to the API limitation.
size_t nbLine = A.rows() + std::count(cstraints._vec_sign.begin(), cstraints._vec_sign.end(), EQ);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t rowindex = 0;
for (int i=0; i < A.rows(); ++i)
{
std::vector<int> vec_colno;
std::vector<double> vec_value;
for (sRMat::InnerIterator it(A,i); it; ++it)
{
vec_colno.push_back(it.col());
vec_value.push_back(it.value());
}
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == LE )
{
int coef = 1;
row_lb[rowindex] = -1.0 * si->getInfinity();
row_ub[rowindex] = coef * cstraints._Cst_objective(i);;
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
rowindex++;
}
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == GE )
{
int coef = -1;
for ( std::vector<double>::iterator iter_val = vec_value.begin();
iter_val != vec_value.end();
iter_val++)
{
*iter_val *= coef;
}
row_lb[rowindex] = -1.0 * si->getInfinity();
row_ub[rowindex] = coef * cstraints._Cst_objective(i);;
matrix->appendRow( vec_colno.size(),
&vec_colno[0],
&vec_value[0] );
rowindex++;
}
}
//-- Setup bounds
if (cstraints._vec_bounds.size() == 1)
{
// Setup the same bound for all the parameter
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[0].first;
col_ub[i] = cstraints._vec_bounds[0].second;
}
}
else {
// Set the required bound per constraint
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[i].first;
col_ub[i] = cstraints._vec_bounds[i].second;
}
}
si->loadProblem(
*matrix,
&col_lb[0],
&col_ub[0],
cstraints._vec_cost.empty() ? NULL : &cstraints._vec_cost[0],
&row_lb[0],
&row_ub[0]);
delete matrix;
return bOk;
}