ClpNonLinearCost Class Reference

#include <ClpNonLinearCost.hpp>

List of all members.

Public Member Functions
Constructors, destructor
	ClpNonLinearCost ()
	Default constructor.
	ClpNonLinearCost (ClpSimplex *model)
	ClpNonLinearCost (ClpSimplex *model, const int *starts, const double *lower, const double *cost)
	~ClpNonLinearCost ()
	Destructor.
	ClpNonLinearCost (const ClpNonLinearCost &)
ClpNonLinearCost &	operator= (const ClpNonLinearCost &)
Actual work in primal
void	checkInfeasibilities (double oldTolerance=0.0)
void	checkInfeasibilities (int numberInArray, const int *index)
void	checkChanged (int numberInArray, CoinIndexedVector *update)
void	goThru (int numberInArray, double multiplier, const int *index, const double *work, double *rhs)
void	goBack (int numberInArray, const int *index, double *rhs)
void	goBackAll (const CoinIndexedVector *update)
void	zapCosts ()
	Temporary zeroing of feasible costs.
double	setOne (int sequence, double solutionValue)
int	setOneOutgoing (int sequence, double &solutionValue)
double	nearest (int sequence, double solutionValue)
	Returns nearest bound.
double	changeInCost (int sequence, double alpha) const
double	changeUpInCost (int sequence) const
double	changeDownInCost (int sequence) const
double	changeInCost (int sequence, double alpha, double &rhs)
	This also updates next bound.
double	lower (int sequence) const
	Returns current lower bound.
double	upper (int sequence) const
	Returns current upper bound.
double	cost (int sequence) const
	Returns current cost.
Gets and sets
int	numberInfeasibilities () const
	Number of infeasibilities.
double	changeInCost () const
	Change in cost.
double	feasibleCost () const
	Feasible cost.
double	feasibleReportCost () const
	Feasible cost with offset and direction (i.e. for reporting).
double	sumInfeasibilities () const
	Sum of infeasibilities.
double	largestInfeasibility () const
	Largest infeasibility.
double	averageTheta () const
	Average theta.
void	setAverageTheta (double value)
void	setChangeInCost (double value)
bool	lookBothWays () const
	See if may want to look both ways.
Private functions to deal with infeasible regions
bool	infeasible (int i) const
void	setInfeasible (int i, bool trueFalse)
Private Attributes
Data members
double	changeCost_
	Change in cost because of infeasibilities.
double	feasibleCost_
	Feasible cost.
double	largestInfeasibility_
	Largest infeasibility.
double	sumInfeasibilities_
	Sum of infeasibilities.
double	averageTheta_
	Average theta - kept here as only for primal.
int	numberRows_
	Number of rows (mainly for checking and copy).
int	numberColumns_
	Number of columns (mainly for checking and copy).
int *	start_
	Starts for each entry (columns then rows).
int *	whichRange_
	Range for each entry (columns then rows).
int *	offset_
	Temporary range offset for each entry (columns then rows).
double *	lower_
double *	cost_
	Cost for each range.
ClpSimplex *	model_
	Model.
unsigned int *	infeasible_
int	numberInfeasibilities_
	Number of infeasibilities found.
bool	convex_
	If all non-linear costs convex.
bool	bothWays_
	If we should look both ways for djs.

---

Detailed Description

Trivial class to deal with non linear costs

I don't make any explicit assumptions about convexity but I am sure I do make implicit ones.

One interesting idea for normal LP's will be to allow non-basic variables to come into basis as infeasible i.e. if variable at lower bound has very large positive reduced cost (when problem is infeasible) could it reduce overall problem infeasibility more by bringing it into basis below its lower bound.

Another feature would be to automatically discover when problems are convex piecewise linear and re-formulate to use non-linear. I did some work on this many years ago on "grade" problems, but while it improved primal interior point algorithms were much better for that particular problem.

Definition at line 30 of file ClpNonLinearCost.hpp.

---

Constructor & Destructor Documentation

ClpNonLinearCost::ClpNonLinearCost (  ClpSimplex *  model  )

Constructor from simplex. This will just set up wasteful arrays for linear, but later may do dual analysis and even finding duplicate columns . Definition at line 45 of file ClpNonLinearCost.cpp. References averageTheta_, bothWays_, changeCost_, convex_, cost(), cost_, ClpSimplex::costRegion(), feasibleCost_, ClpSimplex::infeasibilityCost(), largestInfeasibility_, lower(), lower_, ClpSimplex::lowerRegion(), model_, ClpModel::numberColumns(), numberColumns_, numberInfeasibilities_, ClpModel::numberRows(), numberRows_, offset_, start_, sumInfeasibilities_, upper(), ClpSimplex::upperRegion(), and whichRange_. { model_ = model; numberRows_ = model_->numberRows(); numberColumns_ = model_->numberColumns(); int numberTotal = numberRows_+numberColumns_; convex_ = true; bothWays_ = false; start_ = new int [numberTotal+1]; whichRange_ = new int [numberTotal]; offset_ = new int [numberTotal]; memset(offset_,0,numberTotal*sizeof(int)); numberInfeasibilities_=0; changeCost_=0.0; feasibleCost_=0.0; double infeasibilityCost = model_->infeasibilityCost(); sumInfeasibilities_=0.0; averageTheta_=0.0; largestInfeasibility_=0.0; // First see how much space we need int put=0; int iSequence; double * upper = model_->upperRegion(); double * lower = model_->lowerRegion(); double * cost = model_->costRegion(); // For quadratic we need -inf,0,0,+inf for (iSequence=0;iSequence<numberTotal;iSequence++) { if (lower[iSequence]>-1.0e20) put++; if (upper[iSequence]<1.0e20) put++; put += 2; } lower_ = new double [put]; cost_ = new double [put]; infeasible_ = new unsigned int[(put+31)>>5]; memset(infeasible_,0,((put+31)>>5)*sizeof(unsigned int)); put=0; start_[0]=0; for (iSequence=0;iSequence<numberTotal;iSequence++) { if (lower[iSequence]>-COIN_DBL_MAX) { lower_[put] = -COIN_DBL_MAX; setInfeasible(put,true); cost_[put++] = cost[iSequence]-infeasibilityCost; } whichRange_[iSequence]=put; lower_[put] = lower[iSequence]; cost_[put++] = cost[iSequence]; lower_[put] = upper[iSequence]; cost_[put++] = cost[iSequence]+infeasibilityCost; if (upper[iSequence]<1.0e20) { lower_[put] = COIN_DBL_MAX; setInfeasible(put-1,true); cost_[put++] = 1.0e50; } start_[iSequence+1]=put; } }

ClpNonLinearCost::ClpNonLinearCost (  ClpSimplex *  model, const int *  starts, const double *  lower, const double *  cost )

Constructor from simplex and list of non-linearities (columns only) First lower of each column has to match real lower Last lower has to be <= upper (if == then cost ignored) This could obviously be changed to make more user friendly Definition at line 112 of file ClpNonLinearCost.cpp. References bothWays_, changeCost_, ClpModel::columnLower(), ClpModel::columnUpper(), convex_, cost(), cost_, feasibleCost_, ClpSimplex::infeasibilityCost(), largestInfeasibility_, lower_, model_, ClpModel::numberColumns(), numberColumns_, numberInfeasibilities_, ClpModel::numberRows(), numberRows_, ClpModel::objective(), offset_, ClpModel::optimizationDirection(), ClpModel::rowLower(), ClpModel::rowObjective(), ClpModel::rowUpper(), ClpSimplex::scalingFlag(), start_, sumInfeasibilities_, and whichRange_. { // what about scaling? - only try without it initially assert(!model->scalingFlag()); model_ = model; numberRows_ = model_->numberRows(); numberColumns_ = model_->numberColumns(); int numberTotal = numberRows_+numberColumns_; convex_ = true; bothWays_ = true; start_ = new int [numberTotal+1]; whichRange_ = new int [numberTotal]; offset_ = new int [numberTotal]; memset(offset_,0,numberTotal*sizeof(int)); double whichWay = model_->optimizationDirection(); printf("Direction %g\n",whichWay); numberInfeasibilities_=0; changeCost_=0.0; feasibleCost_=0.0; double infeasibilityCost = model_->infeasibilityCost(); largestInfeasibility_=0.0; sumInfeasibilities_=0.0; int iSequence; assert (!model_->rowObjective()); double * cost = model_->objective(); // First see how much space we need // Also set up feasible bounds int put=starts[numberColumns_]; double * columnUpper = model_->columnUpper(); double * columnLower = model_->columnLower(); for (iSequence=0;iSequence<numberColumns_;iSequence++) { if (columnLower[iSequence]>-1.0e20) put++; if (columnUpper[iSequence]<1.0e20) put++; } double * rowUpper = model_->rowUpper(); double * rowLower = model_->rowLower(); for (iSequence=0;iSequence<numberRows_;iSequence++) { if (rowLower[iSequence]>-1.0e20) put++; if (rowUpper[iSequence]<1.0e20) put++; put +=2; } lower_ = new double [put]; cost_ = new double [put]; infeasible_ = new unsigned int[(put+31)>>5]; memset(infeasible_,0,((put+31)>>5)*sizeof(unsigned int)); // now fill in put=0; start_[0]=0; for (iSequence=0;iSequence<numberTotal;iSequence++) { lower_[put] = -COIN_DBL_MAX; whichRange_[iSequence]=put+1; double thisCost; double lowerValue; double upperValue; if (iSequence>=numberColumns_) { // rows lowerValue = rowLower[iSequence-numberColumns_]; upperValue = rowUpper[iSequence-numberColumns_]; if (lowerValue>-1.0e30) { setInfeasible(put,true); cost_[put++] = -infeasibilityCost; lower_[put] = lowerValue; } cost_[put++] = 0.0; thisCost = 0.0; } else { // columns - move costs and see if convex lowerValue = columnLower[iSequence]; upperValue = columnUpper[iSequence]; if (lowerValue>-1.0e30) { setInfeasible(put,true); cost_[put++] = whichWay*cost[iSequence]-infeasibilityCost; lower_[put] = lowerValue; } int iIndex = starts[iSequence]; int end = starts[iSequence+1]; assert (fabs(columnLower[iSequence]-lowerNon[iIndex])<1.0e-8); thisCost = -COIN_DBL_MAX; for (;iIndex<end;iIndex++) { if (lowerNon[iIndex]<columnUpper[iSequence]-1.0e-8) { lower_[put] = lowerNon[iIndex]; cost_[put++] = whichWay*costNon[iIndex]; // check convexity if (whichWay*costNon[iIndex]<thisCost-1.0e-12) convex_ = false; thisCost = whichWay*costNon[iIndex]; } else { break; } } } lower_[put] = upperValue; setInfeasible(put,true); cost_[put++] = thisCost+infeasibilityCost; if (upperValue<1.0e20) { lower_[put] = COIN_DBL_MAX; cost_[put++] = 1.0e50; } int iFirst = start_[iSequence]; if (lower_[iFirst] != -COIN_DBL_MAX) { setInfeasible(iFirst,true); whichRange_[iSequence]=iFirst+1; } else { whichRange_[iSequence]=iFirst; } start_[iSequence+1]=put; } // can't handle non-convex at present assert(convex_); }

---

Member Function Documentation

double ClpNonLinearCost::changeInCost (  int  sequence, double  alpha )  const [inline]

Returns change in cost - one down if alpha >0.0, up if <0.0 Value is current - new Definition at line 113 of file ClpNonLinearCost.hpp. References cost_, offset_, and whichRange_. Referenced by ClpSimplex::gutsOfSolution(), ClpSimplexPrimalQuadratic::primalRow(), ClpSimplexPrimal::primalRow(), and ClpSimplexPrimal::updatePrimalsInPrimal(). { int iRange = whichRange_[sequence]+offset_[sequence]; if (alpha>0.0) return cost_[iRange]-cost_[iRange-1]; else return cost_[iRange]-cost_[iRange+1]; }

void ClpNonLinearCost::checkChanged (  int  numberInArray, CoinIndexedVector *  update )

Puts back correct infeasible costs for each variable The input indices are row indices and need converting to sequences for costs. On input array is empty (but indices exist). On exit just changed costs will be stored as normal CoinIndexedVector Definition at line 676 of file ClpNonLinearCost.cpp. References cost(), cost_, ClpSimplex::costAddress(), ClpSimplex::currentPrimalTolerance(), CoinIndexedVector::denseVector(), CoinIndexedVector::getIndices(), ClpSimplex::getStatus(), lower(), lower_, ClpSimplex::lowerAddress(), model_, numberInfeasibilities_, ClpSimplex::pivotVariable(), CoinIndexedVector::setNumElements(), ClpSimplex::solution(), start_, upper(), ClpSimplex::upperAddress(), and whichRange_. { assert (model_!=NULL); double primalTolerance = model_->currentPrimalTolerance(); const int * pivotVariable = model_->pivotVariable(); int number=0; int * index = update->getIndices(); double * work = update->denseVector(); int i; for (i=0;i<numberInArray;i++) { int iRow = index[i]; int iPivot = pivotVariable[iRow]; // get where in bound sequence int iRange; double value = model_->solution(iPivot); int start = start_[iPivot]; int end = start_[iPivot+1]-1; for (iRange=start; iRange<end;iRange++) { if (value<lower_[iRange+1]+primalTolerance) { // put in better range if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } assert(iRange<end); assert(model_->getStatus(iPivot)==ClpSimplex::basic); int jRange = whichRange_[iPivot]; if (iRange!=jRange) { // changed work[iRow] = cost_[jRange]-cost_[iRange]; index[number++]=iRow; double & lower = model_->lowerAddress(iPivot); double & upper = model_->upperAddress(iPivot); double & cost = model_->costAddress(iPivot); whichRange_[iPivot]=iRange; if (infeasible(iRange)) numberInfeasibilities_++; if (infeasible(jRange)) numberInfeasibilities_--; lower = lower_[iRange]; upper = lower_[iRange+1]; cost = cost_[iRange]; } } update->setNumElements(number); }

void ClpNonLinearCost::checkInfeasibilities (  int  numberInArray, const int *  index )

Changes infeasible costs for each variable The indices are row indices and need converting to sequences Definition at line 629 of file ClpNonLinearCost.cpp. References cost(), cost_, ClpSimplex::costAddress(), ClpSimplex::currentPrimalTolerance(), ClpSimplex::getStatus(), lower(), lower_, ClpSimplex::lowerAddress(), model_, numberInfeasibilities_, ClpSimplex::pivotVariable(), ClpSimplex::solution(), start_, upper(), ClpSimplex::upperAddress(), and whichRange_. { assert (model_!=NULL); double primalTolerance = model_->currentPrimalTolerance(); const int * pivotVariable = model_->pivotVariable(); int i; for (i=0;i<numberInArray;i++) { int iRow = index[i]; int iPivot = pivotVariable[iRow]; // get where in bound sequence int iRange; int currentRange = whichRange_[iPivot]; double value = model_->solution(iPivot); int start = start_[iPivot]; int end = start_[iPivot+1]-1; for (iRange=start; iRange<end;iRange++) { if (value<lower_[iRange+1]+primalTolerance) { // put in better range if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } assert(iRange<end); assert(model_->getStatus(iPivot)==ClpSimplex::basic); double & lower = model_->lowerAddress(iPivot); double & upper = model_->upperAddress(iPivot); double & cost = model_->costAddress(iPivot); whichRange_[iPivot]=iRange; if (iRange!=currentRange) { if (infeasible(iRange)) numberInfeasibilities_++; if (infeasible(currentRange)) numberInfeasibilities_--; } lower = lower_[iRange]; upper = lower_[iRange+1]; cost = cost_[iRange]; } }

void ClpNonLinearCost::checkInfeasibilities (  double  oldTolerance = 0.0  )

Changes infeasible costs and computes number and cost of infeas Puts all non-basic (non free) variables to bounds and all free variables to zero if oldTolerance is non-zero but does not move those <= oldTolerance away Definition at line 353 of file ClpNonLinearCost.cpp. References changeCost_, cost(), cost_, ClpSimplex::costRegion(), ClpSimplex::currentPrimalTolerance(), feasibleCost_, ClpSimplex::getStatus(), ClpSimplex::infeasibilityCost(), largestInfeasibility_, lower(), lower_, ClpSimplex::lowerRegion(), model_, nearest(), numberColumns_, numberInfeasibilities_, numberRows_, ClpSimplex::setStatus(), ClpSimplex::solutionRegion(), start_, sumInfeasibilities_, upper(), ClpSimplex::upperRegion(), and whichRange_. Referenced by ClpSimplex::ClpSimplex(), ClpSimplex::gutsOfSolution(), ClpSimplex::originalModel(), ClpSimplexPrimal::pivotResult(), ClpSimplexPrimal::primal(), ClpSimplexPrimalQuadratic::statusOfProblemInPrimal(), ClpSimplexPrimal::statusOfProblemInPrimal(), and ClpSimplexPrimal::unPerturb(). { numberInfeasibilities_=0; double infeasibilityCost = model_->infeasibilityCost(); changeCost_=0.0; largestInfeasibility_ = 0.0; sumInfeasibilities_ = 0.0; double primalTolerance = model_->currentPrimalTolerance(); int iSequence; double * solution = model_->solutionRegion(); double * upper = model_->upperRegion(); double * lower = model_->lowerRegion(); double * cost = model_->costRegion(); bool toNearest = oldTolerance<=0.0; feasibleCost_=0.0; // nonbasic should be at a valid bound for (iSequence=0;iSequence<numberColumns_+numberRows_;iSequence++) { double lowerValue; double upperValue; double value=solution[iSequence]; int iRange; // get correct place int start = start_[iSequence]; int end = start_[iSequence+1]-1; // correct costs for this infeasibility weight // If free then true cost will be first double thisFeasibleCost=cost_[start]; if (infeasible(start)) { thisFeasibleCost = cost_[start+1]; cost_[start] = thisFeasibleCost-infeasibilityCost; } if (infeasible(end-1)) { thisFeasibleCost = cost_[end-2]; cost_[end-1] = thisFeasibleCost+infeasibilityCost; } for (iRange=start; iRange<end;iRange++) { if (value<lower_[iRange+1]+primalTolerance) { // put in better range if infeasible if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; whichRange_[iSequence]=iRange; break; } } assert(iRange<end); lowerValue = lower_[iRange]; upperValue = lower_[iRange+1]; ClpSimplex::Status status = model_->getStatus(iSequence); if (upperValue==lowerValue) { if (status != ClpSimplex::basic) model_->setStatus(iSequence,ClpSimplex::isFixed); } switch(status) { case ClpSimplex::basic: case ClpSimplex::superBasic: // iRange is in correct place // slot in here if (infeasible(iRange)) { if (lower_[iRange]<-1.0e50) { //cost_[iRange] = cost_[iRange+1]-infeasibilityCost; // possibly below lowerValue = lower_[iRange+1]; if (value<lowerValue-primalTolerance) { value = lowerValue-value; sumInfeasibilities_ += value; largestInfeasibility_ = max(largestInfeasibility_,value); changeCost_ -= lowerValue* (cost_[iRange]-cost[iSequence]); numberInfeasibilities_++; } } else { //cost_[iRange] = cost_[iRange-1]+infeasibilityCost; // possibly above upperValue = lower_[iRange]; if (value>upperValue+primalTolerance) { value = value-upperValue; sumInfeasibilities_ += value; largestInfeasibility_ = max(largestInfeasibility_,value); changeCost_ -= upperValue* (cost_[iRange]-cost[iSequence]); numberInfeasibilities_++; } } } //lower[iSequence] = lower_[iRange]; //upper[iSequence] = lower_[iRange+1]; //cost[iSequence] = cost_[iRange]; break; case ClpSimplex::isFree: if (toNearest) solution[iSequence] = 0.0; break; case ClpSimplex::atUpperBound: if (!toNearest) { // With increasing tolerances - we may be at wrong place if (fabs(value-upperValue)>oldTolerance*1.0001) { if (fabs(value-lowerValue)<=oldTolerance*1.0001) { if (fabs(value-lowerValue)>primalTolerance) solution[iSequence]=lowerValue; model_->setStatus(iSequence,ClpSimplex::atLowerBound); } else { model_->setStatus(iSequence,ClpSimplex::superBasic); } } else if (fabs(value-upperValue)>primalTolerance) { solution[iSequence]=upperValue; } } else { // Set to nearest and make at upper bound int kRange; iRange=-1; double nearest = COIN_DBL_MAX; for (kRange=start; kRange<end;kRange++) { if (fabs(lower_[kRange]-value)<nearest) { nearest = fabs(lower_[kRange]-value); iRange=kRange; } } assert (iRange>=0); iRange--; solution[iSequence]=lower_[iRange+1]; } break; case ClpSimplex::atLowerBound: if (!toNearest) { // With increasing tolerances - we may be at wrong place if (fabs(value-lowerValue)>oldTolerance*1.0001) { if (fabs(value-upperValue)<=oldTolerance*1.0001) { if (fabs(value-upperValue)>primalTolerance) solution[iSequence]=upperValue; model_->setStatus(iSequence,ClpSimplex::atLowerBound); } else { model_->setStatus(iSequence,ClpSimplex::superBasic); } } else if (fabs(value-lowerValue)>primalTolerance) { solution[iSequence]=lowerValue; } } else { // Set to nearest and make at lower bound int kRange; iRange=-1; double nearest = COIN_DBL_MAX; for (kRange=start; kRange<end;kRange++) { if (fabs(lower_[kRange]-value)<nearest) { nearest = fabs(lower_[kRange]-value); iRange=kRange; } } assert (iRange>=0); solution[iSequence]=lower_[iRange]; } break; case ClpSimplex::isFixed: if (toNearest) { // Set to true fixed for (iRange=start; iRange<end;iRange++) { if (lower_[iRange]==lower_[iRange+1]) break; } if (iRange==end) { // Odd - but make sensible // Set to nearest and make at lower bound int kRange; iRange=-1; double nearest = COIN_DBL_MAX; for (kRange=start; kRange<end;kRange++) { if (fabs(lower_[kRange]-value)<nearest) { nearest = fabs(lower_[kRange]-value); iRange=kRange; } } assert (iRange>=0); model_->setStatus(iSequence,ClpSimplex::atLowerBound); } solution[iSequence]=lower_[iRange]; } break; } lower[iSequence] = lower_[iRange]; upper[iSequence] = lower_[iRange+1]; cost[iSequence] = cost_[iRange]; feasibleCost_ += thisFeasibleCost*solution[iSequence]; } }

void ClpNonLinearCost::goBack (  int  numberInArray, const int *  index, double *  rhs )

Takes off last iteration (i.e. offsets closer to 0) Definition at line 575 of file ClpNonLinearCost.cpp. References lower_, model_, offset_, ClpSimplex::pivotVariable(), ClpSimplex::solution(), start_, and whichRange_. Referenced by ClpSimplexPrimalQuadratic::primalRow(). { assert (model_!=NULL); const int * pivotVariable = model_->pivotVariable(); int i; for (i=0;i<numberInArray;i++) { int iRow = index[i]; int iPivot = pivotVariable[iRow]; // get where in bound sequence int iRange = whichRange_[iPivot]; bool down; // get closer to original if (offset_[iPivot]>0) { offset_[iPivot]--; assert (offset_[iPivot]>=0); down = false; } else { offset_[iPivot]++; assert (offset_[iPivot]<=0); down = true; } iRange += offset_[iPivot]; //add temporary bias double value = model_->solution(iPivot); if (down) { // down one assert(iRange>=start_[iPivot]); rhs[iRow] = value - lower_[iRange]; } else { // up one assert(iRange<start_[iPivot+1]-1); rhs[iRow] = lower_[iRange+1] - value; } } }

void ClpNonLinearCost::goBackAll (  const CoinIndexedVector *  update  )

Puts back correct infeasible costs for each variable The input indices are row indices and need converting to sequences for costs. At the end of this all temporary offsets are zero Definition at line 611 of file ClpNonLinearCost.cpp. References CoinIndexedVector::getIndices(), CoinIndexedVector::getNumElements(), model_, numberColumns_, numberRows_, offset_, and ClpSimplex::pivotVariable(). Referenced by ClpSimplexPrimalQuadratic::primalRow(), and ClpSimplexPrimal::primalRow(). { assert (model_!=NULL); const int * pivotVariable = model_->pivotVariable(); int i; int number = update->getNumElements(); const int * index = update->getIndices(); for (i=0;i<number;i++) { int iRow = index[i]; int iPivot = pivotVariable[iRow]; offset_[iPivot]=0; } #ifdef CLP_DEBUG for (i=0;i<numberRows_+numberColumns_;i++) assert(!offset_[i]); #endif }

void ClpNonLinearCost::goThru (  int  numberInArray, double  multiplier, const int *  index, const double *  work, double *  rhs )

Goes through one bound for each variable. If multiplier*work[iRow]>0 goes down, otherwise up. The indices are row indices and need converting to sequences Temporary offsets may be set Rhs entries are increased Definition at line 543 of file ClpNonLinearCost.cpp. References lower_, model_, offset_, ClpSimplex::pivotVariable(), ClpSimplex::solution(), start_, and whichRange_. Referenced by ClpSimplexPrimalQuadratic::primalRow(). { assert (model_!=NULL); const int * pivotVariable = model_->pivotVariable(); int i; for (i=0;i<numberInArray;i++) { int iRow = index[i]; int iPivot = pivotVariable[iRow]; double alpha = multiplier*array[iRow]; // get where in bound sequence int iRange = whichRange_[iPivot]; iRange += offset_[iPivot]; //add temporary bias double value = model_->solution(iPivot); if (alpha>0.0) { // down one iRange--; assert(iRange>=start_[iPivot]); rhs[iRow] = value - lower_[iRange]; } else { // up one iRange++; assert(iRange<start_[iPivot+1]-1); rhs[iRow] = lower_[iRange+1] - value; } offset_[iPivot] = iRange - whichRange_[iPivot]; } }

double ClpNonLinearCost::setOne (  int  sequence, double  solutionValue )

Sets bounds and cost for one variable Returns change in cost May need to be inline for speed Definition at line 725 of file ClpNonLinearCost.cpp. References bothWays_, changeCost_, cost(), cost_, ClpSimplex::costAddress(), ClpSimplex::currentPrimalTolerance(), ClpSimplex::getStatus(), lower(), lower_, ClpSimplex::lowerAddress(), model_, numberInfeasibilities_, ClpSimplex::setStatus(), start_, upper(), ClpSimplex::upperAddress(), and whichRange_. Referenced by ClpSimplexPrimal::pivotResult(), ClpSimplexPrimal::primalColumn(), ClpSimplexPrimal::updatePrimalsInPrimal(), and ClpSimplexPrimalQuadratic::whileIterating(). { assert (model_!=NULL); double primalTolerance = model_->currentPrimalTolerance(); // get where in bound sequence int iRange; int currentRange = whichRange_[iPivot]; int start = start_[iPivot]; int end = start_[iPivot+1]-1; if (!bothWays_) { // If fixed try and get feasible if (lower_[start+1]==lower_[start+2]&&fabs(value-lower_[start+1])<1.001*primalTolerance) { iRange =start+1; } else { for (iRange=start; iRange<end;iRange++) { if (value<=lower_[iRange+1]+primalTolerance) { // put in better range if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } } } else { // leave in current if possible iRange = whichRange_[iPivot]; if (value<lower_[iRange]-primalTolerance||value>lower_[iRange+1]+primalTolerance) { for (iRange=start; iRange<end;iRange++) { if (value<lower_[iRange+1]+primalTolerance) { // put in better range if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } } } assert(iRange<end); whichRange_[iPivot]=iRange; if (iRange!=currentRange) { if (infeasible(iRange)) numberInfeasibilities_++; if (infeasible(currentRange)) numberInfeasibilities_--; } double & lower = model_->lowerAddress(iPivot); double & upper = model_->upperAddress(iPivot); double & cost = model_->costAddress(iPivot); lower = lower_[iRange]; upper = lower_[iRange+1]; ClpSimplex::Status status = model_->getStatus(iPivot); if (upper==lower) { if (status != ClpSimplex::basic) { model_->setStatus(iPivot,ClpSimplex::isFixed); status = ClpSimplex::basic; // so will skip } } switch(status) { case ClpSimplex::basic: case ClpSimplex::superBasic: case ClpSimplex::isFree: break; case ClpSimplex::atUpperBound: case ClpSimplex::atLowerBound: case ClpSimplex::isFixed: // set correctly if (fabs(value-lower)<=primalTolerance*1.001){ model_->setStatus(iPivot,ClpSimplex::atLowerBound); } else if (fabs(value-upper)<=primalTolerance*1.001){ model_->setStatus(iPivot,ClpSimplex::atUpperBound); } else { // set superBasic model_->setStatus(iPivot,ClpSimplex::superBasic); } break; } double difference = cost-cost_[iRange]; cost = cost_[iRange]; changeCost_ += value*difference; return difference; }

int ClpNonLinearCost::setOneOutgoing (  int  sequence, double &  solutionValue )

Sets bounds and cost for outgoing variable may change value Returns direction Definition at line 811 of file ClpNonLinearCost.cpp. References changeCost_, cost(), cost_, ClpSimplex::costAddress(), ClpSimplex::currentPrimalTolerance(), lower(), lower_, ClpSimplex::lowerAddress(), model_, numberInfeasibilities_, start_, upper(), ClpSimplex::upperAddress(), and whichRange_. Referenced by ClpSimplexPrimal::pivotResult(), and ClpSimplexPrimalQuadratic::whileIterating(). { assert (model_!=NULL); double primalTolerance = model_->currentPrimalTolerance(); // get where in bound sequence int iRange; int currentRange = whichRange_[iPivot]; int start = start_[iPivot]; int end = start_[iPivot+1]-1; // Set perceived direction out int direction; if (value<=lower_[currentRange]+1.001*primalTolerance) { direction=1; } else if (value>=lower_[currentRange+1]-1.001*primalTolerance) { direction=-1; } else { // odd direction=0; } // If fixed try and get feasible if (lower_[start+1]==lower_[start+2]&&fabs(value-lower_[start+1])<1.001*primalTolerance) { iRange =start+1; } else { // See if exact for (iRange=start; iRange<end;iRange++) { if (value==lower_[iRange+1]) { // put in better range if (infeasible(iRange)&&iRange==start) iRange++; break; } } if (iRange==end) { // not exact for (iRange=start; iRange<end;iRange++) { if (value<=lower_[iRange+1]+primalTolerance) { // put in better range if (value>=lower_[iRange+1]-primalTolerance&&infeasible(iRange)&&iRange==start) iRange++; break; } } } } assert(iRange<end); whichRange_[iPivot]=iRange; if (iRange!=currentRange) { if (infeasible(iRange)) numberInfeasibilities_++; if (infeasible(currentRange)) numberInfeasibilities_--; } double & lower = model_->lowerAddress(iPivot); double & upper = model_->upperAddress(iPivot); double & cost = model_->costAddress(iPivot); lower = lower_[iRange]; upper = lower_[iRange+1]; if (upper==lower) { value=upper; } else { // set correctly if (fabs(value-lower)<=primalTolerance*1.001){ value = min(value,lower+primalTolerance); } else if (fabs(value-upper)<=primalTolerance*1.001){ value = max(value,upper-primalTolerance); } else { //printf("*** variable wandered off bound %g %g %g!\n", // lower,value,upper); if (value-lower<=upper-value) value = lower+primalTolerance; else value = upper-primalTolerance; } } double difference = cost-cost_[iRange]; cost = cost_[iRange]; changeCost_ += value*difference; return direction; }

---

Member Data Documentation

double* ClpNonLinearCost::lower_ [private]

Lower bound for each range (upper bound is next lower). For various reasons there is always an infeasible range at bottom - even if lower bound is - infinity Definition at line 235 of file ClpNonLinearCost.hpp. Referenced by changeInCost(), checkChanged(), checkInfeasibilities(), ClpNonLinearCost(), goBack(), goThru(), lower(), nearest(), setOne(), setOneOutgoing(), upper(), and ~ClpNonLinearCost().

---

The documentation for this class was generated from the following files:

• ClpNonLinearCost.hpp
• ClpNonLinearCost.cpp

---