11 #ifndef ClpSimplexDual_H
12 #define ClpSimplexDual_H
118 int dual(
int ifValuesPass,
int startFinishOptions = 0);
128 double * newLower,
double * newUpper,
129 double ** outputSolution,
130 int * outputStatus,
int * outputIterations,
131 bool stopOnFirstInfeasible =
true,
132 bool alwaysFinish =
false,
133 int startFinishOptions = 0);
166 CoinIndexedVector * outputArray,
168 double & objectiveChange,
174 CoinIndexedVector * columnArray,
180 CoinIndexedVector * columnArray);
192 double dualColumn(CoinIndexedVector * rowArray,
193 CoinIndexedVector * columnArray,
194 CoinIndexedVector * spareArray,
195 CoinIndexedVector * spareArray2,
196 double accpetablePivot,
197 CoinBigIndex * dubiousWeights);
199 int dualColumn0(
const CoinIndexedVector * rowArray,
200 const CoinIndexedVector * columnArray,
201 CoinIndexedVector * spareArray,
202 double acceptablePivot,
203 double & upperReturn,
double &bestReturn,
double & badFree);
211 CoinIndexedVector * columnArray,
212 double acceptablePivot);
220 CoinIndexedVector * columnArray,
221 double acceptablePivot);
236 void dualRow(
int alreadyChosen);
246 int changeBounds(
int initialize, CoinIndexedVector * outputArray,
247 double & changeCost);
277 int fastDual(
bool alwaysFinish =
false);
291 int startupSolve(
int ifValuesPass,
double * saveDuals,
int startFinishOptions);
293 void gutsOfDual(
int ifValuesPass,
double * & saveDuals,
int initialStatus,
double * ray() const
For advanced users - no need to delete - sign not changed.
int numberAtFakeBound()
Checks number of variables at fake bounds.
int checkUnbounded(CoinIndexedVector *ray, CoinIndexedVector *spare, double changeCost)
Checks if tentative optimal actually means unbounded in dual Returns -3 if not, 2 if is unbounded...
int fastDual(bool alwaysFinish=false)
Fast iterations.
int startupSolve(int ifValuesPass, double *saveDuals, int startFinishOptions)
Startup part of dual (may be extended to other algorithms) returns 0 if good, 1 if bad...
ClpFactorization * setupForStrongBranching(char *arrays, int numberRows, int numberColumns, bool solveLp=false)
This does first part of StrongBranching.
bool changeBound(int iSequence)
As changeBounds but just changes new bounds for a single variable.
double theta() const
Theta (pivot change)
int changeBounds(int initialize, CoinIndexedVector *outputArray, double &changeCost)
Checks if any fake bounds active - if so returns number and modifies updatedDualBound_ and everything...
void gutsOfDual(int ifValuesPass, double *&saveDuals, int initialStatus, ClpDataSave &saveData)
void statusOfProblemInDual(int &lastCleaned, int type, double *givenDjs, ClpDataSave &saveData, int ifValuesPass)
Refactorizes if necessary Checks if finished.
void cleanupAfterStrongBranching(ClpFactorization *factorization)
This cleans up after strong branching.
This just implements CoinFactorization when an ClpMatrixBase object is passed.
void checkPossibleCleanup(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double acceptablePivot)
Row array has row part of pivot row Column array has column part.
int pivotResultPart1()
Pivot in a variable and choose an outgoing one.
int numberColumns() const
void dualRow(int alreadyChosen)
Chooses dual pivot row Would be faster with separate region to scan and will have this (with square o...
int strongBranching(int numberVariables, const int *variables, double *newLower, double *newUpper, double **outputSolution, int *outputStatus, int *outputIterations, bool stopOnFirstInfeasible=true, bool alwaysFinish=false, int startFinishOptions=0)
For strong branching.
double dualColumn(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, CoinIndexedVector *spareArray, CoinIndexedVector *spareArray2, double accpetablePivot, CoinBigIndex *dubiousWeights)
Row array has row part of pivot row Column array has column part.
int perturb()
Perturbs problem (method depends on perturbation()) returns nonzero if should go to dual...
int dual(int ifValuesPass, int startFinishOptions=0)
Dual algorithm.
This solves LPs using the simplex method.
int updateDualsInDual(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, CoinIndexedVector *outputArray, double theta, double &objectiveChange, bool fullRecompute)
The duals are updated by the given arrays.
void checkPossibleValuesMove(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double acceptablePivot)
Row array has row part of pivot row Column array has column part.
void doEasyOnesInValuesPass(double *givenReducedCosts)
This sees if we can move duals in dual values pass.
void finishSolve(int startFinishOptions)
void flipBounds(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray)
While updateDualsInDual sees what effect is of flip this does actual flipping.
This is a tiny class where data can be saved round calls.
CoinIndexedVector * columnArray(int index) const
Useful column length arrays (0,1,2,3,4,5)
void originalBound(int iSequence)
Restores bound to original bound.
void resetFakeBounds(int type)
int numberRows() const
Number of rows.
void updateDualsInValuesPass(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double theta)
The duals are updated by the given arrays.
ClpFactorization * factorization() const
factorization
int nextSuperBasic()
Get next free , -1 if none.
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
ClpDataSave saveData()
Save data.
This solves LPs using the dual simplex method.
int dualColumn0(const CoinIndexedVector *rowArray, const CoinIndexedVector *columnArray, CoinIndexedVector *spareArray, double acceptablePivot, double &upperReturn, double &bestReturn, double &badFree)
Does first bit of dualColumn.
int whileIterating(double *&givenPi, int ifValuesPass)
This has the flow between re-factorizations Broken out for clarity and will be used by strong branchi...