void
OsiVolSolverInterface::initFromRhsSenseRange(const int rownum,
const char* rowsen,
const double* rowrhs,
const double* rowrng)
{
if (maxNumrows_ > 0) {
rowRimAllocator_();
if (rowsen) {
CoinDisjointCopyN(rowsen, rownum, rowsense_);
} else {
CoinFillN(rowsense_, rownum, 'G');
}
if (rowrhs) {
CoinDisjointCopyN(rowrhs, rownum, rhs_);
} else {
CoinFillN(rhs_, rownum, 0.0);
}
if (rowrng) {
CoinDisjointCopyN(rowrng, rownum, rowrange_);
} else {
CoinFillN(rowrange_, rownum, 0.0);
}
// Set the initial dual solution
CoinFillN(rowprice_, rownum, 0.0);
convertSensesToBounds_();
}
}
//-----------------------------------------------------------------------------
void OsiTestSolverInterface::setRowSetTypes(const int* indexFirst,
const int* indexLast,
const char* senseList,
const double* rhsList,
const double* rangeList)
{
if (indexLast - indexFirst < getNumRows() / 3) {
while (indexFirst < indexLast) {
setRowType(*indexFirst++, *senseList++, *rhsList++, *rangeList++);
}
} else {
// it's better to convert everything at once
while (indexFirst < indexLast) {
const int ind = *indexFirst++;
rowsense_[ind] = *senseList++;
rhs_[ind] = *rhsList++;
rowrange_[ind] = *rangeList++;
}
convertSensesToBounds_();
}
}
void
OsiVolSolverInterface::assignProblem(CoinPackedMatrix*& matrix,
double*& collb, double*& colub,
double*& obj,
char*& rowsen, double*& rowrhs,
double*& rowrng)
{
gutsOfDestructor_();
const int rownum = matrix->getNumRows();
const int colnum = matrix->getNumCols();
maxNumcols_ = colnum;
maxNumrows_ = rownum;
if (matrix->isColOrdered()) {
colMatrix_.swap(*matrix);
colMatrixCurrent_ = true;
rowMatrixCurrent_ = false;
} else {
rowMatrix_.swap(*matrix);
rowMatrixCurrent_ = true;
colMatrixCurrent_ = false;
}
delete matrix; matrix = 0;
rowsense_ = rowsen; rowsen = 0;
rhs_ = rowrhs; rowrhs = 0;
rowrange_ = rowrng; rowrng = 0;
colupper_ = colub; colub = 0;
collower_ = collb; collb = 0;
objcoeffs_ = obj; obj = 0;
if (maxNumrows_ > 0) {
if (!rowsense_) {
rowsense_ = new char[maxNumrows_];
CoinFillN(rowsense_, rownum, 'G');
}
if (!rhs_) {
rhs_ = new double[maxNumrows_];
CoinFillN(rhs_, rownum, 0.0);
}
if (!rowrange_) {
rowrange_ = new double[maxNumrows_];
CoinFillN(rowrange_, rownum, 0.0);
}
rowlower_ = new double[maxNumrows_];
rowupper_ = new double[maxNumrows_];
rowprice_ = new double[maxNumrows_];
lhs_ = new double[maxNumrows_];
// Set the initial dual solution
CoinFillN(rowprice_, rownum, 0.0);
convertSensesToBounds_();
}
if (maxNumcols_ > 0) {
if (!colupper_) {
colupper_ = new double[maxNumcols_];
CoinFillN(colupper_, colnum, OsiVolInfinity);
}
if (!collower_) {
collower_ = new double[maxNumcols_];
CoinFillN(collower_, colnum, -OsiVolInfinity);
}
if (!objcoeffs_) {
objcoeffs_ = new double[maxNumcols_];
CoinFillN(objcoeffs_, colnum, -OsiVolInfinity);
}
colsol_ = new double[maxNumcols_];
int c;
for ( c=0; c<colnum; c++ ) {
if ( fabs(collower_[c]) < fabs(colupper_[c]) ) {
colsol_[c] = collower_[c];
}
else {
colsol_[c] = colupper_[c];
}
}
rc_ = new double[maxNumcols_];
continuous_ = new bool[maxNumcols_];
}
}
