void
OsiVolSolverInterface::loadProblem(const CoinPackedMatrix& matrix,
const double* collb, const double* colub,
const double* obj,
const char* rowsen, const double* rowrhs,
const double* rowrng)
{
gutsOfDestructor_();
const int rownum = matrix.getNumRows();
const int colnum = matrix.getNumCols();
if (matrix.isColOrdered()) {
colMatrix_ = matrix;
colMatrixCurrent_ = true;
rowMatrixCurrent_ = false;
maxNumcols_ = colMatrix_.getMaxMajorDim();
maxNumrows_ = static_cast<int>((1+colMatrix_.getExtraGap()) *
colMatrix_.getMinorDim());
} else {
rowMatrix_ = matrix;
rowMatrixCurrent_ = true;
colMatrixCurrent_ = false;
maxNumcols_ = static_cast<int>((1+rowMatrix_.getExtraGap()) *
rowMatrix_.getMinorDim());
maxNumrows_ = rowMatrix_.getMaxMajorDim();
}
initFromRhsSenseRange(rownum, rowsen, rowrhs, rowrng);
initFromClbCubObj(colnum, collb, colub, obj);
}
OsiTestSolverInterface&
OsiTestSolverInterface::operator=(const OsiTestSolverInterface& rhs)
{
if (&rhs == this)
return *this;
OsiSolverInterface::operator=(rhs);
gutsOfDestructor_();
rowMatrixCurrent_ = rhs.rowMatrixCurrent_;
if (rowMatrixCurrent_)
rowMatrix_ = rhs.rowMatrix_;
colMatrixCurrent_ = rhs.colMatrixCurrent_;
if (colMatrixCurrent_)
colMatrix_ = rhs.colMatrix_;
if (rhs.maxNumrows_) {
maxNumrows_ = rhs.maxNumrows_;
rowRimAllocator_();
const int rownum = getNumRows();
CoinDisjointCopyN(rhs.rowupper_, rownum, rowupper_);
CoinDisjointCopyN(rhs.rowlower_, rownum, rowlower_);
CoinDisjointCopyN(rhs.rowsense_, rownum, rowsense_);
CoinDisjointCopyN(rhs.rhs_, rownum, rhs_);
CoinDisjointCopyN(rhs.rowrange_, rownum, rowrange_);
CoinDisjointCopyN(rhs.rowprice_, rownum, rowprice_);
CoinDisjointCopyN(rhs.lhs_, rownum, lhs_);
}
if (rhs.maxNumcols_) {
maxNumcols_ = rhs.maxNumcols_;
colRimAllocator_();
const int colnum = getNumCols();
CoinDisjointCopyN(rhs.colupper_, colnum, colupper_);
CoinDisjointCopyN(rhs.collower_, colnum, collower_);
CoinDisjointCopyN(rhs.continuous_, colnum, continuous_);
CoinDisjointCopyN(rhs.objcoeffs_, colnum, objcoeffs_);
CoinDisjointCopyN(rhs.colsol_, colnum, colsol_);
CoinDisjointCopyN(rhs.rc_, colnum, rc_);
}
volprob_.parm.granularity = 0.0;
return *this;
}
void
OsiVolSolverInterface::loadProblem(const int numcols, const int numrows,
const int* start, const int* index,
const double* value,
const double* collb, const double* colub,
const double* obj,
const double* rowlb, const double* rowub)
{
gutsOfDestructor_();
colMatrix_.copyOf(true, numrows, numcols, start[numcols],
value, index, start, 0);
colMatrixCurrent_ = true;
rowMatrixCurrent_ = false;
maxNumcols_ = colMatrix_.getMaxMajorDim();
maxNumrows_ = static_cast<int>((1+colMatrix_.getExtraGap()) *
colMatrix_.getMinorDim());
initFromRlbRub(numrows, rowlb, rowub);
initFromClbCubObj(numcols, collb, colub, obj);
}
OsiTestSolverInterface::~OsiTestSolverInterface ()
{
gutsOfDestructor_();
}
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_];
}
}
