//----------------------------------------------------------------
// Assignment operator
//-------------------------------------------------------------------
ClpDynamicExampleMatrix &
ClpDynamicExampleMatrix::operator=(const ClpDynamicExampleMatrix& rhs)
{
if (this != &rhs) {
ClpDynamicMatrix::operator=(rhs);
numberColumns_ = rhs.numberColumns_;
delete [] startColumnGen_;
delete [] rowGen_;
delete [] elementGen_;
delete [] costGen_;
delete [] fullStartGen_;
delete [] dynamicStatusGen_;
delete [] idGen_;
delete [] columnLowerGen_;
delete [] columnUpperGen_;
startColumnGen_ = ClpCopyOfArray(rhs.startColumnGen_, numberColumns_ + 1);
CoinBigIndex numberElements = startColumnGen_[numberColumns_];
rowGen_ = ClpCopyOfArray(rhs.rowGen_, numberElements);;
elementGen_ = ClpCopyOfArray(rhs.elementGen_, numberElements);;
costGen_ = ClpCopyOfArray(rhs.costGen_, numberColumns_);
fullStartGen_ = ClpCopyOfArray(rhs.fullStartGen_, numberSets_ + 1);
dynamicStatusGen_ = ClpCopyOfArray(rhs.dynamicStatusGen_, numberColumns_);
idGen_ = ClpCopyOfArray(rhs.idGen_, maximumGubColumns_);
columnLowerGen_ = ClpCopyOfArray(rhs.columnLowerGen_, numberColumns_);
columnUpperGen_ = ClpCopyOfArray(rhs.columnUpperGen_, numberColumns_);
}
return *this;
}
//----------------------------------------------------------------
// Assignment operator
//-------------------------------------------------------------------
ClpMatrixBase &
ClpMatrixBase::operator=(const ClpMatrixBase& rhs)
{
if (this != &rhs) {
type_ = rhs.type_;
delete [] rhsOffset_;
int numberRows = rhs.getNumRows();
if (rhs.rhsOffset_ && numberRows) {
rhsOffset_ = ClpCopyOfArray(rhs.rhsOffset_, numberRows);
} else {
rhsOffset_ = NULL;
}
startFraction_ = rhs.startFraction_;
endFraction_ = rhs.endFraction_;
savedBestDj_ = rhs.savedBestDj_;
originalWanted_ = rhs.originalWanted_;
currentWanted_ = rhs.currentWanted_;
savedBestSequence_ = rhs.savedBestSequence_;
lastRefresh_ = rhs.lastRefresh_;
refreshFrequency_ = rhs.refreshFrequency_;
minimumObjectsScan_ = rhs.minimumObjectsScan_;
minimumGoodReducedCosts_ = rhs.minimumGoodReducedCosts_;
trueSequenceIn_ = rhs.trueSequenceIn_;
trueSequenceOut_ = rhs.trueSequenceOut_;
skipDualCheck_ = rhs.skipDualCheck_;
}
return *this;
}
ClpLsqr::ClpLsqr(const ClpLsqr &rhs)
: nrows_(rhs.nrows_)
, ncols_(rhs.ncols_)
, model_(rhs.model_)
, diag2_(rhs.diag2_)
{
diag1_ = ClpCopyOfArray(rhs.diag1_, nrows_);
}
//-------------------------------------------------------------------
// Copy constructor
//-------------------------------------------------------------------
ClpDynamicExampleMatrix::ClpDynamicExampleMatrix (const ClpDynamicExampleMatrix & rhs)
: ClpDynamicMatrix(rhs)
{
numberColumns_ = rhs.numberColumns_;
startColumnGen_ = ClpCopyOfArray(rhs.startColumnGen_, numberColumns_ + 1);
CoinBigIndex numberElements = startColumnGen_[numberColumns_];
rowGen_ = ClpCopyOfArray(rhs.rowGen_, numberElements);;
elementGen_ = ClpCopyOfArray(rhs.elementGen_, numberElements);;
costGen_ = ClpCopyOfArray(rhs.costGen_, numberColumns_);
fullStartGen_ = ClpCopyOfArray(rhs.fullStartGen_, numberSets_ + 1);
dynamicStatusGen_ = ClpCopyOfArray(rhs.dynamicStatusGen_, numberColumns_);
idGen_ = ClpCopyOfArray(rhs.idGen_, maximumGubColumns_);
columnLowerGen_ = ClpCopyOfArray(rhs.columnLowerGen_, numberColumns_);
columnUpperGen_ = ClpCopyOfArray(rhs.columnUpperGen_, numberColumns_);
}
// Assignment operator. This copies the data
ClpLsqr &
ClpLsqr::operator=(const ClpLsqr &rhs)
{
if (this != &rhs) {
delete[] diag1_;
diag1_ = ClpCopyOfArray(rhs.diag1_, nrows_);
nrows_ = rhs.nrows_;
ncols_ = rhs.ncols_;
model_ = rhs.model_;
diag2_ = rhs.diag2_;
}
return *this;
}
/* This is the real constructor*/
ClpDynamicExampleMatrix::ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
int numberGubColumns, const int * starts,
const double * lower, const double * upper,
const CoinBigIndex * startColumn, const int * row,
const double * element, const double * cost,
const double * columnLower, const double * columnUpper,
const unsigned char * status,
const unsigned char * dynamicStatus,
int numberIds, const int *ids)
: ClpDynamicMatrix(model, numberSets, 0, NULL, lower, upper, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL)
{
setType(25);
numberColumns_ = numberGubColumns;
// start with safe values - then experiment
maximumGubColumns_ = numberColumns_;
maximumElements_ = startColumn[numberColumns_];
// delete odd stuff created by ClpDynamicMatrix constructor
delete [] startSet_;
startSet_ = new int [numberSets_];
delete [] next_;
next_ = new int [maximumGubColumns_];
delete [] row_;
delete [] element_;
delete [] startColumn_;
delete [] cost_;
delete [] columnLower_;
delete [] columnUpper_;
delete [] dynamicStatus_;
delete [] status_;
delete [] id_;
// and size correctly
row_ = new int [maximumElements_];
element_ = new double [maximumElements_];
startColumn_ = new CoinBigIndex [maximumGubColumns_+1];
// say no columns yet
numberGubColumns_ = 0;
startColumn_[0] = 0;
cost_ = new double[maximumGubColumns_];
dynamicStatus_ = new unsigned char [2*maximumGubColumns_];
memset(dynamicStatus_, 0, maximumGubColumns_);
id_ = new int[maximumGubColumns_];
if (columnLower)
columnLower_ = new double[maximumGubColumns_];
else
columnLower_ = NULL;
if (columnUpper)
columnUpper_ = new double[maximumGubColumns_];
else
columnUpper_ = NULL;
// space for ids
idGen_ = new int [maximumGubColumns_];
int iSet;
for (iSet = 0; iSet < numberSets_; iSet++)
startSet_[iSet] = -1;
// This starts code specific to this storage method
CoinBigIndex i;
fullStartGen_ = ClpCopyOfArray(starts, numberSets_ + 1);
startColumnGen_ = ClpCopyOfArray(startColumn, numberColumns_ + 1);
CoinBigIndex numberElements = startColumnGen_[numberColumns_];
rowGen_ = ClpCopyOfArray(row, numberElements);
elementGen_ = new double[numberElements];
for (i = 0; i < numberElements; i++)
elementGen_[i] = element[i];
costGen_ = new double[numberColumns_];
for (i = 0; i < numberColumns_; i++) {
costGen_[i] = cost[i];
// I don't think I need sorted but ...
CoinSort_2(rowGen_ + startColumnGen_[i], rowGen_ + startColumnGen_[i+1], elementGen_ + startColumnGen_[i]);
}
if (columnLower) {
columnLowerGen_ = new double[numberColumns_];
for (i = 0; i < numberColumns_; i++) {
columnLowerGen_[i] = columnLower[i];
if (columnLowerGen_[i]) {
printf("Non-zero lower bounds not allowed - subtract from model\n");
abort();
}
}
} else {
columnLowerGen_ = NULL;
}
if (columnUpper) {
columnUpperGen_ = new double[numberColumns_];
for (i = 0; i < numberColumns_; i++)
columnUpperGen_[i] = columnUpper[i];
} else {
columnUpperGen_ = NULL;
}
// end specific coding
if (columnUpper_) {
// set all upper bounds so we have enough space
double * columnUpper = model->columnUpper();
for(i = firstDynamic_; i < lastDynamic_; i++)
columnUpper[i] = 1.0e10;
}
status_ = new unsigned char [2*numberSets_+4];
if (status) {
memcpy(status_,status, numberSets_ * sizeof(char));
assert (dynamicStatus);
CoinMemcpyN(dynamicStatus, numberIds, dynamicStatus_);
assert (numberIds);
} else {
assert (!numberIds);
memset(status_, 0, numberSets_);
for (i = 0; i < numberSets_; i++) {
// make slack key
setStatus(i, ClpSimplex::basic);
}
}
dynamicStatusGen_ = new unsigned char [numberColumns_];
memset(dynamicStatusGen_, 0, numberColumns_); // for clarity
for (i = 0; i < numberColumns_; i++)
setDynamicStatusGen(i, atLowerBound);
// Populate with enough columns
if (!numberIds) {
// This could be made more sophisticated
for (iSet = 0; iSet < numberSets_; iSet++) {
int sequence = fullStartGen_[iSet];
CoinBigIndex start = startColumnGen_[sequence];
addColumn(startColumnGen_[sequence+1] - start,
rowGen_ + start,
elementGen_ + start,
costGen_[sequence],
columnLowerGen_ ? columnLowerGen_[sequence] : 0,
columnUpperGen_ ? columnUpperGen_[sequence] : 1.0e30,
iSet, getDynamicStatusGen(sequence));
idGen_[iSet] = sequence; // say which one in
setDynamicStatusGen(sequence, inSmall);
}
} else {
// put back old ones
int * set = new int[numberColumns_];
for (iSet = 0; iSet < numberSets_; iSet++) {
for (CoinBigIndex j = fullStartGen_[iSet]; j < fullStartGen_[iSet+1]; j++)
set[j] = iSet;
}
for (int i = 0; i < numberIds; i++) {
int sequence = ids[i];
CoinBigIndex start = startColumnGen_[sequence];
addColumn(startColumnGen_[sequence+1] - start,
rowGen_ + start,
elementGen_ + start,
costGen_[sequence],
columnLowerGen_ ? columnLowerGen_[sequence] : 0,
columnUpperGen_ ? columnUpperGen_[sequence] : 1.0e30,
set[sequence], getDynamicStatus(i));
idGen_[iSet] = sequence; // say which one in
setDynamicStatusGen(sequence, inSmall);
}
delete [] set;
}
if (!status) {
gubCrash();
} else {
initialProblem();
}
}
void
ClpInterior::gutsOfCopy(const ClpInterior & rhs)
{
lower_ = ClpCopyOfArray(rhs.lower_, numberColumns_ + numberRows_);
rowLowerWork_ = lower_ + numberColumns_;
columnLowerWork_ = lower_;
upper_ = ClpCopyOfArray(rhs.upper_, numberColumns_ + numberRows_);
rowUpperWork_ = upper_ + numberColumns_;
columnUpperWork_ = upper_;
//cost_ = ClpCopyOfArray(rhs.cost_,2*(numberColumns_+numberRows_));
cost_ = ClpCopyOfArray(rhs.cost_, numberColumns_);
rhs_ = ClpCopyOfArray(rhs.rhs_, numberRows_);
x_ = ClpCopyOfArray(rhs.x_, numberColumns_);
y_ = ClpCopyOfArray(rhs.y_, numberRows_);
dj_ = ClpCopyOfArray(rhs.dj_, numberColumns_ + numberRows_);
lsqrObject_ = rhs.lsqrObject_ != NULL ? new ClpLsqr(*rhs.lsqrObject_) : NULL;
pdcoStuff_ = rhs.pdcoStuff_ != NULL ? rhs.pdcoStuff_->clone() : NULL;
largestPrimalError_ = rhs.largestPrimalError_;
largestDualError_ = rhs.largestDualError_;
sumDualInfeasibilities_ = rhs.sumDualInfeasibilities_;
sumPrimalInfeasibilities_ = rhs.sumPrimalInfeasibilities_;
worstComplementarity_ = rhs.worstComplementarity_;
xsize_ = rhs.xsize_;
zsize_ = rhs.zsize_;
solveType_ = rhs.solveType_;
mu_ = rhs.mu_;
objectiveNorm_ = rhs.objectiveNorm_;
rhsNorm_ = rhs.rhsNorm_;
solutionNorm_ = rhs.solutionNorm_;
dualObjective_ = rhs.dualObjective_;
primalObjective_ = rhs.primalObjective_;
diagonalNorm_ = rhs.diagonalNorm_;
stepLength_ = rhs.stepLength_;
linearPerturbation_ = rhs.linearPerturbation_;
diagonalPerturbation_ = rhs.diagonalPerturbation_;
gamma_ = rhs.gamma_;
delta_ = rhs.delta_;
targetGap_ = rhs.targetGap_;
projectionTolerance_ = rhs.projectionTolerance_;
maximumRHSError_ = rhs.maximumRHSError_;
maximumBoundInfeasibility_ = rhs.maximumBoundInfeasibility_;
maximumDualError_ = rhs.maximumDualError_;
diagonalScaleFactor_ = rhs.diagonalScaleFactor_;
scaleFactor_ = rhs.scaleFactor_;
actualPrimalStep_ = rhs.actualPrimalStep_;
actualDualStep_ = rhs.actualDualStep_;
smallestInfeasibility_ = rhs.smallestInfeasibility_;
complementarityGap_ = rhs.complementarityGap_;
baseObjectiveNorm_ = rhs.baseObjectiveNorm_;
worstDirectionAccuracy_ = rhs.worstDirectionAccuracy_;
maximumRHSChange_ = rhs.maximumRHSChange_;
errorRegion_ = ClpCopyOfArray(rhs.errorRegion_, numberRows_);
rhsFixRegion_ = ClpCopyOfArray(rhs.rhsFixRegion_, numberRows_);
deltaY_ = ClpCopyOfArray(rhs.deltaY_, numberRows_);
upperSlack_ = ClpCopyOfArray(rhs.upperSlack_, numberRows_ + numberColumns_);
lowerSlack_ = ClpCopyOfArray(rhs.lowerSlack_, numberRows_ + numberColumns_);
diagonal_ = ClpCopyOfArray(rhs.diagonal_, numberRows_ + numberColumns_);
deltaX_ = ClpCopyOfArray(rhs.deltaX_, numberRows_ + numberColumns_);
deltaZ_ = ClpCopyOfArray(rhs.deltaZ_, numberRows_ + numberColumns_);
deltaW_ = ClpCopyOfArray(rhs.deltaW_, numberRows_ + numberColumns_);
deltaSU_ = ClpCopyOfArray(rhs.deltaSU_, numberRows_ + numberColumns_);
deltaSL_ = ClpCopyOfArray(rhs.deltaSL_, numberRows_ + numberColumns_);
primalR_ = ClpCopyOfArray(rhs.primalR_, numberRows_ + numberColumns_);
dualR_ = ClpCopyOfArray(rhs.dualR_, numberRows_ + numberColumns_);
rhsB_ = ClpCopyOfArray(rhs.rhsB_, numberRows_);
rhsU_ = ClpCopyOfArray(rhs.rhsU_, numberRows_ + numberColumns_);
rhsL_ = ClpCopyOfArray(rhs.rhsL_, numberRows_ + numberColumns_);
rhsZ_ = ClpCopyOfArray(rhs.rhsZ_, numberRows_ + numberColumns_);
rhsW_ = ClpCopyOfArray(rhs.rhsW_, numberRows_ + numberColumns_);
rhsC_ = ClpCopyOfArray(rhs.rhsC_, numberRows_ + numberColumns_);
solution_ = ClpCopyOfArray(rhs.solution_, numberRows_ + numberColumns_);
workArray_ = ClpCopyOfArray(rhs.workArray_, numberRows_ + numberColumns_);
zVec_ = ClpCopyOfArray(rhs.zVec_, numberRows_ + numberColumns_);
wVec_ = ClpCopyOfArray(rhs.wVec_, numberRows_ + numberColumns_);
cholesky_ = rhs.cholesky_->clone();
numberComplementarityPairs_ = rhs.numberComplementarityPairs_;
numberComplementarityItems_ = rhs.numberComplementarityItems_;
maximumBarrierIterations_ = rhs.maximumBarrierIterations_;
gonePrimalFeasible_ = rhs.gonePrimalFeasible_;
goneDualFeasible_ = rhs.goneDualFeasible_;
algorithm_ = rhs.algorithm_;
}
