/*
Comments needed
Returns 1 if solution, 0 if not */
int
CbcHeuristicPivotAndFix::solution(double & /*solutionValue*/,
double * /*betterSolution*/)
{
numCouldRun_++; // Todo: Ask JJHF what this for.
std::cout << "Entering Pivot-and-Fix Heuristic" << std::endl;
#ifdef HEURISTIC_INFORM
printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
heuristicName(),numRuns_,numCouldRun_,when_);
#endif
#ifdef FORNOW
std::cout << "Lucky you! You're in the Pivot-and-Fix Heuristic" << std::endl;
// The struct should be moved to member data
typedef struct {
int numberSolutions;
int maximumSolutions;
int numberColumns;
double ** solution;
int * numberUnsatisfied;
} clpSolution;
double start = CoinCpuTime();
OsiClpSolverInterface * clpSolverOriginal
= dynamic_cast<OsiClpSolverInterface *> (model_->solver());
assert (clpSolverOriginal);
OsiClpSolverInterface *clpSolver(clpSolverOriginal);
ClpSimplex * simplex = clpSolver->getModelPtr();
// Initialize the structure holding the solutions
clpSolution solutions;
// Set typeStruct field of ClpTrustedData struct to one.
// This tells Clp it's "Mahdi!"
ClpTrustedData trustedSolutions;
trustedSolutions.typeStruct = 1;
trustedSolutions.data = &solutions;
solutions.numberSolutions = 0;
solutions.maximumSolutions = 0;
solutions.numberColumns = simplex->numberColumns();
solutions.solution = NULL;
solutions.numberUnsatisfied = NULL;
simplex->setTrustedUserPointer(&trustedSolutions);
// Solve from all slack to get some points
simplex->allSlackBasis();
simplex->primal();
// -------------------------------------------------
// Get the problem information
// - get the number of cols and rows
int numCols = clpSolver->getNumCols();
int numRows = clpSolver->getNumRows();
// - get the right hand side of the rows
const double * rhs = clpSolver->getRightHandSide();
// - find the integer variables
bool * varClassInt = new bool[numCols];
int numInt = 0;
for (int i = 0; i < numCols; i++) {
if (clpSolver->isContinuous(i))
varClassInt[i] = 0;
else {
varClassInt[i] = 1;
numInt++;
}
}
// -Get the rows sense
const char * rowSense;
rowSense = clpSolver->getRowSense();
// -Get the objective coefficients
const double *objCoefficients = clpSolver->getObjCoefficients();
double *originalObjCoeff = new double [numCols];
for (int i = 0; i < numCols; i++)
originalObjCoeff[i] = objCoefficients[i];
// -Get the matrix of the problem
double ** matrix = new double * [numRows];
for (int i = 0; i < numRows; i++) {
matrix[i] = new double[numCols];
for (int j = 0; j < numCols; j++)
matrix[i][j] = 0;
}
const CoinPackedMatrix* matrixByRow = clpSolver->getMatrixByRow();
const double * matrixElements = matrixByRow->getElements();
const int * matrixIndices = matrixByRow->getIndices();
const int * matrixStarts = matrixByRow->getVectorStarts();
for (int j = 0; j < numRows; j++) {
for (int i = matrixStarts[j]; i < matrixStarts[j+1]; i++) {
matrix[j][matrixIndices[i]] = matrixElements[i];
}
}
// The newObj is the randomly perturbed constraint used to find new
// corner points
double * newObj = new double [numCols];
// Set the random seed
srand ( time(NULL) + 1);
int randNum;
// We're going to add a new row to the LP formulation
// after finding each new solution.
// Adding a new row requires the new elements and the new indices.
// The elements are original objective function coefficients.
// The indicies are the (dense) columns indices stored in addRowIndex.
// The rhs is the value of the new solution stored in solutionValue.
int * addRowIndex = new int[numCols];
for (int i = 0; i < numCols; i++)
addRowIndex[i] = i;
// The number of feasible solutions found by the PF heuristic.
// This controls the return code of the solution() method.
int numFeasibles = 0;
// Shuffle the rows
int * index = new int [numRows];
for (int i = 0; i < numRows; i++)
index[i] = i;
for (int i = 0; i < numRows; i++) {
int temp = index[i];
int randNumTemp = i + (rand() % (numRows - i));
index[i] = index[randNumTemp];
index[randNumTemp] = temp;
}
// In the clpSolution struct, we store a lot of column solutions.
// For each perturb objective, we store the solution from each
// iteration of the LP solve.
// For each perturb objective, we look at the collection of
// solutions to do something extremly intelligent :-)
// We could (and should..and will :-) wipe out the block of
// solutions when we're done with them. But for now, we just move on
// and store the next block of solutions for the next (perturbed)
// objective.
// The variable startIndex tells us where the new block begins.
int startIndex = 0;
// At most "fixThreshold" number of integer variables can be unsatisfied
// for calling smallBranchAndBound().
// The PF Heuristic only fixes fixThreshold number of variables to
// their integer values. Not more. Not less. The reason is to give
// the smallBB some opportunity to find better solutions. If we fix
// everything it might be too many (leading the heuristic to come up
// with infeasibility rather than a useful result).
// (This is an important paramater. And it is dynamically set.)
double fixThreshold;
/*
if(numInt > 400)
fixThreshold = 17*sqrt(numInt);
if(numInt<=400 && numInt>100)
fixThreshold = 5*sqrt(numInt);
if(numInt<=100)
fixThreshold = 4*sqrt(numInt);
*/
// Initialize fixThreshold based on the number of integer
// variables
if (numInt <= 100)
fixThreshold = .35 * numInt;
if (numInt > 100 && numInt < 1000)
fixThreshold = .85 * numInt;
if (numInt >= 1000)
fixThreshold = .1 * numInt;
// Whenever the dynamic system for changing fixThreshold
// kicks in, it changes the parameter by the
// fixThresholdChange amount.
// (The 25% should be member data and tuned. Another paper!)
double fixThresholdChange = 0.25 * fixThreshold;
// maxNode is the maximum number of nodes we allow smallBB to
// search. It's initialized to 400 and changed dynamically.
// The 400 should be member data, if we become virtuous.
int maxNode = 400;
// We control the decision to change maxNode through the boolean
// variable changeMaxNode. The boolean variable is initialized to
// true and gets set to false under a condition (and is never true
// again.)
// It's flipped off and stays off (in the current incarnation of PF)
bool changeMaxNode = 1;
// The sumReturnCode is used for the dynamic system that sets
// fixThreshold and changeMaxNode.
//
// We track what's happening in sumReturnCode. There are 8 switches.
// The first 5 switches corresponds to a return code for smallBB.
//
// We want to know how many times we consecutively get the same
// return code.
//
// If "good" return codes are happening often enough, we're happy.
//
// If a "bad" returncodes happen consecutively, we want to
// change something.
//
// The switch 5 is the number of times PF didn't call smallBB
// becuase the number of integer variables that took integer values
// was less than fixThreshold.
//
// The swicth 6 was added for a brilliant idea...to be announced
// later (another paper!)
//
// The switch 7 is the one that changes the max node. Read the
// code. (Todo: Verbalize the brilliant idea for the masses.)
//
int sumReturnCode[8];
/*
sumReturnCode[0] ~ -1 --> problem too big for smallBB
sumReturnCode[1] ~ 0 --> smallBB not finshed and no soln
sumReturnCode[2] ~ 1 --> smallBB not finshed and there is a soln
sumReturnCode[3] ~ 2 --> smallBB finished and no soln
sumReturnCode[4] ~ 3 --> smallBB finished and there is a soln
sumReturnCode[5] ~ didn't call smallBranchAndBound too few to fix
sumReturnCode[6] ~ didn't call smallBranchAndBound too many unsatisfied
sumReturnCode[7] ~ the same as sumReturnCode[1] but becomes zero just if the returnCode is not 0
*/
for (int i = 0; i < 8; i++)
sumReturnCode[i] = 0;
int * colIndex = new int[numCols];
for (int i = 0; i < numCols; i++)
colIndex[i] = i;
double cutoff = COIN_DBL_MAX;
bool didMiniBB;
// Main loop
for (int i = 0; i < numRows; i++) {
// track the number of mini-bb for the dynamic threshold setting
didMiniBB = 0;
for (int k = startIndex; k < solutions.numberSolutions; k++)
//if the point has 0 unsatisfied variables; make sure it is
//feasible. Check integer feasiblity and constraints.
if (solutions.numberUnsatisfied[k] == 0) {
double feasibility = 1;
//check integer feasibility
for (int icol = 0; icol < numCols; icol++) {
double closest = floor(solutions.solution[k][icol] + 0.5);
if (varClassInt[icol] && (fabs(solutions.solution[k][icol] - closest) > 1e-6)) {
feasibility = 0;
break;
}
}
//check if the solution satisfies the constraints
for (int irow = 0; irow < numRows; irow++) {
double lhs = 0;
for (int j = 0; j < numCols; j++)
lhs += matrix[irow][j] * solutions.solution[k][j];
if (rowSense[irow] == 'L' && lhs > rhs[irow] + 1e-6) {
feasibility = 0;
break;
}
if (rowSense[irow] == 'G' && lhs < rhs[irow] - 1e-6) {
feasibility = 0;
break;
}
if (rowSense[irow] == 'E' && (lhs - rhs[irow] > 1e-6 || lhs - rhs[irow] < -1e-6)) {
feasibility = 0;
break;
}
}
//if feasible, find the objective value and set the cutoff
// for the smallBB and add a new constraint to the LP
// (and update the best solution found so far for the
// return arguments)
if (feasibility) {
double objectiveValue = 0;
for (int j = 0; j < numCols; j++)
objectiveValue += solutions.solution[k][j] * originalObjCoeff[j];
cutoff = objectiveValue;
clpSolver->addRow(numCols, addRowIndex, originalObjCoeff, -COIN_DBL_MAX, cutoff);
// Todo: pick up the best solution in the block (not
// the last).
solutionValue = objectiveValue;
for (int m = 0; m < numCols; m++)
betterSolution[m] = solutions.solution[k][m];
numFeasibles++;
}
}
// Go through the block of solution and decide if to call smallBB
for (int k = startIndex; k < solutions.numberSolutions; k++) {
if (solutions.numberUnsatisfied[k] <= fixThreshold) {
// get new copy
OsiSolverInterface * newSolver;
newSolver = new OsiClpSolverInterface(*clpSolver);
newSolver->setObjSense(1);
newSolver->setObjective(originalObjCoeff);
int numberColumns = newSolver->getNumCols();
int numFixed = 0;
// Fix the first fixThreshold number of integer vars
// that are satisfied
for (int iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
if (newSolver->isInteger(iColumn)) {
double value = solutions.solution[k][iColumn];
double intValue = floor(value + 0.5);
if (fabs(value - intValue) < 1.0e-5) {
newSolver->setColLower(iColumn, intValue);
newSolver->setColUpper(iColumn, intValue);
numFixed++;
if (numFixed > numInt - fixThreshold)
break;
}
}
}
COIN_DETAIL_PRINT(printf("numFixed: %d\n", numFixed));
COIN_DETAIL_PRINT(printf("fixThreshold: %f\n", fixThreshold));
COIN_DETAIL_PRINT(printf("numInt: %d\n", numInt));
double *newSolution = new double[numCols];
double newSolutionValue;
// Call smallBB on the modified problem
int returnCode = smallBranchAndBound(newSolver, maxNode, newSolution,
newSolutionValue, cutoff, "mini");
// If smallBB found a solution, update the better
// solution and solutionValue (we gave smallBB our
// cutoff, so it only finds improving solutions)
if (returnCode == 1 || returnCode == 3) {
numFeasibles ++;
solutionValue = newSolutionValue;
for (int m = 0; m < numCols; m++)
betterSolution[m] = newSolution[m];
COIN_DETAIL_PRINT(printf("cutoff: %f\n", newSolutionValue));
COIN_DETAIL_PRINT(printf("time: %.2lf\n", CoinCpuTime() - start));
}
didMiniBB = 1;
COIN_DETAIL_PRINT(printf("returnCode: %d\n", returnCode));
//Update sumReturnCode array
for (int iRC = 0; iRC < 6; iRC++) {
if (iRC == returnCode + 1)
sumReturnCode[iRC]++;
else
sumReturnCode[iRC] = 0;
}
if (returnCode != 0)
sumReturnCode[7] = 0;
else
sumReturnCode[7]++;
if (returnCode == 1 || returnCode == 3) {
cutoff = newSolutionValue;
clpSolver->addRow(numCols, addRowIndex, originalObjCoeff, -COIN_DBL_MAX, cutoff);
COIN_DETAIL_PRINT(printf("******************\n\n*****************\n"));
}
break;
}
}
if (!didMiniBB && solutions.numberSolutions - startIndex > 0) {
sumReturnCode[5]++;
for (int iRC = 0; iRC < 5; iRC++)
sumReturnCode[iRC] = 0;
}
//Change "fixThreshold" if needed
// using the data we've recorded in sumReturnCode
if (sumReturnCode[1] >= 3)
fixThreshold -= fixThresholdChange;
if (sumReturnCode[7] >= 3 && changeMaxNode) {
maxNode *= 5;
changeMaxNode = 0;
}
if (sumReturnCode[3] >= 3 && fixThreshold < 0.95 * numInt)
fixThreshold += fixThresholdChange;
if (sumReturnCode[5] >= 4)
fixThreshold += fixThresholdChange;
if (sumReturnCode[0] > 3)
fixThreshold -= fixThresholdChange;
startIndex = solutions.numberSolutions;
//Check if the maximum iterations limit is reached
// rlh: Ask John how this is working with the change to trustedUserPtr.
if (solutions.numberSolutions > 20000)
break;
// The first time in this loop PF solves orig LP.
//Generate the random objective function
randNum = rand() % 10 + 1;
randNum = fmod(randNum, 2);
for (int j = 0; j < numCols; j++) {
if (randNum == 1)
if (fabs(matrix[index[i]][j]) < 1e-6)
newObj[j] = 0.1;
else
newObj[j] = matrix[index[i]][j] * 1.1;
else if (fabs(matrix[index[i]][j]) < 1e-6)
newObj[j] = -0.1;
else
newObj[j] = matrix[index[i]][j] * 0.9;
}
clpSolver->setObjective(newObj);
if (rowSense[i] == 'L')
clpSolver->setObjSense(-1);
else
// Todo #1: We don't need to solve the LPs to optimality.
// We just need corner points.
// There's a problem in stopping Clp that needs to be looked
// into. So for now, we solve optimality.
clpSolver->setObjSense(1);
// simplex->setMaximumIterations(100);
clpSolver->getModelPtr()->primal(1);
// simplex->setMaximumIterations(100000);
#ifdef COIN_DETAIL
printf("cutoff: %f\n", cutoff);
printf("time: %.2f\n", CoinCpuTime() - start);
for (int iRC = 0; iRC < 8; iRC++)
printf("%d ", sumReturnCode[iRC]);
printf("\nfixThreshold: %f\n", fixThreshold);
printf("numInt: %d\n", numInt);
printf("\n---------------------------------------------------------------- %d\n", i);
#endif
//temp:
if (i > 3) break;
}
COIN_DETAIL_PRINT(printf("Best Feasible Found: %f\n", cutoff));
COIN_DETAIL_PRINT(printf("Total time: %.2f\n", CoinCpuTime() - start));
if (numFeasibles == 0) {
return 0;
}
// We found something better
std::cout << "See you soon! You're leaving the Pivot-and-Fix Heuristic" << std::endl;
std::cout << std::endl;
return 1;
#endif
return 0;
}
/* Orders rows and saves pointer to matrix.and model */
int
ClpCholeskyMumps::order(ClpInterior * model)
{
numberRows_ = model->numberRows();
if (doKKT_) {
numberRows_ += numberRows_ + model->numberColumns();
printf("finish coding MUMPS KKT!\n");
abort();
}
rowsDropped_ = new char [numberRows_];
memset(rowsDropped_, 0, numberRows_);
numberRowsDropped_ = 0;
model_ = model;
rowCopy_ = model->clpMatrix()->reverseOrderedCopy();
const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
const int * columnLength = model_->clpMatrix()->getVectorLengths();
const int * row = model_->clpMatrix()->getIndices();
const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
const int * rowLength = rowCopy_->getVectorLengths();
const int * column = rowCopy_->getIndices();
// We need two arrays for counts
int * which = new int [numberRows_];
int * used = new int[numberRows_+1];
CoinZeroN(used, numberRows_);
int iRow;
sizeFactor_ = 0;
for (iRow = 0; iRow < numberRows_; iRow++) {
int number = 1;
// make sure diagonal exists
which[0] = iRow;
used[iRow] = 1;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
if (!used[jRow]) {
used[jRow] = 1;
which[number++] = jRow;
}
}
}
}
sizeFactor_ += number;
int j;
for (j = 0; j < number; j++)
used[which[j]] = 0;
}
}
delete [] which;
// NOT COMPRESSED FOR NOW ??? - Space for starts
mumps_->ICNTL(5) = 0; // say NOT compressed format
try {
choleskyStart_ = new CoinBigIndex[numberRows_+1+sizeFactor_];
} catch (...) {
// no memory
return -1;
}
// Now we have size - create arrays and fill in
try {
choleskyRow_ = new int [sizeFactor_];
} catch (...) {
// no memory
delete [] choleskyStart_;
choleskyStart_ = NULL;
return -1;
}
try {
sparseFactor_ = new double[sizeFactor_];
} catch (...) {
// no memory
delete [] choleskyRow_;
choleskyRow_ = NULL;
delete [] choleskyStart_;
choleskyStart_ = NULL;
return -1;
}
sizeFactor_ = 0;
which = choleskyRow_;
for (iRow = 0; iRow < numberRows_; iRow++) {
int number = 1;
// make sure diagonal exists
which[0] = iRow;
used[iRow] = 1;
choleskyStart_[iRow] = sizeFactor_;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
if (!used[jRow]) {
used[jRow] = 1;
which[number++] = jRow;
}
}
}
}
sizeFactor_ += number;
int j;
for (j = 0; j < number; j++)
used[which[j]] = 0;
// Sort
std::sort(which, which + number);
// move which on
which += number;
}
}
choleskyStart_[numberRows_] = sizeFactor_;
delete [] used;
permuteInverse_ = new int [numberRows_];
permute_ = new int[numberRows_];
// To Fortran and fake
for (iRow = 0; iRow < numberRows_ + 1; iRow++) {
int k = choleskyStart_[iRow];
int kEnd = choleskyStart_[iRow+1];
k += numberRows_ + 1;
kEnd += numberRows_ + 1;
for (; k < kEnd; k++)
choleskyStart_[k] = iRow + 1;
choleskyStart_[iRow]++;
}
mumps_->nz = sizeFactor_;
mumps_->irn = choleskyStart_ + numberRows_ + 1;
mumps_->jcn = choleskyRow_;
mumps_->a = NULL;
for (CoinBigIndex i = 0; i < sizeFactor_; i++) {
choleskyRow_[i]++;
#ifndef NDEBUG
assert (mumps_->irn[i] >= 1 && mumps_->irn[i] <= numberRows_);
assert (mumps_->jcn[i] >= 1 && mumps_->jcn[i] <= numberRows_);
#endif
}
// validate
//mumps code here
mumps_->n = numberRows_;
mumps_->nelt = numberRows_;
mumps_->eltptr = choleskyStart_;
mumps_->eltvar = choleskyRow_;
mumps_->a_elt = NULL;
mumps_->rhs = NULL;
mumps_->job = 1; // order
dmumps_c(mumps_);
mumps_->a = sparseFactor_;
if (mumps_->infog[0]) {
COIN_DETAIL_PRINT(printf("MUMPS ordering failed -error %d %d\n",
mumps_->infog[0], mumps_->infog[1]));
return 1;
} else {
double size = mumps_->infog[19];
if (size < 0)
size *= -1000000;
COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", size, mumps_->rinfog[0]));
}
for (iRow = 0; iRow < numberRows_; iRow++) {
permuteInverse_[iRow] = iRow;
permute_[iRow] = iRow;
}
return 0;
}
/* Factorize - filling in rowsDropped and returning number dropped */
int
ClpCholeskyMumps::factorize(const double * diagonal, int * rowsDropped)
{
const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
const int * columnLength = model_->clpMatrix()->getVectorLengths();
const int * row = model_->clpMatrix()->getIndices();
const double * element = model_->clpMatrix()->getElements();
const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
const int * rowLength = rowCopy_->getVectorLengths();
const int * column = rowCopy_->getIndices();
const double * elementByRow = rowCopy_->getElements();
int numberColumns = model_->clpMatrix()->getNumCols();
int iRow;
double * work = new double[numberRows_];
CoinZeroN(work, numberRows_);
const double * diagonalSlack = diagonal + numberColumns;
int newDropped = 0;
double largest;
//double smallest;
//perturbation
double perturbation = model_->diagonalPerturbation() * model_->diagonalNorm();
perturbation = 0.0;
perturbation = perturbation * perturbation;
if (perturbation > 1.0) {
#ifdef COIN_DEVELOP
//if (model_->model()->logLevel()&4)
std::cout << "large perturbation " << perturbation << std::endl;
#endif
perturbation = sqrt(perturbation);;
perturbation = 1.0;
}
double delta2 = model_->delta(); // add delta*delta to diagonal
delta2 *= delta2;
for (iRow = 0; iRow < numberRows_; iRow++) {
double * put = sparseFactor_ + choleskyStart_[iRow] - 1; // Fortran
int * which = choleskyRow_ + choleskyStart_[iRow] - 1; // Fortran
int number = choleskyStart_[iRow+1] - choleskyStart_[iRow];
if (!rowLength[iRow])
rowsDropped_[iRow] = 1;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
work[iRow] = diagonalSlack[iRow] + delta2;
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
if (!whichDense_ || !whichDense_[iColumn]) {
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
double multiplier = diagonal[iColumn] * elementByRow[k];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
double value = element[j] * multiplier;
work[jRow] += value;
}
}
}
}
int j;
for (j = 0; j < number; j++) {
int jRow = which[j] - 1; // to Fortran
put[j] = work[jRow];
work[jRow] = 0.0;
}
} else {
// dropped
int j;
for (j = 1; j < number; j++) {
put[j] = 0.0;
}
put[0] = 1.0;
}
}
//check sizes
double largest2 = maximumAbsElement(sparseFactor_, sizeFactor_);
largest2 *= 1.0e-20;
largest = CoinMin(largest2, 1.0e-11);
int numberDroppedBefore = 0;
for (iRow = 0; iRow < numberRows_; iRow++) {
int dropped = rowsDropped_[iRow];
// Move to int array
rowsDropped[iRow] = dropped;
if (!dropped) {
CoinBigIndex start = choleskyStart_[iRow] - 1; // to Fortran
double diagonal = sparseFactor_[start];
if (diagonal > largest2) {
sparseFactor_[start] = CoinMax(diagonal, 1.0e-10);
} else {
sparseFactor_[start] = CoinMax(diagonal, 1.0e-10);
rowsDropped[iRow] = 2;
numberDroppedBefore++;
}
}
}
delete [] work;
// code here
mumps_->a_elt = sparseFactor_;
mumps_->rhs = NULL;
mumps_->job = 2; // factorize
dmumps_c(mumps_);
if (mumps_->infog[0]) {
COIN_DETAIL_PRINT(printf("MUMPS factorization failed -error %d %d\n",
mumps_->infog[0], mumps_->infog[1]));
}
choleskyCondition_ = 1.0;
bool cleanCholesky;
if (model_->numberIterations() < 2000)
cleanCholesky = true;
else
cleanCholesky = false;
if (cleanCholesky) {
//drop fresh makes some formADAT easier
//int oldDropped=numberRowsDropped_;
if (newDropped || numberRowsDropped_) {
//std::cout <<"Rank "<<numberRows_-newDropped<<" ( "<<
// newDropped<<" dropped)";
//if (newDropped>oldDropped)
//std::cout<<" ( "<<newDropped-oldDropped<<" dropped this time)";
//std::cout<<std::endl;
newDropped = 0;
for (int i = 0; i < numberRows_; i++) {
int dropped = rowsDropped[i];
rowsDropped_[i] = (char)dropped;
if (dropped == 2) {
//dropped this time
rowsDropped[newDropped++] = i;
rowsDropped_[i] = 0;
}
}
numberRowsDropped_ = newDropped;
newDropped = -(2 + newDropped);
}
} else {
if (newDropped) {
newDropped = 0;
for (int i = 0; i < numberRows_; i++) {
int dropped = rowsDropped[i];
rowsDropped_[i] = (char)dropped;
if (dropped == 2) {
//dropped this time
rowsDropped[newDropped++] = i;
rowsDropped_[i] = 1;
}
}
}
numberRowsDropped_ += newDropped;
if (numberRowsDropped_ && 0) {
std::cout << "Rank " << numberRows_ - numberRowsDropped_ << " ( " <<
numberRowsDropped_ << " dropped)";
if (newDropped) {
std::cout << " ( " << newDropped << " dropped this time)";
}
std::cout << std::endl;
}
}
status_ = 0;
return newDropped;
}
int
CbcBranchDefaultDecision::bestBranch (CbcBranchingObject ** objects, int numberObjects,
int numberUnsatisfied,
double * changeUp, int * numberInfeasibilitiesUp,
double * changeDown, int * numberInfeasibilitiesDown,
double objectiveValue)
{
int bestWay = 0;
int whichObject = -1;
if (numberObjects) {
CbcModel * model = cbcModel();
// at continuous
//double continuousObjective = model->getContinuousObjective();
//int continuousInfeasibilities = model->getContinuousInfeasibilities();
// average cost to get rid of infeasibility
//double averageCostPerInfeasibility =
//(objectiveValue-continuousObjective)/
//(double) (abs(continuousInfeasibilities-numberUnsatisfied)+1);
/* beforeSolution is :
0 - before any solution
n - n heuristic solutions but no branched one
-1 - branched solution found
*/
int numberSolutions = model->getSolutionCount();
double cutoff = model->getCutoff();
int method = 0;
int i;
if (numberSolutions) {
int numberHeuristic = model->getNumberHeuristicSolutions();
if (numberHeuristic < numberSolutions) {
method = 1;
} else {
method = 2;
// look further
for ( i = 0 ; i < numberObjects ; i++) {
int numberNext = numberInfeasibilitiesUp[i];
if (numberNext < numberUnsatisfied) {
int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
double perUnsatisfied = changeUp[i] / static_cast<double> (numberUp);
double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
if (estimatedObjective < cutoff)
method = 3;
}
numberNext = numberInfeasibilitiesDown[i];
if (numberNext < numberUnsatisfied) {
int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
double perUnsatisfied = changeDown[i] / static_cast<double> (numberDown);
double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
if (estimatedObjective < cutoff)
method = 3;
}
}
}
method = 2;
} else {
method = 0;
}
// Uncomment next to force method 4
//method=4;
// FIXME This should be an enum. It will be easier to
// understand in the code than numbers.
/* Methods :
0 - fewest infeasibilities
1 - largest min change in objective
2 - as 1 but use sum of changes if min close
3 - predicted best solution
4 - take cheapest up branch if infeasibilities same
*/
int bestNumber = COIN_INT_MAX;
double bestCriterion = -1.0e50;
double alternativeCriterion = -1.0;
double bestEstimate = 1.0e100;
switch (method) {
case 0:
// could add in depth as well
for ( i = 0 ; i < numberObjects ; i++) {
int thisNumber = CoinMin(numberInfeasibilitiesUp[i], numberInfeasibilitiesDown[i]);
if (thisNumber <= bestNumber) {
int betterWay = 0;
if (numberInfeasibilitiesUp[i] < numberInfeasibilitiesDown[i]) {
if (numberInfeasibilitiesUp[i] < bestNumber) {
betterWay = 1;
} else {
if (changeUp[i] < bestCriterion)
betterWay = 1;
}
} else if (numberInfeasibilitiesUp[i] > numberInfeasibilitiesDown[i]) {
if (numberInfeasibilitiesDown[i] < bestNumber) {
betterWay = -1;
} else {
if (changeDown[i] < bestCriterion)
betterWay = -1;
}
} else {
// up and down have same number
bool better = false;
if (numberInfeasibilitiesUp[i] < bestNumber) {
better = true;
} else if (numberInfeasibilitiesUp[i] == bestNumber) {
if (CoinMin(changeUp[i], changeDown[i]) < bestCriterion)
better = true;;
}
if (better) {
// see which way
if (changeUp[i] <= changeDown[i])
betterWay = 1;
else
betterWay = -1;
}
}
if (betterWay) {
bestCriterion = CoinMin(changeUp[i], changeDown[i]);
bestNumber = thisNumber;
whichObject = i;
bestWay = betterWay;
}
}
}
break;
case 1:
for ( i = 0 ; i < numberObjects ; i++) {
int betterWay = 0;
if (changeUp[i] <= changeDown[i]) {
if (changeUp[i] > bestCriterion)
betterWay = 1;
} else {
if (changeDown[i] > bestCriterion)
betterWay = -1;
}
if (betterWay) {
bestCriterion = CoinMin(changeUp[i], changeDown[i]);
whichObject = i;
bestWay = betterWay;
}
}
break;
case 2:
for ( i = 0 ; i < numberObjects ; i++) {
double change = CoinMin(changeUp[i], changeDown[i]);
double sum = changeUp[i] + changeDown[i];
bool take = false;
if (change > 1.1*bestCriterion)
take = true;
else if (change > 0.9*bestCriterion && sum + change > bestCriterion + alternativeCriterion)
take = true;
if (take) {
if (changeUp[i] <= changeDown[i]) {
if (changeUp[i] > bestCriterion)
bestWay = 1;
} else {
if (changeDown[i] > bestCriterion)
bestWay = -1;
}
bestCriterion = change;
alternativeCriterion = sum;
whichObject = i;
}
}
break;
case 3:
for ( i = 0 ; i < numberObjects ; i++) {
int numberNext = numberInfeasibilitiesUp[i];
if (numberNext < numberUnsatisfied) {
int numberUp = numberUnsatisfied - numberInfeasibilitiesUp[i];
double perUnsatisfied = changeUp[i] / static_cast<double> (numberUp);
double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
if (estimatedObjective < bestEstimate) {
bestEstimate = estimatedObjective;
bestWay = 1;
whichObject = i;
}
}
numberNext = numberInfeasibilitiesDown[i];
if (numberNext < numberUnsatisfied) {
int numberDown = numberUnsatisfied - numberInfeasibilitiesDown[i];
double perUnsatisfied = changeDown[i] / static_cast<double> (numberDown);
double estimatedObjective = objectiveValue + numberUnsatisfied * perUnsatisfied;
if (estimatedObjective < bestEstimate) {
bestEstimate = estimatedObjective;
bestWay = -1;
whichObject = i;
}
}
}
break;
case 4:
// if number infeas same then cheapest up
// first get best number or when going down
// now choose smallest change up amongst equal number infeas
for ( i = 0 ; i < numberObjects ; i++) {
int thisNumber = CoinMin(numberInfeasibilitiesUp[i], numberInfeasibilitiesDown[i]);
if (thisNumber <= bestNumber) {
int betterWay = 0;
if (numberInfeasibilitiesUp[i] < numberInfeasibilitiesDown[i]) {
if (numberInfeasibilitiesUp[i] < bestNumber) {
betterWay = 1;
} else {
if (changeUp[i] < bestCriterion)
betterWay = 1;
}
} else if (numberInfeasibilitiesUp[i] > numberInfeasibilitiesDown[i]) {
if (numberInfeasibilitiesDown[i] < bestNumber) {
betterWay = -1;
} else {
if (changeDown[i] < bestCriterion)
betterWay = -1;
}
} else {
// up and down have same number
bool better = false;
if (numberInfeasibilitiesUp[i] < bestNumber) {
better = true;
} else if (numberInfeasibilitiesUp[i] == bestNumber) {
if (CoinMin(changeUp[i], changeDown[i]) < bestCriterion)
better = true;;
}
if (better) {
// see which way
if (changeUp[i] <= changeDown[i])
betterWay = 1;
else
betterWay = -1;
}
}
if (betterWay) {
bestCriterion = CoinMin(changeUp[i], changeDown[i]);
bestNumber = thisNumber;
whichObject = i;
bestWay = betterWay;
}
}
}
bestCriterion = 1.0e50;
for ( i = 0 ; i < numberObjects ; i++) {
int thisNumber = numberInfeasibilitiesUp[i];
if (thisNumber == bestNumber && changeUp) {
if (changeUp[i] < bestCriterion) {
bestCriterion = changeUp[i];
whichObject = i;
bestWay = 1;
}
}
}
break;
}
// set way in best
if (whichObject >= 0) {
CbcBranchingObject * bestObject = objects[whichObject];
if (bestObject->object() && bestObject->object()->preferredWay())
bestWay = bestObject->object()->preferredWay();
bestObject->way(bestWay);
} else {
COIN_DETAIL_PRINT(printf("debug\n"));
}
}
return whichObject;
}
/* Orders rows and saves pointer to matrix.and model */
int
ClpCholeskyUfl::order(ClpInterior * model)
{
numberRows_ = model->numberRows();
if (doKKT_) {
numberRows_ += numberRows_ + model->numberColumns();
printf("finish coding UFL KKT!\n");
abort();
}
rowsDropped_ = new char [numberRows_];
memset(rowsDropped_, 0, numberRows_);
numberRowsDropped_ = 0;
model_ = model;
rowCopy_ = model->clpMatrix()->reverseOrderedCopy();
// Space for starts
choleskyStart_ = new CoinBigIndex[numberRows_+1];
const CoinBigIndex * columnStart = model_->clpMatrix()->getVectorStarts();
const int * columnLength = model_->clpMatrix()->getVectorLengths();
const int * row = model_->clpMatrix()->getIndices();
const CoinBigIndex * rowStart = rowCopy_->getVectorStarts();
const int * rowLength = rowCopy_->getVectorLengths();
const int * column = rowCopy_->getIndices();
// We need two arrays for counts
int * which = new int [numberRows_];
int * used = new int[numberRows_+1];
CoinZeroN(used, numberRows_);
int iRow;
sizeFactor_ = 0;
for (iRow = 0; iRow < numberRows_; iRow++) {
int number = 1;
// make sure diagonal exists
which[0] = iRow;
used[iRow] = 1;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
if (!used[jRow]) {
used[jRow] = 1;
which[number++] = jRow;
}
}
}
}
sizeFactor_ += number;
int j;
for (j = 0; j < number; j++)
used[which[j]] = 0;
}
}
delete [] which;
// Now we have size - create arrays and fill in
try {
choleskyRow_ = new int [sizeFactor_];
} catch (...) {
// no memory
delete [] choleskyStart_;
choleskyStart_ = NULL;
return -1;
}
try {
sparseFactor_ = new double[sizeFactor_];
} catch (...) {
// no memory
delete [] choleskyRow_;
choleskyRow_ = NULL;
delete [] choleskyStart_;
choleskyStart_ = NULL;
return -1;
}
sizeFactor_ = 0;
which = choleskyRow_;
for (iRow = 0; iRow < numberRows_; iRow++) {
int number = 1;
// make sure diagonal exists
which[0] = iRow;
used[iRow] = 1;
choleskyStart_[iRow] = sizeFactor_;
if (!rowsDropped_[iRow]) {
CoinBigIndex startRow = rowStart[iRow];
CoinBigIndex endRow = rowStart[iRow] + rowLength[iRow];
for (CoinBigIndex k = startRow; k < endRow; k++) {
int iColumn = column[k];
CoinBigIndex start = columnStart[iColumn];
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
for (CoinBigIndex j = start; j < end; j++) {
int jRow = row[j];
if (jRow >= iRow && !rowsDropped_[jRow]) {
if (!used[jRow]) {
used[jRow] = 1;
which[number++] = jRow;
}
}
}
}
sizeFactor_ += number;
int j;
for (j = 0; j < number; j++)
used[which[j]] = 0;
// Sort
std::sort(which, which + number);
// move which on
which += number;
}
}
choleskyStart_[numberRows_] = sizeFactor_;
delete [] used;
permuteInverse_ = new int [numberRows_];
permute_ = new int[numberRows_];
cholmod_sparse A ;
A.nrow = numberRows_;
A.ncol = numberRows_;
A.nzmax = choleskyStart_[numberRows_];
A.p = choleskyStart_;
A.i = choleskyRow_;
A.x = NULL;
A.stype = -1;
A.itype = CHOLMOD_INT;
A.xtype = CHOLMOD_PATTERN;
A.dtype = CHOLMOD_DOUBLE;
A.sorted = 1;
A.packed = 1;
c_->nmethods = 9;
c_->postorder = true;
//c_->dbound=1.0e-20;
L_ = cholmod_analyze (&A, c_) ;
if (c_->status) {
COIN_DETAIL_PRINT(std::cout << "CHOLMOD ordering failed" << std::endl);
return 1;
} else {
COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", c_->lnz, c_->fl));
}
for (iRow = 0; iRow < numberRows_; iRow++) {
permuteInverse_[iRow] = iRow;
permute_[iRow] = iRow;
}
return 0;
}
int
CbcHeuristicNaive::solution(double & solutionValue,
double * betterSolution)
{
numCouldRun_++;
// See if to do
bool atRoot = model_->getNodeCount() == 0;
int passNumber = model_->getCurrentPassNumber();
if (!when() || (when() == 1 && model_->phase() != 1) || !atRoot || passNumber != 1)
return 0; // switched off
// Don't do if it was this heuristic which found solution!
if (this == model_->lastHeuristic())
return 0;
numRuns_++;
double cutoff;
model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
double direction = model_->solver()->getObjSense();
cutoff *= direction;
cutoff = CoinMin(cutoff, solutionValue);
OsiSolverInterface * solver = model_->continuousSolver();
if (!solver)
solver = model_->solver();
const double * colLower = solver->getColLower();
const double * colUpper = solver->getColUpper();
const double * objective = solver->getObjCoefficients();
int numberColumns = model_->getNumCols();
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
int i;
bool solutionFound = false;
CoinWarmStartBasis saveBasis;
CoinWarmStartBasis * basis =
dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
if (basis) {
saveBasis = * basis;
delete basis;
}
// First just fix all integers as close to zero as possible
OsiSolverInterface * newSolver = cloneBut(7); // wassolver->clone();
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double lower = colLower[iColumn];
double upper = colUpper[iColumn];
double value;
if (lower > 0.0)
value = lower;
else if (upper < 0.0)
value = upper;
else
value = 0.0;
newSolver->setColLower(iColumn, value);
newSolver->setColUpper(iColumn, value);
}
newSolver->initialSolve();
if (newSolver->isProvenOptimal()) {
double solValue = newSolver->getObjValue() * direction ;
if (solValue < cutoff) {
// we have a solution
solutionFound = true;
solutionValue = solValue;
memcpy(betterSolution, newSolver->getColSolution(),
numberColumns*sizeof(double));
COIN_DETAIL_PRINT(printf("Naive fixing close to zero gave solution of %g\n", solutionValue));
cutoff = solValue - model_->getCutoffIncrement();
}
}
// Now fix all integers as close to zero if zero or large cost
int nFix = 0;
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
double lower = colLower[iColumn];
double upper = colUpper[iColumn];
double value;
if (fabs(objective[i]) > 0.0 && fabs(objective[i]) < large_) {
nFix++;
if (lower > 0.0)
value = lower;
else if (upper < 0.0)
value = upper;
else
value = 0.0;
newSolver->setColLower(iColumn, value);
newSolver->setColUpper(iColumn, value);
} else {
// set back to original
newSolver->setColLower(iColumn, lower);
newSolver->setColUpper(iColumn, upper);
}
}
const double * solution = solver->getColSolution();
if (nFix) {
newSolver->setWarmStart(&saveBasis);
newSolver->setColSolution(solution);
newSolver->initialSolve();
if (newSolver->isProvenOptimal()) {
double solValue = newSolver->getObjValue() * direction ;
if (solValue < cutoff) {
// try branch and bound
double * newSolution = new double [numberColumns];
COIN_DETAIL_PRINT(printf("%d fixed after fixing costs\n", nFix));
int returnCode = smallBranchAndBound(newSolver,
numberNodes_, newSolution,
solutionValue,
solutionValue, "CbcHeuristicNaive1");
if (returnCode < 0)
returnCode = 0; // returned on size
if ((returnCode&2) != 0) {
// could add cut
returnCode &= ~2;
}
if (returnCode == 1) {
// solution
solutionFound = true;
memcpy(betterSolution, newSolution,
numberColumns*sizeof(double));
COIN_DETAIL_PRINT(printf("Naive fixing zeros gave solution of %g\n", solutionValue));
cutoff = solutionValue - model_->getCutoffIncrement();
}
delete [] newSolution;
}
}
}
#if 1
newSolver->setObjSense(-direction); // maximize
newSolver->setWarmStart(&saveBasis);
newSolver->setColSolution(solution);
for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
double value = solution[iColumn];
double lower = colLower[iColumn];
double upper = colUpper[iColumn];
double newLower;
double newUpper;
if (newSolver->isInteger(iColumn)) {
newLower = CoinMax(lower, floor(value) - 2.0);
newUpper = CoinMin(upper, ceil(value) + 2.0);
} else {
newLower = CoinMax(lower, value - 1.0e5);
newUpper = CoinMin(upper, value + 1.0e-5);
}
newSolver->setColLower(iColumn, newLower);
newSolver->setColUpper(iColumn, newUpper);
}
newSolver->initialSolve();
if (newSolver->isProvenOptimal()) {
double solValue = newSolver->getObjValue() * direction ;
if (solValue < cutoff) {
nFix = 0;
newSolver->setObjSense(direction); // correct direction
//const double * thisSolution = newSolver->getColSolution();
for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
double value = solution[iColumn];
double lower = colLower[iColumn];
double upper = colUpper[iColumn];
double newLower = lower;
double newUpper = upper;
if (newSolver->isInteger(iColumn)) {
if (value < lower + 1.0e-6) {
nFix++;
newUpper = lower;
} else if (value > upper - 1.0e-6) {
nFix++;
newLower = upper;
} else {
newLower = CoinMax(lower, floor(value) - 2.0);
newUpper = CoinMin(upper, ceil(value) + 2.0);
}
}
newSolver->setColLower(iColumn, newLower);
newSolver->setColUpper(iColumn, newUpper);
}
// try branch and bound
double * newSolution = new double [numberColumns];
COIN_DETAIL_PRINT(printf("%d fixed after maximizing\n", nFix));
int returnCode = smallBranchAndBound(newSolver,
numberNodes_, newSolution,
solutionValue,
solutionValue, "CbcHeuristicNaive1");
if (returnCode < 0)
returnCode = 0; // returned on size
if ((returnCode&2) != 0) {
// could add cut
returnCode &= ~2;
}
if (returnCode == 1) {
// solution
solutionFound = true;
memcpy(betterSolution, newSolution,
numberColumns*sizeof(double));
COIN_DETAIL_PRINT(printf("Naive maximizing gave solution of %g\n", solutionValue));
cutoff = solutionValue - model_->getCutoffIncrement();
}
delete [] newSolution;
}
}
#endif
delete newSolver;
return solutionFound ? 1 : 0;
}
/*
First tries setting a variable to better value. If feasible then
tries setting others. If not feasible then tries swaps
Returns 1 if solution, 0 if not
The main body of this routine implements an O((q^2)/2) brute force search
around the current solution, for q = number of integer variables. Call this
the inc/dec heuristic. For each integer variable x<i>, first decrement the
value. Then, for integer variables x<i+1>, ..., x<q-1>, try increment and
decrement. If one of these permutations produces a better solution,
remember it. Then repeat, with x<i> incremented. If we find a better
solution, update our notion of current solution and continue.
The net effect is a greedy walk: As each improving pair is found, the
current solution is updated and the search continues from this updated
solution.
Way down at the end, we call solutionFix, which will create a drastically
restricted problem based on variables marked as used, then do mini-BaC on
the restricted problem. This can occur even if we don't try the inc/dec
heuristic. This would be more obvious if the inc/dec heuristic were broken
out as a separate routine and solutionFix had a name that reflected where
it was headed.
The return code of 0 is grossly overloaded, because it maps to a return
code of 0 from solutionFix, which is itself grossly overloaded. See
comments in solutionFix and in CbcHeuristic::smallBranchAndBound.
*/
int
CbcHeuristicLocal::solution(double & solutionValue,
double * betterSolution)
{
/*
Execute only if a new solution has been discovered since the last time we
were called.
*/
numCouldRun_++;
// See if frequency kills off idea
int swap = swap_%100;
int skip = swap_/100;
int nodeCount = model_->getNodeCount();
if (nodeCount<lastRunDeep_+skip && nodeCount != lastRunDeep_+1)
return 0;
if (numberSolutions_ == model_->getSolutionCount() &&
(numberSolutions_ == howOftenShallow_ ||
nodeCount < lastRunDeep_+2*skip))
return 0;
howOftenShallow_ = numberSolutions_;
numberSolutions_ = model_->getSolutionCount();
if (nodeCount<lastRunDeep_+skip )
return 0;
lastRunDeep_ = nodeCount;
howOftenShallow_ = numberSolutions_;
if ((swap%10) == 2) {
// try merge
return solutionFix( solutionValue, betterSolution, NULL);
}
/*
Exclude long (column), thin (row) systems.
Given the n^2 nature of the search, more than 100,000 columns could get
expensive. But I don't yet see the rationale for the second part of the
condition (cols > 10*rows). And cost is proportional to number of integer
variables --- shouldn't we use that?
Why wait until we have more than one solution?
*/
if ((model_->getNumCols() > 100000 && model_->getNumCols() >
10*model_->getNumRows()) || numberSolutions_ <= 1)
return 0; // probably not worth it
// worth trying
OsiSolverInterface * solver = model_->solver();
const double * rowLower = solver->getRowLower();
const double * rowUpper = solver->getRowUpper();
const double * solution = model_->bestSolution();
/*
Shouldn't this test be redundant if we've already checked that
numberSolutions_ > 1? Stronger: shouldn't this be an assertion?
*/
if (!solution)
return 0; // No solution found yet
const double * objective = solver->getObjCoefficients();
double primalTolerance;
solver->getDblParam(OsiPrimalTolerance, primalTolerance);
int numberRows = matrix_.getNumRows();
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
int i;
double direction = solver->getObjSense();
double newSolutionValue = model_->getObjValue() * direction;
int returnCode = 0;
numRuns_++;
// Column copy
const double * element = matrix_.getElements();
const int * row = matrix_.getIndices();
const CoinBigIndex * columnStart = matrix_.getVectorStarts();
const int * columnLength = matrix_.getVectorLengths();
// Get solution array for heuristic solution
int numberColumns = solver->getNumCols();
double * newSolution = new double [numberColumns];
memcpy(newSolution, solution, numberColumns*sizeof(double));
#ifdef LOCAL_FIX_CONTINUOUS
// mark continuous used
const double * columnLower = solver->getColLower();
for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
if (!solver->isInteger(iColumn)) {
if (solution[iColumn] > columnLower[iColumn] + 1.0e-8)
used_[iColumn] = numberSolutions_;
}
}
#endif
// way is 1 if down possible, 2 if up possible, 3 if both possible
char * way = new char[numberIntegers];
// corrected costs
double * cost = new double[numberIntegers];
// for array to mark infeasible rows after iColumn branch
char * mark = new char[numberRows];
memset(mark, 0, numberRows);
// space to save values so we don't introduce rounding errors
double * save = new double[numberRows];
/*
Force variables within their original bounds, then to the nearest integer.
Overall, we seem to be prepared to cope with noninteger bounds. Is this
necessary? Seems like we'd be better off to force the bounds to integrality
as part of preprocessing. More generally, why do we need to do this? This
solution should have been cleaned and checked when it was accepted as a
solution!
Once the value is set, decide whether we can move up or down.
The only place that used_ is used is in solutionFix; if a variable is not
flagged as used, it will be fixed (at lower bound). Why the asymmetric
treatment? This makes some sense for binary variables (for which there are
only two options). But for general integer variables, why not make a similar
test against the original upper bound?
*/
// clean solution
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
const OsiObject * object = model_->object(i);
// get original bounds
double originalLower;
double originalUpper;
getIntegerInformation( object, originalLower, originalUpper);
double value = newSolution[iColumn];
if (value < originalLower) {
value = originalLower;
newSolution[iColumn] = value;
} else if (value > originalUpper) {
value = originalUpper;
newSolution[iColumn] = value;
}
double nearest = floor(value + 0.5);
//assert(fabs(value-nearest)<10.0*primalTolerance);
value = nearest;
newSolution[iColumn] = nearest;
// if away from lower bound mark that fact
if (nearest > originalLower) {
used_[iColumn] = numberSolutions_;
}
cost[i] = direction * objective[iColumn];
/*
Given previous computation we're checking that value is at least 1 away
from the original bounds.
*/
int iway = 0;
if (value > originalLower + 0.5)
iway = 1;
if (value < originalUpper - 0.5)
iway |= 2;
way[i] = static_cast<char>(iway);
}
/*
Calculate lhs of each constraint for groomed solution.
*/
// get row activities
double * rowActivity = new double[numberRows];
memset(rowActivity, 0, numberRows*sizeof(double));
for (i = 0; i < numberColumns; i++) {
int j;
double value = newSolution[i];
if (value) {
for (j = columnStart[i];
j < columnStart[i] + columnLength[i]; j++) {
int iRow = row[j];
rowActivity[iRow] += value * element[j];
}
}
}
/*
Check that constraints are satisfied. For small infeasibility, force the
activity within bound. Again, why is this necessary if the current solution
was accepted as a valid solution?
Why are we scanning past the first unacceptable constraint?
*/
// check was feasible - if not adjust (cleaning may move)
// if very infeasible then give up
bool tryHeuristic = true;
for (i = 0; i < numberRows; i++) {
if (rowActivity[i] < rowLower[i]) {
if (rowActivity[i] < rowLower[i] - 10.0*primalTolerance)
tryHeuristic = false;
rowActivity[i] = rowLower[i];
} else if (rowActivity[i] > rowUpper[i]) {
if (rowActivity[i] < rowUpper[i] + 10.0*primalTolerance)
tryHeuristic = false;
rowActivity[i] = rowUpper[i];
}
}
/*
This bit of code is not quite totally redundant: it'll bail at 10,000
instead of 100,000. Potentially we can do a lot of work to get here, only
to abandon it.
*/
// Switch off if may take too long
if (model_->getNumCols() > 10000 && model_->getNumCols() >
10*model_->getNumRows())
tryHeuristic = false;
/*
Try the inc/dec heuristic?
*/
if (tryHeuristic) {
// total change in objective
double totalChange = 0.0;
// local best change in objective
double bestChange = 0.0;
// maybe just do 1000
int maxIntegers = numberIntegers;
if (((swap/10) &1) != 0) {
maxIntegers = CoinMin(1000,numberIntegers);
}
/*
Outer loop to walk integer variables. Call the current variable x<i>. At the
end of this loop, bestChange will contain the best (negative) change in the
objective for any single pair.
The trouble is, we're limited to monotonically increasing improvement.
Suppose we discover an improvement of 10 for some pair. If, later in the
search, we discover an improvement of 9 for some other pair, we will not use
it. That seems wasteful.
*/
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
bestChange = 0.0;
int endInner = CoinMin(numberIntegers,i+maxIntegers);
double objectiveCoefficient = cost[i];
int k;
int j;
int goodK = -1;
int wayK = -1, wayI = -1;
/*
Try decrementing x<i>.
*/
if ((way[i]&1) != 0) {
int numberInfeasible = 0;
/*
Adjust row activities where x<i> has a nonzero coefficient. Save the old
values for restoration. Mark any rows that become infeasible as a result
of the decrement.
*/
// save row activities and adjust
for (j = columnStart[iColumn];
j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
save[iRow] = rowActivity[iRow];
rowActivity[iRow] -= element[j];
if (rowActivity[iRow] < rowLower[iRow] - primalTolerance ||
rowActivity[iRow] > rowUpper[iRow] + primalTolerance) {
// mark row
mark[iRow] = 1;
numberInfeasible++;
}
}
/*
Run through the remaining integer variables. Try increment and decrement on
each one. If the potential objective change is better than anything we've
seen so far, do a full evaluation of x<k> in that direction. If we can
repair all infeasibilities introduced by pushing x<i> down, we have a
winner. Remember the best variable, and the direction for x<i> and x<k>.
*/
// try down
for (k = i + 1; k < endInner; k++) {
if ((way[k]&1) != 0) {
// try down
if (-objectiveCoefficient - cost[k] < bestChange) {
// see if feasible down
bool good = true;
int numberMarked = 0;
int kColumn = integerVariable[k];
for (j = columnStart[kColumn];
j < columnStart[kColumn] + columnLength[kColumn]; j++) {
int iRow = row[j];
double newValue = rowActivity[iRow] - element[j];
if (newValue < rowLower[iRow] - primalTolerance ||
newValue > rowUpper[iRow] + primalTolerance) {
good = false;
break;
} else if (mark[iRow]) {
// made feasible
numberMarked++;
}
}
if (good && numberMarked == numberInfeasible) {
// better solution
goodK = k;
wayK = -1;
wayI = -1;
bestChange = -objectiveCoefficient - cost[k];
}
}
}
if ((way[k]&2) != 0) {
// try up
if (-objectiveCoefficient + cost[k] < bestChange) {
// see if feasible up
bool good = true;
int numberMarked = 0;
int kColumn = integerVariable[k];
for (j = columnStart[kColumn];
j < columnStart[kColumn] + columnLength[kColumn]; j++) {
int iRow = row[j];
double newValue = rowActivity[iRow] + element[j];
if (newValue < rowLower[iRow] - primalTolerance ||
newValue > rowUpper[iRow] + primalTolerance) {
good = false;
break;
} else if (mark[iRow]) {
// made feasible
numberMarked++;
}
}
if (good && numberMarked == numberInfeasible) {
// better solution
goodK = k;
wayK = 1;
wayI = -1;
bestChange = -objectiveCoefficient + cost[k];
}
}
}
}
/*
Remove effect of decrementing x<i> by restoring original lhs values.
*/
// restore row activities
for (j = columnStart[iColumn];
j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
rowActivity[iRow] = save[iRow];
mark[iRow] = 0;
}
}
/*
Try to increment x<i>. Actions as for decrement.
*/
if ((way[i]&2) != 0) {
int numberInfeasible = 0;
// save row activities and adjust
for (j = columnStart[iColumn];
j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
save[iRow] = rowActivity[iRow];
rowActivity[iRow] += element[j];
if (rowActivity[iRow] < rowLower[iRow] - primalTolerance ||
rowActivity[iRow] > rowUpper[iRow] + primalTolerance) {
// mark row
mark[iRow] = 1;
numberInfeasible++;
}
}
// try up
for (k = i + 1; k < endInner; k++) {
if ((way[k]&1) != 0) {
// try down
if (objectiveCoefficient - cost[k] < bestChange) {
// see if feasible down
bool good = true;
int numberMarked = 0;
int kColumn = integerVariable[k];
for (j = columnStart[kColumn];
j < columnStart[kColumn] + columnLength[kColumn]; j++) {
int iRow = row[j];
double newValue = rowActivity[iRow] - element[j];
if (newValue < rowLower[iRow] - primalTolerance ||
newValue > rowUpper[iRow] + primalTolerance) {
good = false;
break;
} else if (mark[iRow]) {
// made feasible
numberMarked++;
}
}
if (good && numberMarked == numberInfeasible) {
// better solution
goodK = k;
wayK = -1;
wayI = 1;
bestChange = objectiveCoefficient - cost[k];
}
}
}
if ((way[k]&2) != 0) {
// try up
if (objectiveCoefficient + cost[k] < bestChange) {
// see if feasible up
bool good = true;
int numberMarked = 0;
int kColumn = integerVariable[k];
for (j = columnStart[kColumn];
j < columnStart[kColumn] + columnLength[kColumn]; j++) {
int iRow = row[j];
double newValue = rowActivity[iRow] + element[j];
if (newValue < rowLower[iRow] - primalTolerance ||
newValue > rowUpper[iRow] + primalTolerance) {
good = false;
break;
} else if (mark[iRow]) {
// made feasible
numberMarked++;
}
}
if (good && numberMarked == numberInfeasible) {
// better solution
goodK = k;
wayK = 1;
wayI = 1;
bestChange = objectiveCoefficient + cost[k];
}
}
}
}
// restore row activities
for (j = columnStart[iColumn];
j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
rowActivity[iRow] = save[iRow];
mark[iRow] = 0;
}
}
/*
We've found a pair x<i> and x<k> which produce a better solution. Update our
notion of current solution to match.
Why does this not update newSolutionValue?
*/
if (goodK >= 0) {
// we found something - update solution
for (j = columnStart[iColumn];
j < columnStart[iColumn] + columnLength[iColumn]; j++) {
int iRow = row[j];
rowActivity[iRow] += wayI * element[j];
}
newSolution[iColumn] += wayI;
int kColumn = integerVariable[goodK];
for (j = columnStart[kColumn];
j < columnStart[kColumn] + columnLength[kColumn]; j++) {
int iRow = row[j];
rowActivity[iRow] += wayK * element[j];
}
newSolution[kColumn] += wayK;
/*
Adjust motion range for x<k>. We may have banged up against a bound with that
last move.
*/
// See if k can go further ?
const OsiObject * object = model_->object(goodK);
// get original bounds
double originalLower;
double originalUpper;
getIntegerInformation( object, originalLower, originalUpper);
double value = newSolution[kColumn];
int iway = 0;
if (value > originalLower + 0.5)
iway = 1;
if (value < originalUpper - 0.5)
iway |= 2;
way[goodK] = static_cast<char>(iway);
totalChange += bestChange;
}
}
/*
End of loop to try increment/decrement of integer variables.
newSolutionValue does not necessarily match the current newSolution, and
bestChange simply reflects the best single change. Still, that's sufficient
to indicate that there's been at least one change. Check that we really do
have a valid solution.
*/
if (totalChange + newSolutionValue < solutionValue) {
// paranoid check
memset(rowActivity, 0, numberRows*sizeof(double));
for (i = 0; i < numberColumns; i++) {
int j;
double value = newSolution[i];
if (value) {
for (j = columnStart[i];
j < columnStart[i] + columnLength[i]; j++) {
int iRow = row[j];
rowActivity[iRow] += value * element[j];
}
}
}
int numberBad = 0;
double sumBad = 0.0;
// check was approximately feasible
for (i = 0; i < numberRows; i++) {
if (rowActivity[i] < rowLower[i]) {
sumBad += rowLower[i] - rowActivity[i];
if (rowActivity[i] < rowLower[i] - 10.0*primalTolerance)
numberBad++;
} else if (rowActivity[i] > rowUpper[i]) {
sumBad += rowUpper[i] - rowActivity[i];
if (rowActivity[i] > rowUpper[i] + 10.0*primalTolerance)
numberBad++;
}
}
if (!numberBad) {
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
const OsiObject * object = model_->object(i);
// get original bounds
double originalLower;
double originalUpper;
getIntegerInformation( object, originalLower, originalUpper);
double value = newSolution[iColumn];
// if away from lower bound mark that fact
if (value > originalLower) {
used_[iColumn] = numberSolutions_;
}
}
/*
Copy the solution to the array returned to the client. Grab a basis from
the solver (which, if it exists, is almost certainly infeasible, but it
should be ok for a dual start). The value returned as solutionValue is
conservative because of handling of newSolutionValue and bestChange, as
described above.
*/
// new solution
memcpy(betterSolution, newSolution, numberColumns*sizeof(double));
CoinWarmStartBasis * basis =
dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
if (basis) {
model_->setBestSolutionBasis(* basis);
delete basis;
}
returnCode = 1;
solutionValue = newSolutionValue + bestChange;
} else {
// bad solution - should not happen so debug if see message
COIN_DETAIL_PRINT(printf("Local search got bad solution with %d infeasibilities summing to %g\n",
numberBad, sumBad));
}
}
}
/*
We're done. Clean up.
*/
delete [] newSolution;
delete [] rowActivity;
delete [] way;
delete [] cost;
delete [] save;
delete [] mark;
/*
Do we want to try swapping values between solutions?
swap_ is set elsewhere; it's not adjusted during heuristic execution.
Again, redundant test. We shouldn't be here if numberSolutions_ = 1.
*/
if (numberSolutions_ > 1 && (swap%10) == 1) {
// try merge
int returnCode2 = solutionFix( solutionValue, betterSolution, NULL);
if (returnCode2)
returnCode = 1;
}
return returnCode;
}
/* Returns step length which gives minimum of objective for
solution + theta * change vector up to maximum theta.
arrays are numberColumns+numberRows
*/
double
ClpQuadraticObjective::stepLength(ClpSimplex *model,
const double *solution,
const double *change,
double maximumTheta,
double ¤tObj,
double &predictedObj,
double &thetaObj)
{
const double *cost = model->costRegion();
bool inSolve = true;
if (!cost) {
// not in solve
cost = objective_;
inSolve = false;
}
double delta = 0.0;
double linearCost = 0.0;
int numberRows = model->numberRows();
int numberColumns = model->numberColumns();
int numberTotal = numberColumns;
if (inSolve)
numberTotal += numberRows;
currentObj = 0.0;
thetaObj = 0.0;
for (int iColumn = 0; iColumn < numberTotal; iColumn++) {
delta += cost[iColumn] * change[iColumn];
linearCost += cost[iColumn] * solution[iColumn];
}
if (!activated_ || !quadraticObjective_) {
currentObj = linearCost;
thetaObj = currentObj + delta * maximumTheta;
if (delta < 0.0) {
return maximumTheta;
} else {
COIN_DETAIL_PRINT(printf("odd linear direction %g\n", delta));
return 0.0;
}
}
assert(model);
bool scaling = false;
if ((model->rowScale() || model->objectiveScale() != 1.0 || model->optimizationDirection() != 1.0) && inSolve)
scaling = true;
const int *columnQuadratic = quadraticObjective_->getIndices();
const CoinBigIndex *columnQuadraticStart = quadraticObjective_->getVectorStarts();
const int *columnQuadraticLength = quadraticObjective_->getVectorLengths();
const double *quadraticElement = quadraticObjective_->getElements();
double a = 0.0;
double b = delta;
double c = 0.0;
if (!scaling) {
if (!fullMatrix_) {
int iColumn;
for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
double valueI = solution[iColumn];
double changeI = change[iColumn];
CoinBigIndex j;
for (j = columnQuadraticStart[iColumn];
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
int jColumn = columnQuadratic[j];
double valueJ = solution[jColumn];
double changeJ = change[jColumn];
double elementValue = quadraticElement[j];
if (iColumn != jColumn) {
a += changeI * changeJ * elementValue;
b += (changeI * valueJ + changeJ * valueI) * elementValue;
c += valueI * valueJ * elementValue;
} else {
a += 0.5 * changeI * changeI * elementValue;
b += changeI * valueI * elementValue;
c += 0.5 * valueI * valueI * elementValue;
}
}
}
} else {
// full matrix stored
int iColumn;
for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
double valueI = solution[iColumn];
double changeI = change[iColumn];
CoinBigIndex j;
for (j = columnQuadraticStart[iColumn];
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
int jColumn = columnQuadratic[j];
double valueJ = solution[jColumn];
double changeJ = change[jColumn];
double elementValue = quadraticElement[j];
valueJ *= elementValue;
a += changeI * changeJ * elementValue;
b += changeI * valueJ;
c += valueI * valueJ;
}
}
a *= 0.5;
c *= 0.5;
}
} else {
// scaling
// for now only if half
assert(!fullMatrix_);
const double *columnScale = model->columnScale();
double direction = model->optimizationDirection() * model->objectiveScale();
// direction is actually scale out not scale in
if (direction)
direction = 1.0 / direction;
if (!columnScale) {
for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
double valueI = solution[iColumn];
double changeI = change[iColumn];
CoinBigIndex j;
for (j = columnQuadraticStart[iColumn];
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
int jColumn = columnQuadratic[j];
double valueJ = solution[jColumn];
double changeJ = change[jColumn];
double elementValue = quadraticElement[j];
elementValue *= direction;
if (iColumn != jColumn) {
a += changeI * changeJ * elementValue;
b += (changeI * valueJ + changeJ * valueI) * elementValue;
c += valueI * valueJ * elementValue;
} else {
a += 0.5 * changeI * changeI * elementValue;
b += changeI * valueI * elementValue;
c += 0.5 * valueI * valueI * elementValue;
}
}
}
} else {
// scaling
for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
double valueI = solution[iColumn];
double changeI = change[iColumn];
double scaleI = columnScale[iColumn] * direction;
CoinBigIndex j;
for (j = columnQuadraticStart[iColumn];
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
int jColumn = columnQuadratic[j];
double valueJ = solution[jColumn];
double changeJ = change[jColumn];
double elementValue = quadraticElement[j];
elementValue *= scaleI * columnScale[jColumn];
if (iColumn != jColumn) {
a += changeI * changeJ * elementValue;
b += (changeI * valueJ + changeJ * valueI) * elementValue;
c += valueI * valueJ * elementValue;
} else {
a += 0.5 * changeI * changeI * elementValue;
b += changeI * valueI * elementValue;
c += 0.5 * valueI * valueI * elementValue;
}
}
}
}
}
double theta;
//printf("Current cost %g\n",c+linearCost);
currentObj = c + linearCost;
thetaObj = currentObj + a * maximumTheta * maximumTheta + b * maximumTheta;
// minimize a*x*x + b*x + c
if (a <= 0.0) {
theta = maximumTheta;
} else {
theta = -0.5 * b / a;
}
predictedObj = currentObj + a * theta * theta + b * theta;
if (b > 0.0) {
if (model->messageHandler()->logLevel() & 32)
printf("a %g b %g c %g => %g\n", a, b, c, theta);
b = 0.0;
}
return CoinMin(theta, maximumTheta);
}
