#include <ClpSimplex.hpp>
Inheritance diagram for ClpSimplex:
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. | |
| ClpDualRowPivot * | dualRowPivot () const |
| dual row pivot choice | |
| bool | goodAccuracy () const |
| Returns true if model looks OK. | |
| 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. | |
| void | setValuesPassAction (double incomingInfeasibility, double allowedInfeasibility) |
| For advanced use. | |
| 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 | checkBothSolutions () |
| This sets sum and number of infeasibilities (Dual and Primal). | |
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 | |
| int | spareIntArray_ [4] |
| Spare int array for passing information [0]!=0 switches on. | |
| double | spareDoubleArray_ [4] |
| Spare double array for passing information [0]!=0 switches on. | |
| 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 | moreSpecialOptions_ |
| More special options - see set for details. | |
| int | baseIteration_ |
| Iteration when we entered dual or primal. | |
| 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 | alphaAccuracy_ |
| For computing whether to re-factorize. | |
| 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 | acceptablePivot_ |
| Acceptable pivot value just after factorization. | |
| 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. | |
| ClpSimplex * | auxiliaryModel_ |
| Auxiliary model. | |
| 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. | |
| ClpDisasterHandler * | disasterArea_ |
| Disaster handler. | |
| 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. | |
| 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 | numberChanged_ |
| Can be used for count of changed costs (dual) or changed bounds (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. | |
| int | dontFactorizePivots_ |
| If may skip final factorize then allow up to this pivots (default 20). | |
| double | incomingInfeasibility_ |
| For advanced use. | |
| double | allowedInfeasibility_ |
| Spare int array for passing information [0]!=0 switches on. | |
| int | automaticScale_ |
| Automatic scaling of objective and rhs and bounds. | |
| ClpSimplex * | baseModel_ |
| A copy of model with certain state - normally without cuts. | |
| ClpSimplexProgress | progress_ |
| For dealing with all issues of cycling etc. | |
| class | OsiClpSolverInterface |
| Allow OsiClp certain perks. | |
Public Types | |
| isFree = 0x00 | |
| basic = 0x01 | |
| atUpperBound = 0x02 | |
| atLowerBound = 0x03 | |
| superBasic = 0x04 | |
| isFixed = 0x05 | |
| noFake = 0x00 | |
| bothFake = 0x01 | |
| upperFake = 0x02 | |
| lowerFake = 0x03 | |
| 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 (bool emptyMessages=false) | |
| 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, bool fixOthers=false) | |
| Subproblem constructor. | |
| ClpSimplex (const ClpSimplex *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true, bool fixOthers=false) | |
| 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. | |
| void | setPersistenceFlag (int value) |
| Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 but give a bit extra if bigger needed. | |
| void | auxiliaryModel (int options) |
| If you are re-using the same matrix again and again then the setup time to do scaling may be significant. | |
| void | deleteAuxiliaryModel () |
| Switch off e.g. if people using presolve. | |
| bool | usingAuxiliaryModel () const |
| See if we have auxiliary model. | |
| void | makeBaseModel () |
| Save a copy of model with certain state - normally without cuts. | |
| void | deleteBaseModel () |
| Switch off base model. | |
| ClpSimplex * | baseModel () const |
| See if we have base model. | |
| void | setToBaseModel (ClpSimplex *model=NULL) |
| Reset to base model (just size and arrays needed) If model NULL use internal copy. | |
| 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 | loadProblem (CoinModel &modelObject, bool keepSolution=false) |
| This loads a model from a coinModel object - returns number of errors. | |
| int | readMps (const char *filename, bool keepNames=false, bool ignoreErrors=false) |
| Read an mps file from the given filename. | |
| int | readGMPL (const char *filename, const char *dataName, bool keepNames=false) |
| Read GMPL files from the given filenames. | |
| int | readLp (const char *filename, const double epsilon=1e-5) |
| Read file in LP format from file with name 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). | |
| void | getbackSolution (const ClpSimplex &smallModel, const int *whichRow, const int *whichColumn) |
| Puts solution back into small model. | |
| int | loadNonLinear (void *info, int &numberConstraints, ClpConstraint **&constraints) |
| Load nonlinear part of problem from AMPL info Returns 0 if linear 1 if quadratic objective 2 if quadratic constraints 3 if nonlinear objective 4 if nonlinear constraints -1 on failure. | |
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 | initialBarrierSolve () |
| Barrier initial solve. | |
| int | initialBarrierNoCrossSolve () |
| Barrier initial solve, not to be followed by crossover. | |
| int | dual (int ifValuesPass=0, int startFinishOptions=0) |
| Dual algorithm - see ClpSimplexDual.hpp for method. | |
| int | dualDebug (int ifValuesPass=0, int startFinishOptions=0) |
| General solve algorithm which can do presolve. | |
| int | primal (int ifValuesPass=0, int startFinishOptions=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 | nonlinearSLP (int numberConstraints, ClpConstraint **constraints, int numberPasses, double deltaTolerance) |
| Solves problem with nonlinear constraints 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 | cleanup (int cleanupScaling) |
| When scaling is on it is possible that the scaled problem is feasible but the unscaled is not. | |
| int | dualRanging (int numberCheck, const int *which, double *costIncrease, int *sequenceIncrease, double *costDecrease, int *sequenceDecrease, double *valueIncrease=NULL, double *valueDecrease=NULL) |
| Dual ranging. | |
| int | primalRanging (int numberCheck, const int *which, double *valueIncrease, int *sequenceIncrease, double *valueDecrease, int *sequenceDecrease) |
| Primal ranging. | |
| int | writeBasis (const char *filename, bool writeValues=false, int formatType=0) const |
| Write the basis in MPS format to the specified file. | |
| int | readBasis (const char *filename) |
| Read a basis from the given filename, returns -1 on file error, 0 if no values, 1 if values. | |
| CoinWarmStartBasis * | getBasis () const |
| Returns a basis (to be deleted by user). | |
| void | setFactorization (ClpFactorization &factorization) |
| Passes in factorization. | |
| void | copyFactorization (ClpFactorization &factorization) |
| Copies in factorization to existing one. | |
| int | tightenPrimalBounds (double factor=0.0, int doTight=0, bool tightIntegers=false) |
| 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, int startFinishOptions=0) |
| For strong branching. | |
| int | fathom (void *stuff) |
| Fathom - 1 if solution. | |
| int | fathomMany (void *stuff) |
| Do up to N deep - returns -1 - no solution nNodes_ valid nodes >= if solution and that node gives solution ClpNode array is 2**N long. | |
| double | doubleCheck () |
| Double checks OK. | |
| int | startFastDual2 (ClpNodeStuff *stuff) |
| Starts Fast dual2. | |
| int | fastDual2 (ClpNodeStuff *stuff) |
| Like Fast dual. | |
| void | stopFastDual2 (ClpNodeStuff *stuff) |
| Stops Fast dual2. | |
| ClpSimplex * | fastCrunch (ClpNodeStuff *stuff, int mode) |
| Deals with crunch aspects mode 0 - in 1 - out with solution 2 - out without solution returns small model or NULL. | |
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, int startFinishOptions=0) |
| Common bits of coding for dual and primal. | |
| void | finish (int startFinishOptions=0) |
| Pivot in a variable and out a variable. | |
| bool | statusOfProblem (bool initial=false) |
| Factorizes and returns true if optimal. | |
| void | defaultFactorizationFrequency () |
| If user left factorization frequency then compute. | |
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. | |
| int | numberDualInfeasibilitiesWithoutFree () const |
| Number of dual infeasibilities (without free). | |
| 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 (int setToBounds=false) |
| Just check solution (for external use) - sets sum of infeasibilities etc. | |
| void | checkSolutionInternal () |
| Just check solution (for internal 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). | |
most useful gets and sets | |
| double | alphaAccuracy () const |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| void | setAlphaAccuracy (double value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| void | setDisasterHandler (ClpDisasterHandler *handler) |
| Disaster handler. | |
| double | largeValue () const |
| Large bound value (for complementarity etc). | |
| void | setLargeValue (double value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| double | largestPrimalError () const |
| Largest error on Ax-b. | |
| double | largestDualError () const |
| Largest error on basic duals. | |
| void | setLargestPrimalError (double value) |
| Largest error on Ax-b. | |
| void | setLargestDualError (double value) |
| Largest error on basic duals. | |
| int * | pivotVariable () const |
| Basic variables pivoting on which rows. | |
| bool | automaticScaling () const |
| If automatic scaling on. | |
| void | setAutomaticScaling (bool onOff) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| double | currentDualTolerance () const |
| Current dual tolerance. | |
| void | setCurrentDualTolerance (double value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| double | currentPrimalTolerance () const |
| Current primal tolerance. | |
| void | setCurrentPrimalTolerance (double value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| int | numberRefinements () const |
| How many iterative refinements to do. | |
| void | setNumberRefinements (int value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| double | alpha () const |
| Alpha (pivot element) for use by classes e.g. steepestedge. | |
| void | setAlpha (double value) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| 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) |
| Initial value for alpha accuracy calculation (-1.0 off). | |
| 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. | |
| bool | startPermanentArrays () |
| Start or reset using maximumRows_ and Columns_ - true if change. | |
| 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. | |
| int | moreSpecialOptions () const |
| Return more special options 1 bit - if presolve says infeasible in | |