#include <ClpSimplex.hpp>
Inheritance diagram for ClpSimplex:
Public Types | |
enum | Status { isFree = 0x00, basic = 0x01, atUpperBound = 0x02, atLowerBound = 0x03, superBasic = 0x04, isFixed = 0x05 } |
enums for status of various sorts. More... | |
enum | FakeBound { noFake = 0x00, bothFake = 0x01, upperFake = 0x02, lowerFake = 0x03 } |
Public Member Functions | |
Constructors and destructor and copy | |
ClpSimplex () | |
Default constructor. | |
ClpSimplex (const ClpSimplex &rhs, int scalingMode=-1) | |
Copy constructor. | |
ClpSimplex (const ClpModel &rhs, int scalingMode=-1) | |
Copy constructor from model. | |
ClpSimplex (const ClpModel *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true) | |
Subproblem constructor. | |
ClpSimplex (ClpSimplex *wholeModel, int numberColumns, const int *whichColumns) | |
This constructor modifies original ClpSimplex and stores original stuff in created ClpSimplex. | |
void | originalModel (ClpSimplex *miniModel) |
This copies back stuff from miniModel and then deletes miniModel. | |
ClpSimplex & | operator= (const ClpSimplex &rhs) |
Assignment operator. This copies the data. | |
~ClpSimplex () | |
Destructor. | |
void | loadProblem (const ClpMatrixBase &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, const double *rowObjective=NULL) |
Loads a problem (the constraints on the rows are given by lower and upper bounds). | |
void | loadProblem (const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, const double *rowObjective=NULL) |
Default constructor. | |
void | loadProblem (const int numcols, const int numrows, const CoinBigIndex *start, const int *index, const double *value, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, const double *rowObjective=NULL) |
Just like the other loadProblem() method except that the matrix is given in a standard column major ordered format (without gaps). | |
void | loadProblem (const int numcols, const int numrows, const CoinBigIndex *start, const int *index, const double *value, const int *length, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, const double *rowObjective=NULL) |
This one is for after presolve to save memory. | |
int | readMps (const char *filename, bool keepNames=false, bool ignoreErrors=false) |
Read an mps file from the given filename. | |
void | borrowModel (ClpModel &otherModel) |
Borrow model. | |
void | borrowModel (ClpSimplex &otherModel) |
Default constructor. | |
void | passInEventHandler (const ClpEventHandler *eventHandler) |
Pass in Event handler (cloned and deleted at end). | |
Functions most useful to user | |
int | initialSolve (ClpSolve &options) |
General solve algorithm which can do presolve. | |
int | initialSolve () |
Default initial solve. | |
int | initialDualSolve () |
Dual initial solve. | |
int | initialPrimalSolve () |
Primal initial solve. | |
int | dual (int ifValuesPass=0) |
Dual algorithm - see ClpSimplexDual.hpp for method. | |
int | primal (int ifValuesPass=0) |
Primal algorithm - see ClpSimplexPrimal.hpp for method. | |
int | nonlinearSLP (int numberPasses, double deltaTolerance) |
Solves nonlinear problem using SLP - may be used as crash for other algorithms when number of iterations small. | |
int | barrier (bool crossover=true) |
Solves using barrier (assumes you have good cholesky factor code). | |
int | reducedGradient (int phase=0) |
Solves non-linear using reduced gradient. | |
int | dualRanging (int numberCheck, const int *which, double *costIncrease, int *sequenceIncrease, double *costDecrease, int *sequenceDecrease) |
Dual ranging. | |
int | primalRanging (int numberCheck, const int *which, double *valueIncrease, int *sequenceIncrease, double *valueDecrease, int *sequenceDecrease) |
Primal ranging. | |
void | setFactorization (ClpFactorization &factorization) |
Passes in factorization. | |
int | tightenPrimalBounds (double factor=0.0) |
Tightens primal bounds to make dual faster. | |
int | crash (double gap, int pivot) |
Crash - at present just aimed at dual, returns -2 if dual preferred and crash basis created -1 if dual preferred and all slack basis preferred 0 if basis going in was not all slack 1 if primal preferred and all slack basis preferred 2 if primal preferred and crash basis created. | |
void | setDualRowPivotAlgorithm (ClpDualRowPivot &choice) |
Sets row pivot choice algorithm in dual. | |
void | setPrimalColumnPivotAlgorithm (ClpPrimalColumnPivot &choice) |
Sets column pivot choice algorithm in primal. | |
int | strongBranching (int numberVariables, const int *variables, double *newLower, double *newUpper, double **outputSolution, int *outputStatus, int *outputIterations, bool stopOnFirstInfeasible=true, bool alwaysFinish=false) |
For strong branching. | |
Needed for functionality of OsiSimplexInterface | |
int | pivot () |
Pivot in a variable and out a variable. | |
int | primalPivotResult () |
Pivot in a variable and choose an outgoing one. | |
int | dualPivotResult () |
Pivot out a variable and choose an incoing one. | |
int | startup (int ifValuesPass) |
Common bits of coding for dual and primal. | |
void | finish () |
Pivot in a variable and out a variable. | |
bool | statusOfProblem () |
Factorizes and returns true if optimal. | |
most useful gets and sets | |
bool | primalFeasible () const |
If problem is primal feasible. | |
bool | dualFeasible () const |
If problem is dual feasible. | |
ClpFactorization * | factorization () const |
factorization | |
bool | sparseFactorization () const |
Sparsity on or off. | |
void | setSparseFactorization (bool value) |
If problem is primal feasible. | |
int | factorizationFrequency () const |
Factorization frequency. | |
void | setFactorizationFrequency (int value) |
If problem is primal feasible. | |
double | dualBound () const |
Dual bound. | |
void | setDualBound (double value) |
If problem is primal feasible. | |
double | infeasibilityCost () const |
Infeasibility cost. | |
void | setInfeasibilityCost (double value) |
If problem is primal feasible. | |
int | perturbation () const |
Perturbation: 50 - switch on perturbation 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don't try perturbing again default is 100 others are for playing. | |
void | setPerturbation (int value) |
If problem is primal feasible. | |
int | algorithm () const |
Current (or last) algorithm. | |
void | setAlgorithm (int value) |
Set algorithm. | |
double | sumDualInfeasibilities () const |
Sum of dual infeasibilities. | |
void | setSumDualInfeasibilities (double value) |
If problem is primal feasible. | |
double | sumOfRelaxedDualInfeasibilities () const |
Sum of relaxed dual infeasibilities. | |
void | setSumOfRelaxedDualInfeasibilities (double value) |
If problem is primal feasible. | |
int | numberDualInfeasibilities () const |
Number of dual infeasibilities. | |
void | setNumberDualInfeasibilities (int value) |
If problem is primal feasible. | |
double | sumPrimalInfeasibilities () const |
Sum of primal infeasibilities. | |
void | setSumPrimalInfeasibilities (double value) |
If problem is primal feasible. | |
double | sumOfRelaxedPrimalInfeasibilities () const |
Sum of relaxed primal infeasibilities. | |
void | setSumOfRelaxedPrimalInfeasibilities (double value) |
If problem is primal feasible. | |
int | numberPrimalInfeasibilities () const |
Number of primal infeasibilities. | |
void | setNumberPrimalInfeasibilities (int value) |
If problem is primal feasible. | |
int | saveModel (const char *fileName) |
Save model to file, returns 0 if success. | |
int | restoreModel (const char *fileName) |
Restore model from file, returns 0 if success, deletes current model. | |
void | checkSolution () |
Just check solution (for external use) - sets sum of infeasibilities etc. | |
CoinIndexedVector * | rowArray (int index) const |
Useful row length arrays (0,1,2,3,4,5). | |
CoinIndexedVector * | columnArray (int index) const |
Useful column length arrays (0,1,2,3,4,5). | |
Functions less likely to be useful to casual user | |
int | getSolution (const double *rowActivities, const double *columnActivities) |
Given an existing factorization computes and checks primal and dual solutions. | |
int | getSolution () |
Given an existing factorization computes and checks primal and dual solutions. | |
int | createPiecewiseLinearCosts (const int *starts, const double *lower, const double *gradient) |
Constructs a non linear cost from list of non-linearities (columns only) First lower of each column is taken as real lower Last lower is taken as real upper and cost ignored. | |
void | returnModel (ClpSimplex &otherModel) |
Return model - updates any scalars. | |
int | internalFactorize (int solveType) |
Factorizes using current basis. | |
ClpDataSave | saveData () |
Save data. | |
void | restoreData (ClpDataSave saved) |
Restore data. | |
void | cleanStatus () |
Clean up status. | |
int | factorize () |
Factorizes using current basis. For external use. | |
void | computeDuals (double *givenDjs) |
Computes duals from scratch. | |
void | computePrimals (const double *rowActivities, const double *columnActivities) |
Computes primals from scratch. | |
void | add (double *array, int column, double multiplier) const |
Adds multiple of a column into an array. | |
void | unpack (CoinIndexedVector *rowArray) const |
Unpacks one column of the matrix into indexed array Uses sequenceIn_ Also applies scaling if needed. | |
void | unpack (CoinIndexedVector *rowArray, int sequence) const |
Unpacks one column of the matrix into indexed array Slack if sequence>= numberColumns Also applies scaling if needed. | |
void | unpackPacked (CoinIndexedVector *rowArray) |
Unpacks one column of the matrix into indexed array as packed vector Uses sequenceIn_ Also applies scaling if needed. | |
void | unpackPacked (CoinIndexedVector *rowArray, int sequence) |
Unpacks one column of the matrix into indexed array as packed vector Slack if sequence>= numberColumns Also applies scaling if needed. | |
int | housekeeping (double objectiveChange) |
This does basis housekeeping and does values for in/out variables. | |
void | checkPrimalSolution (const double *rowActivities=NULL, const double *columnActivies=NULL) |
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal). | |
void | checkDualSolution () |
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual). | |
void | setValuesPassAction (float incomingInfeasibility, float allowedInfeasibility) |
For advanced use. | |
most useful gets and sets | |
double | columnPrimalInfeasibility () const |
Worst column primal infeasibility. | |
int | columnPrimalSequence () const |
Sequence of worst (-1 if feasible). | |
double | rowPrimalInfeasibility () const |
Worst row primal infeasibility. | |
int | rowPrimalSequence () const |
Sequence of worst (-1 if feasible). | |
double | columnDualInfeasibility () const |
Worst column dual infeasibility (note - these may not be as meaningful if the problem is primal infeasible. | |
int | columnDualSequence () const |
Sequence of worst (-1 if feasible). | |
double | rowDualInfeasibility () const |
Worst row dual infeasibility. | |
int | rowDualSequence () const |
Sequence of worst (-1 if feasible). | |
double | primalToleranceToGetOptimal () const |
Primal tolerance needed to make dual feasible (<largeTolerance). | |
double | remainingDualInfeasibility () const |
Remaining largest dual infeasibility. | |
double | largeValue () const |
Large bound value (for complementarity etc). | |
void | setLargeValue (double value) |
Worst column primal infeasibility. | |
double | largestPrimalError () const |
Largest error on Ax-b. | |
double | largestDualError () const |
Largest error on basic duals. | |
double | largestSolutionError () const |
Largest difference between input primal solution and computed. | |
int * | pivotVariable () const |
Basic variables pivoting on which rows. | |
bool | automaticScaling () const |
If automatic scaling on. | |
void | setAutomaticScaling (bool onOff) |
Worst column primal infeasibility. | |
double | currentDualTolerance () const |
Current dual tolerance. | |
void | setCurrentDualTolerance (double value) |
Worst column primal infeasibility. | |
double | currentPrimalTolerance () const |
Current primal tolerance. | |
void | setCurrentPrimalTolerance (double value) |
Worst column primal infeasibility. | |
int | numberRefinements () const |
How many iterative refinements to do. | |
void | setNumberRefinements (int value) |
Worst column primal infeasibility. | |
double | alpha () const |
Alpha (pivot element) for use by classes e.g. steepestedge. | |
void | setAlpha (double value) |
Worst column primal infeasibility. | |
double | dualIn () const |
Reduced cost of last incoming for use by classes e.g. steepestedge. | |
int | pivotRow () const |
Pivot Row for use by classes e.g. steepestedge. | |
void | setPivotRow (int value) |
Worst column primal infeasibility. | |
double | valueIncomingDual () const |
value of incoming variable (in Dual) | |
public methods | |
double * | solutionRegion (int section) const |
Return row or column sections - not as much needed as it once was. | |
double * | djRegion (int section) const |
Return row or column sections - not as much needed as it once was. | |
double * | lowerRegion (int section) const |
Return row or column sections - not as much needed as it once was. | |
double * | upperRegion (int section) const |
Return row or column sections - not as much needed as it once was. | |
double * | costRegion (int section) const |
Return row or column sections - not as much needed as it once was. | |
double * | solutionRegion () const |
Return region as single array. | |
double * | djRegion () const |
Return row or column sections - not as much needed as it once was. | |
double * | lowerRegion () const |
Return row or column sections - not as much needed as it once was. | |
double * | upperRegion () const |
Return row or column sections - not as much needed as it once was. | |
double * | costRegion () const |
Return row or column sections - not as much needed as it once was. | |
Status | getStatus (int sequence) const |
Return row or column sections - not as much needed as it once was. | |
void | setStatus (int sequence, Status status) |
Return row or column sections - not as much needed as it once was. | |
void | setInitialDenseFactorization (bool onOff) |
Normally the first factorization does sparse coding because the factorization could be singular. | |
bool | initialDenseFactorization () const |
Return row or column sections - not as much needed as it once was. | |
int | sequenceIn () const |
Return sequence In or Out. | |
int | sequenceOut () const |
Return row or column sections - not as much needed as it once was. | |
void | setSequenceIn (int sequence) |
Set sequenceIn or Out. | |
void | setSequenceOut (int sequence) |
Return row or column sections - not as much needed as it once was. | |
int | directionIn () const |
Return direction In or Out. | |
int | directionOut () const |
Return row or column sections - not as much needed as it once was. | |
void | setDirectionIn (int direction) |
Set directionIn or Out. | |
void | setDirectionOut (int direction) |
Return row or column sections - not as much needed as it once was. | |
double | valueOut () const |
Value of Out variable. | |
int | isColumn (int sequence) const |
Returns 1 if sequence indicates column. | |
int | sequenceWithin (int sequence) const |
Returns sequence number within section. | |
double | solution (int sequence) |
Return row or column values. | |
double & | solutionAddress (int sequence) |
Return address of row or column values. | |
double | reducedCost (int sequence) |
Return row or column sections - not as much needed as it once was. | |
double & | reducedCostAddress (int sequence) |
Return row or column sections - not as much needed as it once was. | |
double | lower (int sequence) |
Return row or column sections - not as much needed as it once was. | |
double & | lowerAddress (int sequence) |
Return address of row or column lower bound. | |
double | upper (int sequence) |
Return row or column sections - not as much needed as it once was. | |
double & | upperAddress (int sequence) |
Return address of row or column upper bound. | |
double | cost (int sequence) |
Return row or column sections - not as much needed as it once was. | |
double & | costAddress (int sequence) |
Return address of row or column cost. | |
double | originalLower (int iSequence) const |
Return original lower bound. | |
double | originalUpper (int iSequence) const |
Return original lower bound. | |
double | theta () const |
Theta (pivot change). | |
ClpNonLinearCost * | nonLinearCost () const |
Return pointer to details of costs. | |
status methods | |
void | setFakeBound (int sequence, FakeBound fakeBound) |
FakeBound | getFakeBound (int sequence) const |
void | setRowStatus (int sequence, Status status) |
Status | getRowStatus (int sequence) const |
void | setColumnStatus (int sequence, Status status) |
Status | getColumnStatus (int sequence) const |
void | setPivoted (int sequence) |
void | clearPivoted (int sequence) |
bool | pivoted (int sequence) const |
void | setFlagged (int sequence) |
To flag a variable (not inline to allow for column generation). | |
void | clearFlagged (int sequence) |
bool | flagged (int sequence) const |
void | setActive (int iRow) |
To say row active in primal pivot row choice. | |
void | clearActive (int iRow) |
bool | active (int iRow) const |
void | createStatus () |
Set up status array (can be used by OsiClp). | |
void | allSlackBasis () |
int | lastBadIteration () const |
So we know when to be cautious. | |
int | progressFlag () const |
Progress flag - at present 0 bit says artificials out. | |
void | forceFactorization (int value) |
Force re-factorization early. | |
double | rawObjectiveValue () const |
Raw objective value (so always minimize in primal). | |
int | numberExtraRows () const |
Number of extra rows. | |
int | maximumBasic () const |
Maximum number of basic variables - can be more than number of rows if GUB. | |
unsigned int | specialOptions () const |
For advanced options 1 - Don't keep changing infeasibility weight 2 - Keep nonLinearCost round solves 4 - Force outgoing variables to exact bound (primal) 8 - Safe to use dense initial factorization 16 -Just use basic variables for operation if column generation 32 -Clean up with primal before strong branching. | |
void | setSpecialOptions (unsigned int value) |
Protected Member Functions | |
protected methods | |
int | gutsOfSolution (double *givenDuals, const double *givenPrimals, bool valuesPass=false) |
May change basis and then returns number changed. | |
void | gutsOfDelete (int type) |
Does most of deletion (0 = all, 1 = most, 2 most + factorization). | |
void | gutsOfCopy (const ClpSimplex &rhs) |
Does most of copying. | |
bool | createRim (int what, bool makeRowCopy=false) |
puts in format I like (rowLower,rowUpper) also see StandardMatrix 1 bit does rows, 2 bit does column bounds, 4 bit does objective(s). | |
void | deleteRim (int getRidOfFactorizationData=2) |
releases above arrays and does solution scaling out. | |
bool | sanityCheck () |
Sanity check on input rim data (after scaling) - returns true if okay. | |
Protected Attributes | |
data. Many arrays have a row part and a column part. | |
There is a single array with both - columns then rows and then normally two arrays pointing to rows and columns.
The single array is the owner of memory | |
double | columnPrimalInfeasibility_ |
Worst column primal infeasibility. | |
double | rowPrimalInfeasibility_ |
Worst row primal infeasibility. | |
int | columnPrimalSequence_ |
Sequence of worst (-1 if feasible). | |
int | rowPrimalSequence_ |
Sequence of worst (-1 if feasible). | |
double | columnDualInfeasibility_ |
Worst column dual infeasibility. | |
double | rowDualInfeasibility_ |
Worst row dual infeasibility. | |
int | columnDualSequence_ |
Sequence of worst (-1 if feasible). | |
int | rowDualSequence_ |
Sequence of worst (-1 if feasible). | |
double | primalToleranceToGetOptimal_ |
Primal tolerance needed to make dual feasible (<largeTolerance). | |
double | remainingDualInfeasibility_ |
Remaining largest dual infeasibility. | |
double | largeValue_ |
Large bound value (for complementarity etc). | |
double | largestPrimalError_ |
Largest error on Ax-b. | |
double | largestDualError_ |
Largest error on basic duals. | |
double | largestSolutionError_ |
Largest difference between input primal solution and computed. | |
double | dualBound_ |
Dual bound. | |
double | alpha_ |
Alpha (pivot element). | |
double | theta_ |
Theta (pivot change). | |
double | lowerIn_ |
Lower Bound on In variable. | |
double | valueIn_ |
Value of In variable. | |
double | upperIn_ |
Upper Bound on In variable. | |
double | dualIn_ |
Reduced cost of In variable. | |
double | lowerOut_ |
Lower Bound on Out variable. | |
double | valueOut_ |
Value of Out variable. | |
double | upperOut_ |
Upper Bound on Out variable. | |
double | dualOut_ |
Infeasibility (dual) or ? (primal) of Out variable. | |
double | dualTolerance_ |
Current dual tolerance for algorithm. | |
double | primalTolerance_ |
Current primal tolerance for algorithm. | |
double | sumDualInfeasibilities_ |
Sum of dual infeasibilities. | |
double | sumPrimalInfeasibilities_ |
Sum of primal infeasibilities. | |
double | infeasibilityCost_ |
Weight assigned to being infeasible in primal. | |
double | sumOfRelaxedDualInfeasibilities_ |
Sum of Dual infeasibilities using tolerance based on error in duals. | |
double | sumOfRelaxedPrimalInfeasibilities_ |
Sum of Primal infeasibilities using tolerance based on error in primals. | |
double * | lower_ |
Working copy of lower bounds (Owner of arrays below). | |
double * | rowLowerWork_ |
Row lower bounds - working copy. | |
double * | columnLowerWork_ |
Column lower bounds - working copy. | |
double * | upper_ |
Working copy of upper bounds (Owner of arrays below). | |
double * | rowUpperWork_ |
Row upper bounds - working copy. | |
double * | columnUpperWork_ |
Column upper bounds - working copy. | |
double * | cost_ |
Working copy of objective (Owner of arrays below). | |
double * | rowObjectiveWork_ |
Row objective - working copy. | |
double * | objectiveWork_ |
Column objective - working copy. | |
CoinIndexedVector * | rowArray_ [6] |
Useful row length arrays. | |
CoinIndexedVector * | columnArray_ [6] |
Useful column length arrays. | |
int | sequenceIn_ |
Sequence of In variable. | |
int | directionIn_ |
Direction of In, 1 going up, -1 going down, 0 not a clude. | |
int | sequenceOut_ |
Sequence of Out variable. | |
int | directionOut_ |
Direction of Out, 1 to upper bound, -1 to lower bound, 0 - superbasic. | |
int | pivotRow_ |
Pivot Row. | |
int | lastGoodIteration_ |
Last good iteration (immediately after a re-factorization). | |
double * | dj_ |
Working copy of reduced costs (Owner of arrays below). | |
double * | rowReducedCost_ |
Reduced costs of slacks not same as duals (or - duals). | |
double * | reducedCostWork_ |
Possible scaled reduced costs. | |
double * | solution_ |
Working copy of primal solution (Owner of arrays below). | |
double * | rowActivityWork_ |
Row activities - working copy. | |
double * | columnActivityWork_ |
Column activities - working copy. | |
int | numberDualInfeasibilities_ |
Number of dual infeasibilities. | |
int | numberDualInfeasibilitiesWithoutFree_ |
Number of dual infeasibilities (without free). | |
int | numberPrimalInfeasibilities_ |
Number of primal infeasibilities. | |
int | numberRefinements_ |
How many iterative refinements to do. | |
ClpDualRowPivot * | dualRowPivot_ |
dual row pivot choice | |
ClpPrimalColumnPivot * | primalColumnPivot_ |
primal column pivot choice | |
int * | pivotVariable_ |
Basic variables pivoting on which rows. | |
ClpFactorization * | factorization_ |
factorization | |
double * | savedSolution_ |
Saved version of solution. | |
int | numberTimesOptimal_ |
Number of times code has tentatively thought optimal. | |
int | changeMade_ |
If change has been made (first attempt at stopping looping). | |
int | algorithm_ |
Algorithm >0 == Primal, <0 == Dual. | |
int | forceFactorization_ |
Now for some reliability aids This forces re-factorization early. | |
int | perturbation_ |
Perturbation: -50 to +50 - perturb by this power of ten (-6 sounds good) 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don't try perturbing again default is 100. | |
unsigned char * | saveStatus_ |
Saved status regions. | |
ClpNonLinearCost * | nonLinearCost_ |
Very wasteful way of dealing with infeasibilities in primal. | |
unsigned int | specialOptions_ |
For advanced options 1 - Don't keep changing infeasibility weight 2 - Keep nonLinearCost round solves 4 - Force outgoing variables to exact bound (primal) 8 - Safe to use dense initial factorization 16 -Just use basic variables for operation. | |
int | lastBadIteration_ |
So we know when to be cautious. | |
int | lastFlaggedIteration_ |
So we know when to open up again. | |
int | numberFake_ |
Can be used for count of fake bounds (dual) or fake costs (primal). | |
int | progressFlag_ |
Progress flag - at present 0 bit says artificials out, 1 free in. | |
int | firstFree_ |
First free/super-basic variable (-1 if none). | |
int | numberExtraRows_ |
Number of extra rows. | |
int | maximumBasic_ |
Maximum number of basic variables - can be more than number of rows if GUB. | |
float | incomingInfeasibility_ |
For advanced use. | |
float | allowedInfeasibility_ |
Worst column primal infeasibility. | |
int | automaticScale_ |
Automatic scaling of objective and rhs and bounds. | |
ClpSimplexProgress * | progress_ |
For dealing with all issues of cycling etc. | |
Friends | |
void | ClpSimplexUnitTest (const std::string &mpsDir, const std::string &netlibDir) |
A function that tests the methods in the ClpSimplex class. |
It inherits from ClpModel and all its arrays are created at algorithm time. Originally I tried to work with model arrays but for simplicity of coding I changed to single arrays with structural variables then row variables. Some coding is still based on old style and needs cleaning up.
For a description of algorithms:
for dual see ClpSimplexDual.hpp and at top of ClpSimplexDual.cpp for primal see ClpSimplexPrimal.hpp and at top of ClpSimplexPrimal.cpp
There is an algorithm data member. + for primal variations and - for dual variations
This file also includes (at end) a very simple class ClpSimplexProgress which is where anti-looping stuff should migrate to
Definition at line 46 of file ClpSimplex.hpp.
|
enums for status of various sorts. First 4 match CoinWarmStartBasis, isFixed means fixed at lower bound and out of basis Definition at line 55 of file ClpSimplex.hpp. Referenced by getColumnStatus(), getRowStatus(), and getStatus(). |
|
Definition at line 64 of file ClpSimplex.hpp. Referenced by getFakeBound(). |
|
Default constructor.
|
|
Copy constructor. May scale depending on mode -1 leave mode as is 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) |
|
Copy constructor from model. May scale depending on mode -1 leave mode as is 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) |
|
Subproblem constructor. A subset of whole model is created from the row and column lists given. The new order is given by list order and duplicates are allowed. Name and integer information can be dropped |
|
This constructor modifies original ClpSimplex and stores original stuff in created ClpSimplex. It is only to be used in conjunction with originalModel |
|
Destructor.
|
|
This copies back stuff from miniModel and then deletes miniModel. Only to be used with mini constructor |
|
Assignment operator. This copies the data.
|
|
Loads a problem (the constraints on the rows are given by lower and upper bounds). If a pointer is 0 then the following values are the default:
Reimplemented from ClpModel. |
|
Default constructor.
Reimplemented from ClpModel. |
|
Just like the other loadProblem() method except that the matrix is given in a standard column major ordered format (without gaps).
Reimplemented from ClpModel. |
|
This one is for after presolve to save memory.
Reimplemented from ClpModel. |
|
Read an mps file from the given filename.
Reimplemented from ClpModel. |
|
Borrow model. This is so we dont have to copy large amounts of data around. It assumes a derived class wants to overwrite an empty model with a real one - while it does an algorithm. This is same as ClpModel one, but sets scaling on etc. Reimplemented from ClpModel. |
|
Default constructor.
|
|
Pass in Event handler (cloned and deleted at end).
Reimplemented from ClpModel. |
|
General solve algorithm which can do presolve. See ClpSolve.hpp for options |
|
Default initial solve.
|
|
Dual initial solve.
|
|
Primal initial solve.
|
|
Dual algorithm - see ClpSimplexDual.hpp for method. ifValuesPass==2 just does values pass and then stops |
|
Primal algorithm - see ClpSimplexPrimal.hpp for method. ifValuesPass==2 just does values pass and then stops |
|
Solves nonlinear problem using SLP - may be used as crash for other algorithms when number of iterations small. Also exits if all problematical variables are changing less than deltaTolerance |
|
Solves using barrier (assumes you have good cholesky factor code). Does crossover to simplex if asked |
|
Solves non-linear using reduced gradient. Phase = 0 get feasible, =1 use solution |
|
Dual ranging. This computes increase/decrease in cost for each given variable and corresponding sequence numbers which would change basis. Sequence numbers are 0..numberColumns and numberColumns.. for artificials/slacks. For non-basic variables the sequence number will be that of the non-basic variables. The increase/decrease value is always >= 0.0 Up to user to provide correct length arrays. Returns non-zero if infeasible unbounded etc Reimplemented in ClpSimplexOther. |
|
Primal ranging. This computes increase/decrease in value for each given variable and corresponding sequence numbers which would change basis. Sequence numbers are 0..numberColumns and numberColumns.. for artificials/slacks. For basic variables the sequence number will be that of the basic variables. Up to user to providen correct length arrays. Returns non-zero if infeasible unbounded etc Reimplemented in ClpSimplexOther. |
|
Passes in factorization.
|
|
Tightens primal bounds to make dual faster. Unless fixed, bounds are slightly looser than they could be. This is to make dual go faster and is probably not needed with a presolve. Returns non-zero if problem infeasible. Fudge for branch and bound - put bounds on columns of factor * largest value (at continuous) - should improve stability in branch and bound on infeasible branches (0.0 is off) |
|
Crash - at present just aimed at dual, returns -2 if dual preferred and crash basis created -1 if dual preferred and all slack basis preferred 0 if basis going in was not all slack 1 if primal preferred and all slack basis preferred 2 if primal preferred and crash basis created. if gap between bounds <="gap" variables can be flipped If "pivot" is 0 No pivoting (so will just be choice of algorithm) 1 Simple pivoting e.g. gub 2 Mini iterations |
|
Sets row pivot choice algorithm in dual.
|
|
Sets column pivot choice algorithm in primal.
|
|
For strong branching. On input lower and upper are new bounds while on output they are change in objective function values (>1.0e50 infeasible). Return code is 0 if nothing interesting, -1 if infeasible both ways and +1 if infeasible one way (check values to see which one(s)) Solutions are filled in as well - even down, odd up - also status and number of iterations Reimplemented in ClpSimplexDual. |
|
Pivot in a variable and out a variable. Returns 0 if okay, 1 if inaccuracy forced re-factorization, -1 if would be singular. Also updates primal/dual infeasibilities. Assumes sequenceIn_ and pivotRow_ set and also directionIn and Out. |
|
Pivot in a variable and choose an outgoing one. Assumes primal feasible - will not go through a bound. Returns step length in theta Returns ray in ray_ (or NULL if no pivot) Return codes as before but -1 means no acceptable pivot |
|
Pivot out a variable and choose an incoing one. Assumes dual feasible - will not go through a reduced cost. Returns step length in theta Returns ray in ray_ (or NULL if no pivot) Return codes as before but -1 means no acceptable pivot |
|
Common bits of coding for dual and primal. Return s0 if okay, 1 if bad matrix, 2 if very bad factorization |
|
Pivot in a variable and out a variable. Returns 0 if okay, 1 if inaccuracy forced re-factorization, -1 if would be singular. Also updates primal/dual infeasibilities. Assumes sequenceIn_ and pivotRow_ set and also directionIn and Out. |
|
Factorizes and returns true if optimal. Used by user |
|
If problem is primal feasible.
Definition at line 301 of file ClpSimplex.hpp. References numberPrimalInfeasibilities_. |
|
If problem is dual feasible.
Definition at line 304 of file ClpSimplex.hpp. References numberDualInfeasibilities_. |
|
factorization
Definition at line 307 of file ClpSimplex.hpp. References factorization_. |
|
Sparsity on or off.
|
|
If problem is primal feasible.
|
|
Factorization frequency.
|
|
If problem is primal feasible.
|
|
Dual bound.
Definition at line 316 of file ClpSimplex.hpp. References dualBound_. |
|
If problem is primal feasible.
|
|
Infeasibility cost.
Definition at line 320 of file ClpSimplex.hpp. References infeasibilityCost_. |
|
If problem is primal feasible.
|
|
Perturbation: 50 - switch on perturbation 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don't try perturbing again default is 100 others are for playing.
Definition at line 339 of file ClpSimplex.hpp. References perturbation_. |
|
If problem is primal feasible.
|
|
Current (or last) algorithm.
Definition at line 343 of file ClpSimplex.hpp. References algorithm_. |
|
Set algorithm.
Definition at line 346 of file ClpSimplex.hpp. References algorithm_. |
|
Sum of dual infeasibilities.
Definition at line 349 of file ClpSimplex.hpp. References sumDualInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 351 of file ClpSimplex.hpp. References sumDualInfeasibilities_. |
|
Sum of relaxed dual infeasibilities.
Definition at line 354 of file ClpSimplex.hpp. References sumOfRelaxedDualInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 356 of file ClpSimplex.hpp. References sumOfRelaxedDualInfeasibilities_. |
|
Number of dual infeasibilities.
Definition at line 359 of file ClpSimplex.hpp. References numberDualInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 361 of file ClpSimplex.hpp. References numberDualInfeasibilities_. |
|
Sum of primal infeasibilities.
Definition at line 364 of file ClpSimplex.hpp. References sumPrimalInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 366 of file ClpSimplex.hpp. References sumPrimalInfeasibilities_. |
|
Sum of relaxed primal infeasibilities.
Definition at line 369 of file ClpSimplex.hpp. References sumOfRelaxedPrimalInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 371 of file ClpSimplex.hpp. References sumOfRelaxedPrimalInfeasibilities_. |
|
Number of primal infeasibilities.
Definition at line 374 of file ClpSimplex.hpp. References numberPrimalInfeasibilities_. |
|
If problem is primal feasible.
Definition at line 376 of file ClpSimplex.hpp. References numberPrimalInfeasibilities_. |
|
Save model to file, returns 0 if success. This is designed for use outside algorithms so does not save iterating arrays etc. It does not save any messaging information. Does not save scaling values. It does not know about all types of virtual functions. |
|
Restore model from file, returns 0 if success, deletes current model.
|
|
Just check solution (for external use) - sets sum of infeasibilities etc.
|
|
Useful row length arrays (0,1,2,3,4,5).
Definition at line 393 of file ClpSimplex.hpp. References rowArray_. |
|
Useful column length arrays (0,1,2,3,4,5).
Definition at line 396 of file ClpSimplex.hpp. References columnArray_. |
|
Given an existing factorization computes and checks primal and dual solutions. Uses input arrays for variables at bounds. Returns feasibility states |
|
Given an existing factorization computes and checks primal and dual solutions. Uses current problem arrays for bounds. Returns feasibility states |
|
Constructs a non linear cost from list of non-linearities (columns only) First lower of each column is taken as real lower Last lower is taken as real upper and cost ignored. Returns nonzero if bad data e.g. lowers not monotonic |
|
Return model - updates any scalars.
|
|
Factorizes using current basis. solveType - 1 iterating, 0 initial, -1 external If 10 added then in primal values pass Return codes are as from ClpFactorization unless initial factorization when total number of singularities is returned |
|
Save data.
|
|
Restore data.
|
|
Clean up status.
|
|
Factorizes using current basis. For external use.
|
|
Computes duals from scratch. If givenDjs then allows for nonzero basic djs |
|
Computes primals from scratch.
|
|
Adds multiple of a column into an array.
|
|
Unpacks one column of the matrix into indexed array Uses sequenceIn_ Also applies scaling if needed.
|
|
Unpacks one column of the matrix into indexed array Slack if sequence>= numberColumns Also applies scaling if needed.
|
|
Unpacks one column of the matrix into indexed array as packed vector Uses sequenceIn_ Also applies scaling if needed.
|
|
Unpacks one column of the matrix into indexed array as packed vector Slack if sequence>= numberColumns Also applies scaling if needed.
|
|
This does basis housekeeping and does values for in/out variables. Can also decide to re-factorize |
|
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal).
|
|
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual).
|
|
For advanced use. When doing iterative solves things can get nasty so on values pass if incoming solution has largest infeasibility < incomingInfeasibility throw out variables from basis until largest infeasibility < allowedInfeasibility or incoming largest infeasibility. If allowedInfeasibility>= incomingInfeasibility this is always possible altough you may end up with an all slack basis. Defaults are 1.0,10.0 |
|
Worst column primal infeasibility.
Definition at line 501 of file ClpSimplex.hpp. References columnPrimalInfeasibility_. |
|
Sequence of worst (-1 if feasible).
Definition at line 504 of file ClpSimplex.hpp. References columnPrimalSequence_. |
|
Worst row primal infeasibility.
Definition at line 507 of file ClpSimplex.hpp. References rowPrimalInfeasibility_. |
|
Sequence of worst (-1 if feasible).
Definition at line 510 of file ClpSimplex.hpp. References rowPrimalSequence_. |
|
Worst column dual infeasibility (note - these may not be as meaningful if the problem is primal infeasible.
Definition at line 514 of file ClpSimplex.hpp. References columnDualInfeasibility_. |
|
Sequence of worst (-1 if feasible).
Definition at line 517 of file ClpSimplex.hpp. References columnDualSequence_. |
|
Worst row dual infeasibility.
Definition at line 520 of file ClpSimplex.hpp. References rowDualInfeasibility_. |
|
Sequence of worst (-1 if feasible).
Definition at line 523 of file ClpSimplex.hpp. References rowDualSequence_. |
|
Primal tolerance needed to make dual feasible (<largeTolerance).
Definition at line 526 of file ClpSimplex.hpp. References primalToleranceToGetOptimal_. |
|
Remaining largest dual infeasibility.
Definition at line 529 of file ClpSimplex.hpp. References remainingDualInfeasibility_. |
|
Large bound value (for complementarity etc).
Definition at line 532 of file ClpSimplex.hpp. References largeValue_. |
|
Worst column primal infeasibility.
|
|
Largest error on Ax-b.
Definition at line 536 of file ClpSimplex.hpp. References largestPrimalError_. |
|
Largest error on basic duals.
Definition at line 539 of file ClpSimplex.hpp. References largestDualError_. |
|
Largest difference between input primal solution and computed.
Definition at line 542 of file ClpSimplex.hpp. References largestSolutionError_. |
|
Basic variables pivoting on which rows.
Definition at line 545 of file ClpSimplex.hpp. References pivotVariable_. |
|
If automatic scaling on.
Definition at line 548 of file ClpSimplex.hpp. References automaticScale_. |
|
Worst column primal infeasibility.
Definition at line 550 of file ClpSimplex.hpp. References automaticScale_. |
|
Current dual tolerance.
Definition at line 553 of file ClpSimplex.hpp. References dualTolerance_. |
|
Worst column primal infeasibility.
Definition at line 555 of file ClpSimplex.hpp. References dualTolerance_. |
|
Current primal tolerance.
Definition at line 558 of file ClpSimplex.hpp. References primalTolerance_. |
|
Worst column primal infeasibility.
Definition at line 560 of file ClpSimplex.hpp. References primalTolerance_. |
|
How many iterative refinements to do.
Definition at line 563 of file ClpSimplex.hpp. References numberRefinements_. |
|
Worst column primal infeasibility.
|
|
Alpha (pivot element) for use by classes e.g. steepestedge.
Definition at line 567 of file ClpSimplex.hpp. References alpha_. |
|
Worst column primal infeasibility.
Definition at line 568 of file ClpSimplex.hpp. References alpha_. |
|
Reduced cost of last incoming for use by classes e.g. steepestedge.
Definition at line 570 of file ClpSimplex.hpp. References dualIn_. |
|
Pivot Row for use by classes e.g. steepestedge.
Definition at line 572 of file ClpSimplex.hpp. References pivotRow_. |
|
Worst column primal infeasibility.
Definition at line 573 of file ClpSimplex.hpp. References pivotRow_. |
|
value of incoming variable (in Dual)
|
|
May change basis and then returns number changed. Computation of solutions may be overriden by given pi and solution |
|
Does most of deletion (0 = all, 1 = most, 2 most + factorization).
|
|
Does most of copying.
|
|
puts in format I like (rowLower,rowUpper) also see StandardMatrix 1 bit does rows, 2 bit does column bounds, 4 bit does objective(s). 8 bit does solution scaling in 16 bit does rowArray and columnArray indexed vectors and makes row copy if wanted, also sets columnStart_ etc Also creates scaling arrays if needed. It does scaling if needed. 16 also moves solutions etc in to work arrays On 16 returns false if problem "bad" i.e. matrix or bounds bad |
|
releases above arrays and does solution scaling out. May also get rid of factorization data - 0 get rid of nothing, 1 get rid of arrays, 2 also factorization |
|
Sanity check on input rim data (after scaling) - returns true if okay.
|
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 614 of file ClpSimplex.hpp. References columnActivityWork_, and rowActivityWork_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 616 of file ClpSimplex.hpp. References reducedCostWork_, and rowReducedCost_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 618 of file ClpSimplex.hpp. References columnLowerWork_, and rowLowerWork_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 620 of file ClpSimplex.hpp. References columnUpperWork_, and rowUpperWork_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 622 of file ClpSimplex.hpp. References objectiveWork_, and rowObjectiveWork_. |
|
Return region as single array.
Definition at line 625 of file ClpSimplex.hpp. References solution_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 627 of file ClpSimplex.hpp. References dj_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 629 of file ClpSimplex.hpp. References lower_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 631 of file ClpSimplex.hpp. References upper_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 633 of file ClpSimplex.hpp. References cost_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 635 of file ClpSimplex.hpp. References Status. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 637 of file ClpSimplex.hpp. |
|
Normally the first factorization does sparse coding because the factorization could be singular. This allows initial dense factorization when it is known to be safe |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays |
|
Return sequence In or Out.
Definition at line 650 of file ClpSimplex.hpp. References sequenceIn_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 652 of file ClpSimplex.hpp. References sequenceOut_. |
|
Set sequenceIn or Out.
Definition at line 655 of file ClpSimplex.hpp. References sequenceIn_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 657 of file ClpSimplex.hpp. References sequenceOut_. |
|
Return direction In or Out.
Definition at line 660 of file ClpSimplex.hpp. References directionIn_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 662 of file ClpSimplex.hpp. References directionOut_. |
|
Set directionIn or Out.
Definition at line 665 of file ClpSimplex.hpp. References directionIn_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 667 of file ClpSimplex.hpp. References directionOut_. |
|
Value of Out variable.
Definition at line 670 of file ClpSimplex.hpp. References valueOut_. |
|
Returns 1 if sequence indicates column.
Definition at line 673 of file ClpSimplex.hpp. |
|
Returns sequence number within section.
Definition at line 676 of file ClpSimplex.hpp. |
|
Return row or column values.
Definition at line 679 of file ClpSimplex.hpp. References solution_. |
|
Return address of row or column values.
Definition at line 682 of file ClpSimplex.hpp. References solution_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 684 of file ClpSimplex.hpp. References dj_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 686 of file ClpSimplex.hpp. References dj_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 688 of file ClpSimplex.hpp. References lower_. |
|
Return address of row or column lower bound.
Definition at line 691 of file ClpSimplex.hpp. References lower_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 693 of file ClpSimplex.hpp. References upper_. |
|
Return address of row or column upper bound.
Definition at line 696 of file ClpSimplex.hpp. References upper_. |
|
Return row or column sections - not as much needed as it once was. These just map into single arrays Definition at line 698 of file ClpSimplex.hpp. References cost_. |
|
Return address of row or column cost.
Definition at line 701 of file ClpSimplex.hpp. References cost_. |
|
Return original lower bound.
Definition at line 704 of file ClpSimplex.hpp. |
|
Return original lower bound.
Definition at line 708 of file ClpSimplex.hpp. |
|
Theta (pivot change).
Definition at line 712 of file ClpSimplex.hpp. References theta_. |
|
Return pointer to details of costs.
Definition at line 715 of file ClpSimplex.hpp. References nonLinearCost_. |
|
Definition at line 720 of file ClpSimplex.hpp. |
|
Definition at line 726 of file ClpSimplex.hpp. References FakeBound. |
|
Definition at line 728 of file ClpSimplex.hpp. |
|
Definition at line 734 of file ClpSimplex.hpp. References Status. |
|
Definition at line 736 of file ClpSimplex.hpp. |
|
Definition at line 742 of file ClpSimplex.hpp. References Status. |
|
Definition at line 744 of file ClpSimplex.hpp. |
|
Definition at line 746 of file ClpSimplex.hpp. |
|
Definition at line 748 of file ClpSimplex.hpp. |
|
To flag a variable (not inline to allow for column generation).
|
|
Definition at line 752 of file ClpSimplex.hpp. |
|
Definition at line 756 of file ClpSimplex.hpp. |
|
To say row active in primal pivot row choice.
Definition at line 759 of file ClpSimplex.hpp. |
|
Definition at line 763 of file ClpSimplex.hpp. |
|
Definition at line 767 of file ClpSimplex.hpp. |
|
Set up status array (can be used by OsiClp). Also can be used to set up all slack basis Referenced by allSlackBasis(). |
|
Definition at line 772 of file ClpSimplex.hpp. References createStatus(). |
|
So we know when to be cautious.
Definition at line 776 of file ClpSimplex.hpp. References lastBadIteration_. |
|
Progress flag - at present 0 bit says artificials out.
Definition at line 779 of file ClpSimplex.hpp. References progressFlag_. |
|
Force re-factorization early.
Definition at line 782 of file ClpSimplex.hpp. References forceFactorization_. |
|
Raw objective value (so always minimize in primal).
Definition at line 785 of file ClpSimplex.hpp. |
|
Number of extra rows. These are ones which will be dynamically created each iteration. This is for GUB but may have other uses. Definition at line 790 of file ClpSimplex.hpp. References numberExtraRows_. |
|
Maximum number of basic variables - can be more than number of rows if GUB.
Definition at line 794 of file ClpSimplex.hpp. References maximumBasic_. |
|
For advanced options 1 - Don't keep changing infeasibility weight 2 - Keep nonLinearCost round solves 4 - Force outgoing variables to exact bound (primal) 8 - Safe to use dense initial factorization 16 -Just use basic variables for operation if column generation 32 -Clean up with primal before strong branching.
Definition at line 804 of file ClpSimplex.hpp. References specialOptions_. |
|
Definition at line 806 of file ClpSimplex.hpp. References specialOptions_. |
|
A function that tests the methods in the ClpSimplex class. The only reason for it not to be a member method is that this way it doesn't have to be compiled into the library. And that's a gain, because the library should be compiled with optimization on, but this method should be compiled with debugging. It also does some testing of ClpFactorization class |
|
Worst column primal infeasibility.
Definition at line 820 of file ClpSimplex.hpp. Referenced by columnPrimalInfeasibility(). |
|
Worst row primal infeasibility.
Definition at line 822 of file ClpSimplex.hpp. Referenced by rowPrimalInfeasibility(). |
|
Sequence of worst (-1 if feasible).
Definition at line 824 of file ClpSimplex.hpp. Referenced by columnPrimalSequence(). |
|
Sequence of worst (-1 if feasible).
Definition at line 826 of file ClpSimplex.hpp. Referenced by rowPrimalSequence(). |
|
Worst column dual infeasibility.
Definition at line 828 of file ClpSimplex.hpp. Referenced by columnDualInfeasibility(). |
|
Worst row dual infeasibility.
Definition at line 830 of file ClpSimplex.hpp. Referenced by rowDualInfeasibility(). |
|
Sequence of worst (-1 if feasible).
Definition at line 832 of file ClpSimplex.hpp. Referenced by columnDualSequence(). |
|
Sequence of worst (-1 if feasible).
Definition at line 834 of file ClpSimplex.hpp. Referenced by rowDualSequence(). |
|
Primal tolerance needed to make dual feasible (<largeTolerance).
Definition at line 836 of file ClpSimplex.hpp. Referenced by primalToleranceToGetOptimal(). |
|
Remaining largest dual infeasibility.
Definition at line 838 of file ClpSimplex.hpp. Referenced by remainingDualInfeasibility(). |
|
Large bound value (for complementarity etc).
Definition at line 840 of file ClpSimplex.hpp. Referenced by largeValue(). |
|
Largest error on Ax-b.
Definition at line 842 of file ClpSimplex.hpp. Referenced by largestPrimalError(). |
|
Largest error on basic duals.
Definition at line 844 of file ClpSimplex.hpp. Referenced by largestDualError(). |
|
Largest difference between input primal solution and computed.
Definition at line 846 of file ClpSimplex.hpp. Referenced by largestSolutionError(). |
|
Dual bound.
Definition at line 848 of file ClpSimplex.hpp. Referenced by dualBound(). |
|
Alpha (pivot element).
Definition at line 850 of file ClpSimplex.hpp. Referenced by alpha(), and setAlpha(). |
|
Theta (pivot change).
Definition at line 852 of file ClpSimplex.hpp. Referenced by theta(). |
|
Lower Bound on In variable.
Definition at line 854 of file ClpSimplex.hpp. |
|
Value of In variable.
Definition at line 856 of file ClpSimplex.hpp. |
|
Upper Bound on In variable.
Definition at line 858 of file ClpSimplex.hpp. |
|
Reduced cost of In variable.
Definition at line 860 of file ClpSimplex.hpp. Referenced by dualIn(). |
|
Lower Bound on Out variable.
Definition at line 862 of file ClpSimplex.hpp. |
|
Value of Out variable.
Definition at line 864 of file ClpSimplex.hpp. Referenced by valueOut(). |
|
Upper Bound on Out variable.
Definition at line 866 of file ClpSimplex.hpp. |
|
Infeasibility (dual) or ? (primal) of Out variable.
Definition at line 868 of file ClpSimplex.hpp. |
|
Current dual tolerance for algorithm.
Definition at line 870 of file ClpSimplex.hpp. Referenced by currentDualTolerance(), and setCurrentDualTolerance(). |
|
Current primal tolerance for algorithm.
Definition at line 872 of file ClpSimplex.hpp. Referenced by currentPrimalTolerance(), and setCurrentPrimalTolerance(). |
|
Sum of dual infeasibilities.
Definition at line 874 of file ClpSimplex.hpp. Referenced by setSumDualInfeasibilities(), and sumDualInfeasibilities(). |
|
Sum of primal infeasibilities.
Definition at line 876 of file ClpSimplex.hpp. Referenced by setSumPrimalInfeasibilities(), and sumPrimalInfeasibilities(). |
|
Weight assigned to being infeasible in primal.
Definition at line 878 of file ClpSimplex.hpp. Referenced by infeasibilityCost(). |
|
Sum of Dual infeasibilities using tolerance based on error in duals.
Definition at line 880 of file ClpSimplex.hpp. Referenced by setSumOfRelaxedDualInfeasibilities(), and sumOfRelaxedDualInfeasibilities(). |
|
Sum of Primal infeasibilities using tolerance based on error in primals.
Definition at line 882 of file ClpSimplex.hpp. Referenced by setSumOfRelaxedPrimalInfeasibilities(), and sumOfRelaxedPrimalInfeasibilities(). |
|
Working copy of lower bounds (Owner of arrays below).
Definition at line 884 of file ClpSimplex.hpp. Referenced by lower(), lowerAddress(), and lowerRegion(). |
|
Row lower bounds - working copy.
Definition at line 886 of file ClpSimplex.hpp. Referenced by lowerRegion(). |
|
Column lower bounds - working copy.
Definition at line 888 of file ClpSimplex.hpp. Referenced by lowerRegion(). |
|
Working copy of upper bounds (Owner of arrays below).
Definition at line 890 of file ClpSimplex.hpp. Referenced by upper(), upperAddress(), and upperRegion(). |
|
Row upper bounds - working copy.
Definition at line 892 of file ClpSimplex.hpp. Referenced by upperRegion(). |
|
Column upper bounds - working copy.
Definition at line 894 of file ClpSimplex.hpp. Referenced by upperRegion(). |
|
Working copy of objective (Owner of arrays below).
Definition at line 896 of file ClpSimplex.hpp. Referenced by cost(), costAddress(), and costRegion(). |
|
Row objective - working copy.
Definition at line 898 of file ClpSimplex.hpp. Referenced by costRegion(). |
|
Column objective - working copy.
Definition at line 900 of file ClpSimplex.hpp. Referenced by costRegion(). |
|
Useful row length arrays.
Definition at line 902 of file ClpSimplex.hpp. Referenced by rowArray(). |
|
Useful column length arrays.
Definition at line 904 of file ClpSimplex.hpp. Referenced by columnArray(). |
|
Sequence of In variable.
Definition at line 906 of file ClpSimplex.hpp. Referenced by sequenceIn(), and setSequenceIn(). |
|
Direction of In, 1 going up, -1 going down, 0 not a clude.
Definition at line 908 of file ClpSimplex.hpp. Referenced by directionIn(), and setDirectionIn(). |
|
Sequence of Out variable.
Definition at line 910 of file ClpSimplex.hpp. Referenced by sequenceOut(), and setSequenceOut(). |
|
Direction of Out, 1 to upper bound, -1 to lower bound, 0 - superbasic.
Definition at line 912 of file ClpSimplex.hpp. Referenced by directionOut(), and setDirectionOut(). |
|
Pivot Row.
Definition at line 914 of file ClpSimplex.hpp. Referenced by pivotRow(), and setPivotRow(). |
|
Last good iteration (immediately after a re-factorization).
Definition at line 916 of file ClpSimplex.hpp. |
|
Working copy of reduced costs (Owner of arrays below).
Definition at line 918 of file ClpSimplex.hpp. Referenced by djRegion(), reducedCost(), and reducedCostAddress(). |
|
Reduced costs of slacks not same as duals (or - duals).
Definition at line 920 of file ClpSimplex.hpp. Referenced by djRegion(). |
|
Possible scaled reduced costs.
Definition at line 922 of file ClpSimplex.hpp. Referenced by djRegion(). |
|
Working copy of primal solution (Owner of arrays below).
Definition at line 924 of file ClpSimplex.hpp. Referenced by solution(), solutionAddress(), and solutionRegion(). |
|
Row activities - working copy.
Definition at line 926 of file ClpSimplex.hpp. Referenced by solutionRegion(). |
|
Column activities - working copy.
Definition at line 928 of file ClpSimplex.hpp. Referenced by solutionRegion(). |
|
Number of dual infeasibilities.
Definition at line 930 of file ClpSimplex.hpp. Referenced by dualFeasible(), numberDualInfeasibilities(), and setNumberDualInfeasibilities(). |
|
Number of dual infeasibilities (without free).
Definition at line 932 of file ClpSimplex.hpp. |
|
Number of primal infeasibilities.
Definition at line 934 of file ClpSimplex.hpp. Referenced by numberPrimalInfeasibilities(), primalFeasible(), and setNumberPrimalInfeasibilities(). |
|
How many iterative refinements to do.
Definition at line 936 of file ClpSimplex.hpp. Referenced by numberRefinements(). |
|
dual row pivot choice
Definition at line 938 of file ClpSimplex.hpp. |
|
primal column pivot choice
Definition at line 940 of file ClpSimplex.hpp. |
|
Basic variables pivoting on which rows.
Definition at line 942 of file ClpSimplex.hpp. Referenced by pivotVariable(). |
|
factorization
Definition at line 944 of file ClpSimplex.hpp. Referenced by factorization(). |
|
Saved version of solution.
Definition at line 946 of file ClpSimplex.hpp. |
|
Number of times code has tentatively thought optimal.
Definition at line 948 of file ClpSimplex.hpp. |
|
If change has been made (first attempt at stopping looping).
Definition at line 950 of file ClpSimplex.hpp. |
|
Algorithm >0 == Primal, <0 == Dual.
Definition at line 952 of file ClpSimplex.hpp. Referenced by algorithm(), and setAlgorithm(). |
|
Now for some reliability aids This forces re-factorization early.
Definition at line 955 of file ClpSimplex.hpp. Referenced by forceFactorization(). |
|
Perturbation: -50 to +50 - perturb by this power of ten (-6 sounds good) 100 - auto perturb if takes too long (1.0e-6 largest nonzero) 101 - we are perturbed 102 - don't try perturbing again default is 100.
Definition at line 963 of file ClpSimplex.hpp. Referenced by perturbation(). |
|
Saved status regions.
Definition at line 965 of file ClpSimplex.hpp. |
|
Very wasteful way of dealing with infeasibilities in primal. However it will allow non-linearities and use of dual analysis. If it doesn't work it can easily be replaced. Definition at line 970 of file ClpSimplex.hpp. Referenced by nonLinearCost(). |
|
For advanced options 1 - Don't keep changing infeasibility weight 2 - Keep nonLinearCost round solves 4 - Force outgoing variables to exact bound (primal) 8 - Safe to use dense initial factorization 16 -Just use basic variables for operation.
Definition at line 978 of file ClpSimplex.hpp. Referenced by setSpecialOptions(), and specialOptions(). |
|
So we know when to be cautious.
Definition at line 980 of file ClpSimplex.hpp. Referenced by lastBadIteration(). |
|
So we know when to open up again.
Definition at line 982 of file ClpSimplex.hpp. |
|
Can be used for count of fake bounds (dual) or fake costs (primal).
Definition at line 984 of file ClpSimplex.hpp. |
|
Progress flag - at present 0 bit says artificials out, 1 free in.
Definition at line 986 of file ClpSimplex.hpp. Referenced by progressFlag(). |
|
First free/super-basic variable (-1 if none).
Definition at line 988 of file ClpSimplex.hpp. |
|
Number of extra rows. These are ones which will be dynamically created each iteration. This is for GUB but may have other uses. Definition at line 992 of file ClpSimplex.hpp. Referenced by numberExtraRows(). |
|
Maximum number of basic variables - can be more than number of rows if GUB.
Definition at line 995 of file ClpSimplex.hpp. Referenced by maximumBasic(). |
|
For advanced use. When doing iterative solves things can get nasty so on values pass if incoming solution has largest infeasibility < incomingInfeasibility throw out variables from basis until largest infeasibility < allowedInfeasibility. if allowedInfeasibility>= incomingInfeasibility this is always possible altough you may end up with an all slack basis. Defaults are 1.0,10.0 Definition at line 1005 of file ClpSimplex.hpp. |
|
Worst column primal infeasibility.
Definition at line 1006 of file ClpSimplex.hpp. |
|
Automatic scaling of objective and rhs and bounds.
Definition at line 1008 of file ClpSimplex.hpp. Referenced by automaticScaling(), and setAutomaticScaling(). |
|
For dealing with all issues of cycling etc.
Definition at line 1010 of file ClpSimplex.hpp. |