// Fill most values
void
ClpDualRowSteepest::fill(const ClpDualRowSteepest& rhs)
{
state_ = rhs.state_;
mode_ = rhs.mode_;
persistence_ = rhs.persistence_;
assert (model_->numberRows() == rhs.model_->numberRows());
model_ = rhs.model_;
assert(model_);
int number = model_->numberRows();
if (rhs.savedWeights_)
number = CoinMin(number, rhs.savedWeights_->capacity());
if (rhs.infeasible_ != NULL) {
if (!infeasible_)
infeasible_ = new CoinIndexedVector(rhs.infeasible_);
else
*infeasible_ = *rhs.infeasible_;
} else {
delete infeasible_;
infeasible_ = NULL;
}
if (rhs.weights_ != NULL) {
if (!weights_)
weights_ = new double[number];
ClpDisjointCopyN(rhs.weights_, number, weights_);
} else {
delete [] weights_;
weights_ = NULL;
}
if (rhs.alternateWeights_ != NULL) {
if (!alternateWeights_)
alternateWeights_ = new CoinIndexedVector(rhs.alternateWeights_);
else
*alternateWeights_ = *rhs.alternateWeights_;
} else {
delete alternateWeights_;
alternateWeights_ = NULL;
}
if (rhs.savedWeights_ != NULL) {
if (!savedWeights_)
savedWeights_ = new CoinIndexedVector(rhs.savedWeights_);
else
*savedWeights_ = *rhs.savedWeights_;
} else {
delete savedWeights_;
savedWeights_ = NULL;
}
if (rhs.dubiousWeights_) {
assert(model_);
int number = model_->numberRows();
if (!dubiousWeights_)
dubiousWeights_ = new int[number];
ClpDisjointCopyN(rhs.dubiousWeights_, number, dubiousWeights_);
} else {
delete [] dubiousWeights_;
dubiousWeights_ = NULL;
}
}
//----------------------------------------------------------------
// Assignment operator
//-------------------------------------------------------------------
ClpDualRowSteepest &
ClpDualRowSteepest::operator=(const ClpDualRowSteepest& rhs)
{
if (this != &rhs) {
ClpDualRowPivot::operator=(rhs);
state_ = rhs.state_;
mode_ = rhs.mode_;
persistence_ = rhs.persistence_;
model_ = rhs.model_;
delete [] weights_;
delete [] dubiousWeights_;
delete infeasible_;
delete alternateWeights_;
delete savedWeights_;
assert(model_);
int number = model_->numberRows();
if (rhs.savedWeights_)
number = CoinMin(number, rhs.savedWeights_->capacity());
if (rhs.infeasible_ != NULL) {
infeasible_ = new CoinIndexedVector(rhs.infeasible_);
} else {
infeasible_ = NULL;
}
if (rhs.weights_ != NULL) {
weights_ = new double[number];
ClpDisjointCopyN(rhs.weights_, number, weights_);
} else {
weights_ = NULL;
}
if (rhs.alternateWeights_ != NULL) {
alternateWeights_ = new CoinIndexedVector(rhs.alternateWeights_);
} else {
alternateWeights_ = NULL;
}
if (rhs.savedWeights_ != NULL) {
savedWeights_ = new CoinIndexedVector(rhs.savedWeights_);
} else {
savedWeights_ = NULL;
}
if (rhs.dubiousWeights_) {
assert(model_);
int number = model_->numberRows();
dubiousWeights_ = new int[number];
ClpDisjointCopyN(rhs.dubiousWeights_, number, dubiousWeights_);
} else {
dubiousWeights_ = NULL;
}
}
return *this;
}
//-------------------------------------------------------------------
// Copy constructor
//-------------------------------------------------------------------
ClpDualRowSteepest::ClpDualRowSteepest (const ClpDualRowSteepest & rhs)
: ClpDualRowPivot(rhs)
{
state_ = rhs.state_;
mode_ = rhs.mode_;
persistence_ = rhs.persistence_;
model_ = rhs.model_;
if ((model_ && model_->whatsChanged() & 1) != 0) {
int number = model_->numberRows();
if (rhs.savedWeights_)
number = CoinMin(number, rhs.savedWeights_->capacity());
if (rhs.infeasible_) {
infeasible_ = new CoinIndexedVector(rhs.infeasible_);
} else {
infeasible_ = NULL;
}
if (rhs.weights_) {
weights_ = new double[number];
ClpDisjointCopyN(rhs.weights_, number, weights_);
} else {
weights_ = NULL;
}
if (rhs.alternateWeights_) {
alternateWeights_ = new CoinIndexedVector(rhs.alternateWeights_);
} else {
alternateWeights_ = NULL;
}
if (rhs.savedWeights_) {
savedWeights_ = new CoinIndexedVector(rhs.savedWeights_);
} else {
savedWeights_ = NULL;
}
if (rhs.dubiousWeights_) {
assert(model_);
int number = model_->numberRows();
dubiousWeights_ = new int[number];
ClpDisjointCopyN(rhs.dubiousWeights_, number, dubiousWeights_);
} else {
dubiousWeights_ = NULL;
}
} else {
infeasible_ = NULL;
weights_ = NULL;
alternateWeights_ = NULL;
savedWeights_ = NULL;
dubiousWeights_ = NULL;
}
}
inline T *
ClpCopyOfArray(const T *array, const CoinBigIndex size, T value)
{
T *arrayNew = new T[size];
if (array)
ClpDisjointCopyN(array, size, arrayNew);
else
ClpFillN(arrayNew, size, value);
return arrayNew;
}
/// This returns a non const array filled with input from scalar or actual array
template <class T> inline T*
ClpCopyOfArray( const T * array, const int size, T value)
{
T * arrayNew = new T[size];
if (array)
ClpDisjointCopyN(array, size, arrayNew);
else
ClpFillN ( arrayNew, size, value);
return arrayNew;
}
/* Returns reduced gradient.Returns an offset (to be added to current one).
*/
double
ClpLinearObjective::reducedGradient(ClpSimplex * model, double * region,
bool /*useFeasibleCosts*/)
{
int numberRows = model->numberRows();
//work space
CoinIndexedVector * workSpace = model->rowArray(0);
CoinIndexedVector arrayVector;
arrayVector.reserve(numberRows + 1);
int iRow;
#ifdef CLP_DEBUG
workSpace->checkClear();
#endif
double * array = arrayVector.denseVector();
int * index = arrayVector.getIndices();
int number = 0;
const double * cost = model->costRegion();
//assert (!useFeasibleCosts);
const int * pivotVariable = model->pivotVariable();
for (iRow = 0; iRow < numberRows; iRow++) {
int iPivot = pivotVariable[iRow];
double value = cost[iPivot];
if (value) {
array[iRow] = value;
index[number++] = iRow;
}
}
arrayVector.setNumElements(number);
int numberColumns = model->numberColumns();
// Btran basic costs
double * work = workSpace->denseVector();
model->factorization()->updateColumnTranspose(workSpace, &arrayVector);
ClpFillN(work, numberRows, 0.0);
// now look at dual solution
double * rowReducedCost = region + numberColumns;
double * dual = rowReducedCost;
double * rowCost = model->costRegion(0);
for (iRow = 0; iRow < numberRows; iRow++) {
dual[iRow] = array[iRow];
}
double * dj = region;
ClpDisjointCopyN(model->costRegion(1), numberColumns, dj);
model->transposeTimes(-1.0, dual, dj);
for (iRow = 0; iRow < numberRows; iRow++) {
// slack
double value = dual[iRow];
value += rowCost[iRow];
rowReducedCost[iRow] = value;
}
return 0.0;
}
inline T *
ClpCopyOfArray(const T *array, const CoinBigIndex size)
{
if (array) {
T *arrayNew = new T[size];
ClpDisjointCopyN(array, size, arrayNew);
return arrayNew;
} else {
return NULL;
}
}
/// This returns a non const array filled with actual array (or NULL)
template <class T> inline T*
ClpCopyOfArray( const T * array, const int size)
{
if (array) {
T * arrayNew = new T[size];
ClpDisjointCopyN(array, size, arrayNew);
return arrayNew;
} else {
return NULL;
}
}
