/*
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 */
int
CbcHeuristicVND::solution(double & solutionValue,
double * betterSolution)
{
numCouldRun_++;
int returnCode = 0;
const double * bestSolution = model_->bestSolution();
if (!bestSolution)
return 0; // No solution found yet
#ifdef HEURISTIC_INFORM
printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
heuristicName(),numRuns_,numCouldRun_,when_);
#endif
if (numberSolutions_ < model_->getSolutionCount()) {
// new solution - add info
numberSolutions_ = model_->getSolutionCount();
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
int i;
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 = bestSolution[iColumn];
if (value < originalLower) {
value = originalLower;
} else if (value > originalUpper) {
value = originalUpper;
}
}
}
int numberNodes = model_->getNodeCount();
if (howOften_ == 100) {
if (numberNodes < lastNode_ + 12)
return 0;
// Do at 50 and 100
if ((numberNodes > 40 && numberNodes <= 50) || (numberNodes > 90 && numberNodes < 100))
numberNodes = howOften_;
}
if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() <= 1 ||
model_->getCurrentPassNumber() == 999999)) {
lastNode_ = model_->getNodeCount();
OsiSolverInterface * solver = model_->solver();
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
const double * currentSolution = solver->getColSolution();
OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
//const double * colLower = newSolver->getColLower();
//const double * colUpper = newSolver->getColUpper();
double primalTolerance;
solver->getDblParam(OsiPrimalTolerance, primalTolerance);
// Sort on distance
double * distance = new double [numberIntegers];
int * which = new int [numberIntegers];
int i;
int nFix = 0;
double tolerance = 10.0 * primalTolerance;
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 valueInt = bestSolution[iColumn];
if (valueInt < originalLower) {
valueInt = originalLower;
} else if (valueInt > originalUpper) {
valueInt = originalUpper;
}
baseSolution_[iColumn] = currentSolution[iColumn];
distance[i] = fabs(currentSolution[iColumn] - valueInt);
which[i] = i;
if (fabs(currentSolution[iColumn] - valueInt) < tolerance)
nFix++;
}
CoinSort_2(distance, distance + numberIntegers, which);
nDifferent_ = numberIntegers - nFix;
stepSize_ = nDifferent_ / 10;
k_ = stepSize_;
//nFix = numberIntegers-stepSize_;
for (i = 0; i < nFix; i++) {
int j = which[i];
int iColumn = integerVariable[j];
const OsiObject * object = model_->object(i);
// get original bounds
double originalLower;
double originalUpper;
getIntegerInformation( object, originalLower, originalUpper);
double valueInt = bestSolution[iColumn];
if (valueInt < originalLower) {
valueInt = originalLower;
} else if (valueInt > originalUpper) {
valueInt = originalUpper;
}
double nearest = floor(valueInt + 0.5);
newSolver->setColLower(iColumn, nearest);
newSolver->setColUpper(iColumn, nearest);
}
delete [] distance;
delete [] which;
if (nFix > numberIntegers / 5) {
//printf("%d integers have samish value\n",nFix);
returnCode = smallBranchAndBound(newSolver, numberNodes_, betterSolution, solutionValue,
model_->getCutoff(), "CbcHeuristicVND");
if (returnCode < 0)
returnCode = 0; // returned on size
else
numRuns_++;
if ((returnCode&1) != 0)
numberSuccesses_++;
//printf("return code %d",returnCode);
if ((returnCode&2) != 0) {
// could add cut
returnCode &= ~2;
//printf("could add cut with %d elements (if all 0-1)\n",nFix);
} else {
//printf("\n");
}
numberTries_++;
if ((numberTries_ % 10) == 0 && numberSuccesses_*3 < numberTries_)
howOften_ += static_cast<int> (howOften_ * decayFactor_);
}
delete newSolver;
}
return returnCode;
}
/*
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;
}
// This version fixes stuff and does IP
int
CbcHeuristicLocal::solutionFix(double & objectiveValue,
double * newSolution,
const int * /*keep*/)
{
/*
If when is set to off (0), or set to root (1) and we're not at the root,
return. If this heuristic discovered the current solution, don't continue.
*/
numCouldRun_++;
// See if to do
if (!when() || (when() == 1 && model_->phase() != 1))
return 0; // switched off
// Don't do if it was this heuristic which found solution!
if (this == model_->lastHeuristic())
return 0;
/*
Load up a new solver with the solution.
Why continuousSolver(), as opposed to solver()?
*/
OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
const double * colLower = newSolver->getColLower();
//const double * colUpper = newSolver->getColUpper();
int numberIntegers = model_->numberIntegers();
const int * integerVariable = model_->integerVariable();
/*
The net effect here is that anything that hasn't moved from its lower bound
will be fixed at lower bound.
See comments in solution() w.r.t. asymmetric treatment of upper and lower
bounds.
*/
int i;
int nFix = 0;
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);
newSolver->setColLower(iColumn, CoinMax(colLower[iColumn], originalLower));
if (!used_[iColumn]) {
newSolver->setColUpper(iColumn, colLower[iColumn]);
nFix++;
}
}
/*
Try a `small' branch-and-bound search. The notion here is that we've fixed a
lot of variables and reduced the amount of `free' problem to a point where a
small BaB search will suffice to fully explore the remaining problem. This
routine will execute integer presolve, then call branchAndBound to do the
actual search.
*/
int returnCode = 0;
#ifdef CLP_INVESTIGATE2
printf("Fixing %d out of %d (%d continuous)\n",
nFix, numberIntegers, newSolver->getNumCols() - numberIntegers);
#endif
if (nFix*10 <= numberIntegers) {
// see if we can fix more
int * which = new int [2*(numberIntegers-nFix)];
int * sort = which + (numberIntegers - nFix);
int n = 0;
for (i = 0; i < numberIntegers; i++) {
int iColumn = integerVariable[i];
if (used_[iColumn]) {
which[n] = iColumn;
sort[n++] = used_[iColumn];
}
}
CoinSort_2(sort, sort + n, which);
// only half fixed in total
n = CoinMin(n, numberIntegers / 2 - nFix);
int allow = CoinMax(numberSolutions_ - 2, sort[0]);
int nFix2 = 0;
for (i = 0; i < n; i++) {
int iColumn = integerVariable[i];
if (used_[iColumn] <= allow) {
newSolver->setColUpper(iColumn, colLower[iColumn]);
nFix2++;
} else {
break;
}
}
delete [] which;
nFix += nFix2;
#ifdef CLP_INVESTIGATE2
printf("Number fixed increased from %d to %d\n",
nFix - nFix2, nFix);
#endif
}
if (nFix*10 > numberIntegers) {
returnCode = smallBranchAndBound(newSolver, numberNodes_, newSolution, objectiveValue,
objectiveValue, "CbcHeuristicLocal");
/*
-2 is return due to user event, and -1 is overloaded with what look to be
two contradictory meanings.
*/
if (returnCode < 0) {
returnCode = 0; // returned on size
int numberColumns = newSolver->getNumCols();
int numberContinuous = numberColumns - numberIntegers;
if (numberContinuous > 2*numberIntegers &&
nFix*10 < numberColumns) {
#define LOCAL_FIX_CONTINUOUS
#ifdef LOCAL_FIX_CONTINUOUS
//const double * colUpper = newSolver->getColUpper();
const double * colLower = newSolver->getColLower();
int nAtLb = 0;
//double sumDj=0.0;
const double * dj = newSolver->getReducedCost();
double direction = newSolver->getObjSense();
for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
if (!newSolver->isInteger(iColumn)) {
if (!used_[iColumn]) {
//double djValue = dj[iColumn]*direction;
nAtLb++;
//sumDj += djValue;
}
}
}
if (nAtLb) {
// fix some continuous
double * sort = new double[nAtLb];
int * which = new int [nAtLb];
//double threshold = CoinMax((0.01*sumDj)/static_cast<double>(nAtLb),1.0e-6);
int nFix2 = 0;
for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
if (!newSolver->isInteger(iColumn)) {
if (!used_[iColumn]) {
double djValue = dj[iColumn] * direction;
if (djValue > 1.0e-6) {
sort[nFix2] = -djValue;
which[nFix2++] = iColumn;
}
}
}
}
CoinSort_2(sort, sort + nFix2, which);
int divisor = 2;
nFix2 = CoinMin(nFix2, (numberColumns - nFix) / divisor);
for (int i = 0; i < nFix2; i++) {
int iColumn = which[i];
newSolver->setColUpper(iColumn, colLower[iColumn]);
}
delete [] sort;
delete [] which;
#ifdef CLP_INVESTIGATE2
printf("%d integers have zero value, and %d continuous fixed at lb\n",
nFix, nFix2);
#endif
returnCode = smallBranchAndBound(newSolver,
numberNodes_, newSolution,
objectiveValue,
objectiveValue, "CbcHeuristicLocal");
if (returnCode < 0)
returnCode = 0; // returned on size
}
#endif
}
}
}
/*
If the result is complete exploration with a solution (3) or proven
infeasibility (2), we could generate a cut (the AI folks would call it a
nogood) to prevent us from going down this route in the future.
*/
if ((returnCode&2) != 0) {
// could add cut
returnCode &= ~2;
}
delete newSolver;
return returnCode;
}
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;
}
int
CbcHeuristicCrossover::solution(double & solutionValue,
double * betterSolution)
{
if (when_ == 0)
return 0;
numCouldRun_++;
bool useBest = (numberSolutions_ != model_->getSolutionCount());
if (!useBest && (when_ % 10) == 1)
return 0;
numberSolutions_ = model_->getSolutionCount();
OsiSolverInterface * continuousSolver = model_->continuousSolver();
int useNumber = CoinMin(model_->numberSavedSolutions(), useNumber_);
if (useNumber < 2 || !continuousSolver)
return 0;
// Fix later
if (!useBest)
abort();
numRuns_++;
double cutoff;
model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
double direction = model_->solver()->getObjSense();
cutoff *= direction;
cutoff = CoinMin(cutoff, solutionValue);
OsiSolverInterface * solver = cloneBut(2);
// But reset bounds
solver->setColLower(continuousSolver->getColLower());
solver->setColUpper(continuousSolver->getColUpper());
int numberColumns = solver->getNumCols();
// Fixed
double * fixed = new double [numberColumns];
for (int i = 0; i < numberColumns; i++)
fixed[i] = -COIN_DBL_MAX;
int whichSolution[10];
for (int i = 0; i < useNumber; i++)
whichSolution[i] = i;
for (int i = 0; i < useNumber; i++) {
int k = whichSolution[i];
const double * solution = model_->savedSolution(k);
for (int j = 0; j < numberColumns; j++) {
if (solver->isInteger(j)) {
if (fixed[j] == -COIN_DBL_MAX)
fixed[j] = floor(solution[j] + 0.5);
else if (fabs(fixed[j] - solution[j]) > 1.0e-7)
fixed[j] = COIN_DBL_MAX;
}
}
}
const double * colLower = solver->getColLower();
for (int i = 0; i < numberColumns; i++) {
if (solver->isInteger(i)) {
double value = fixed[i];
if (value != COIN_DBL_MAX) {
if (when_ < 10) {
solver->setColLower(i, value);
solver->setColUpper(i, value);
} else if (value == colLower[i]) {
solver->setColUpper(i, value);
}
}
}
}
int returnCode = smallBranchAndBound(solver, numberNodes_, betterSolution,
solutionValue,
solutionValue, "CbcHeuristicCrossover");
if (returnCode < 0)
returnCode = 0; // returned on size
if ((returnCode&2) != 0) {
// could add cut
returnCode &= ~2;
}
delete solver;
return returnCode;
}
