28 class OsiAbcSolverInterface;
31 class AbcSimplexProgress;
53 #if ABC_NORMAL_DEBUG > 0
57 #define HEAVY_PERTURBATION 57
110 bool dropNames =
true,
bool dropIntegers =
true,
111 bool fixOthers =
false);
121 bool dropNames =
true,
bool dropIntegers =
true,
122 bool fixOthers =
false);
168 int primal(
int ifValuesPass);
204 #ifdef EARLY_FACTORIZE
266 const double *fakePrimals,
413 #define rowUseScale_ scaleFromExternal_
414 #define inverseRowUseScale_ scaleToExternal_
446 double allowedInfeasibility);
569 const double *givenPrimals,
570 bool valuesPass =
false);
677 st_byte =
static_cast< unsigned char >(st_byte & ~7);
678 st_byte =
static_cast< unsigned char >(st_byte | newstatus);
683 st_byte =
static_cast< unsigned char >(st_byte & ~7);
684 st_byte =
static_cast< unsigned char >(st_byte | newstatus);
712 inline int sequenceInternalIn()
const {
713 return sequenceInternalIn_;
715 inline int sequenceInternalOut()
const {
716 return sequenceInternalOut_;
719 inline void setSequenceInternalIn(
int sequence) {
720 sequenceInternalIn_ = sequence;
722 inline void setSequenceInternalOut(
int sequence) {
723 sequenceInternalOut_ = sequence;
726 inline int isColumn(
int sequence)
const
779 printf(
"Pansetting %d to lb\n", iSequence);
789 printf(
"Pansetting %d to ub\n", iSequence);
800 inline double solution(
int sequence)
836 inline double cost(
int sequence)
870 void restoreFromSubProblem(
AbcSimplex *fullProblem,
const int *whichColumn);
886 inline int parallelMode()
const
889 return parallelMode_;
892 inline void setParallelMode(
int value)
894 parallelMode_ = value;
897 inline int numberCpus()
const
899 return parallelMode_ + 1;
901 #if ABC_PARALLEL == 1
902 inline void setStopStart(
int value)
919 int check = 1 << which;
926 int check = 1 << which;
934 void swapDualStuff(
int lastSequenceOut,
int lastDirectionOut);
945 st_byte =
static_cast< unsigned char >(st_byte & ~24);
946 st_byte =
static_cast< unsigned char >(st_byte | (fakeBound << 3));
1000 void crash(
int type);
1014 int startup(
int ifValuesPass);
1027 #ifndef NUMBER_THREADS
1028 #define NUMBER_THREADS 3
1030 #if ABC_PARALLEL == 1
1032 inline pthread_mutex_t *mutexPointer(
int which,
int thread = 0)
1034 return mutex_ + which + 3 * thread;
1036 inline pthread_barrier_t *barrierPointer()
1040 inline int whichLocked(
int thread = 0)
const
1042 return locked_[thread];
1044 inline CoinThreadInfo *threadInfoPointer(
int thread = 0)
1046 return threadInfo_ + thread;
1048 void startParallelStuff(
int type);
1049 int stopParallelStuff(
int type);
1051 int whichThread()
const;
1052 #elif ABC_PARALLEL == 2
1090 const int *indexLast,
1091 const double *boundList);
1108 double newlower,
double newupper)
1120 const int *indexLast,
1121 const double *boundList)
1128 void setRowLower(
int elementIndex,
double elementValue);
1132 void setRowUpper(
int elementIndex,
double elementValue);
1145 const int *indexLast,
1146 const double *boundList);
1148 void resize(
int newNumberRows,
int newNumberColumns);
1194 #ifdef ABC_LONG_FACTORIZATION
1238 #define startAtLowerNoOther_ maximumAbcNumberRows_
1249 #ifdef EARLY_FACTORIZE
1270 #define ALL_STATUS_OK 2048
1271 #define ROW_PRIMAL_OK 4096
1272 #define ROW_DUAL_OK 8192
1273 #define COLUMN_PRIMAL_OK 16384
1274 #define COLUMN_DUAL_OK 32768
1275 #define PESSIMISTIC 65536
1276 #define ADD_A_BIT 131072
1277 #define DO_SCALE_AND_MATRIX 262144
1278 #define DO_BASIS_AND_ORDER 524288
1279 #define DO_STATUS 1048576
1280 #define DO_SOLUTION 2097152
1281 #define DO_JUST_BOUNDS 0x400000
1282 #define NEED_BASIS_SORT 0x800000
1283 #define FAKE_SUPERBASIC 0x1000000
1284 #define VALUES_PASS 0x2000000
1285 #define VALUES_PASS2 0x4000000
1396 #ifdef EARLY_FACTORIZE
1400 #ifdef TEMPORARY_FACTORIZATION
1419 #define ABC_NUMBER_USEFUL 8
1442 #if ABC_PARALLEL == 1
1445 pthread_barrier_t barrier_;
1450 #elif ABC_PARALLEL == 2
int numberTotal() const
Number of variables (includes spare rows)
double objectiveChange_
Objective change.
int maximumNumberTotal() const
Maximum Total.
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
#define ROW_LOWER_SAME
Whats changed since last solve.
double solution(int sequence)
Return row or column values.
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
double & solutionAddress(int sequence)
Return address of row or column values.
CoinPartitionedVector * usefulArray(int index) const
factorization
double sumNonBasicCosts_
Sum of nonbasic costs.
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
double * lowerRegion(int which) const
Return region.
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
double acceptablePivot() const
Acceptable pivot for this iteration.
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
double valueIncomingDual() const
value of incoming variable (in Dual)
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
Given an existing factorization computes and checks primal and dual solutions.
int arrayForBtran() const
factorization
int ordinaryVariables() const
Set to 1 if no free or super basic.
int arrayForFtran_
Sum of nonbasic costs.
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual. ...
int arrayForFlipBounds() const
factorization
int freeSequenceIn_
Free chosen vector.
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
int startAtLowerOther_
Start of variables at lower bound with upper.
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
void computeObjective()
Computes nonbasic cost and total cost.
This is a tiny class where data can be saved round calls.
void setFakeBound(int sequence, FakeBound fakeBound)
Swaps two variables.
int numberColumns_
Number of columns.
int numberFlagged_
Current number of variables flagged.
double * rowUpper_
Row upper.
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
double * solutionBasic() const
Return region.
double * perturbationBasic_
basic perturbation
double * lowerBasic() const
Return region.
double originalLower(int iSequence) const
Return original lower bound.
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
double * abcPerturbation() const
Perturbation.
double * upperRegion(int which) const
Return region.
void deleteBaseModel()
Switch off base model.
double lastDualBound_
Last dual bound.
int arrayForFlipRhs() const
factorization
bool atFakeBound(int sequence) const
Swaps two variables.
AbcMatrix * abcMatrix() const
Abc Matrix.
double * upperBasic() const
Return region.
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
bool initialDenseFactorization() const
Return region.
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
int arrayForTableauRow_
Sum of nonbasic costs.
double currentDualBound() const
Current dualBound (will end up as dualBound_)
int maximumAbcNumberColumns_
Maximum number columns.
unsigned char * internalStatus_
Working status ? may be signed ? link pi_ to an indexed array? may have saved from last factorization...
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
int numberDisasters_
Sum of nonbasic costs.
void saveGoodStatus()
Saves good status etc.
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
int doAbcDual()
Dual algorithm - see AbcSimplexDual.hpp for method.
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
AbcSimplex * baseModel() const
See if we have base model.
double * solutionSaved_
Saved scaled primal solution.
double * inverseRowScale2() const
factorization
double reducedCost(int sequence)
Return region.
AbcMatrix * abcMatrix_
Working matrix.
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
double currentDualBound_
Current dualBound (will end up as dualBound_)
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
AbcSimplex::Status getInternalStatus(int sequence) const
Return region.
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
double * costBasic_
Working scaled copy of basic objective.
double * scaleFromExternal() const
Points from external to internal.
double * costRegion() const
Return region.
int numberRows() const
Number of rows.
void restoreData(ClpDataSave saved)
Restore data.
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
FakeBound getFakeBound(int sequence) const
Swaps two variables.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
double * inverseColumnUseScale_
use this instead of inverseColumnScale
int initialNumberInfeasibilities_
Initial number of infeasibilities.
int getAvailableArray() const
Returns first available empty array (and sets flag)
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
int lastFirstFree_
Last firstFree_.
double & lowerAddress(int sequence)
Return address of row or column lower bound.
double * costRegion(int which) const
Return region.
int housekeeping()
This does basis housekeeping and does values for in/out variables.
int firstFree_
First free/super-basic variable (-1 if none)
AbcSimplex::Status getInternalColumnStatus(int sequence) const
Return region.
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
double * solutionRegion(int which) const
Return region.
void setPivoted(int sequence)
Swaps two variables.
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
void setActive(int iRow)
To say row active in primal pivot row choice.
int doAbcPrimal(int ifValuesPass)
Dual algorithm - see AbcSimplexDual.hpp for method.
void clearPivoted(int sequence)
Swaps two variables.
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
int fakeSuperBasic(int iSequence)
Returns 1 if fake superbasic 0 if free or true superbasic -1 if was fake but has cleaned itself up (s...
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
double * columnUpper_
Column Upper.
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
void setStateOfProblem(int value)
State of problem.
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual. ...
int numberFreeNonBasic_
Number of free nonbasic variables.
double * djBasic_
Working scaled basic dual solution (want it to be zero)
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
int startAtUpperOther_
Start of variables at upper bound with lower.
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
int arrayForFlipRhs_
Sum of nonbasic costs.
int arrayForFlipBounds_
Sum of nonbasic costs.
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
double minimumThetaMovement_
Minimum theta movement.
void setSequenceOut(int sequence)
Return region.
double largestGap_
Largest gap.
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
int arrayForFtran() const
factorization
double acceptablePivot_
Acceptable pivot value just after factorization.
double cost(int sequence)
Return region.
double * tempArray_
Useful array of numberTotal length.
double * columnLower_
Column Lower.
double * upperSaved_
Saved scaled copy of upper bounds.
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
ClpDataSave saveData()
Save data.
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
int sequenceOut() const
Return region.
void setAvailableArray(int which) const
Say array going available.
void setupDualValuesPass(const double *fakeDuals, const double *fakePrimals, int type)
Sets dual values pass djs using unscaled duals type 1 - values pass type 2 - just use as infeasibilit...
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
int arrayForDualColumn_
Sum of nonbasic costs.
double movement_
Movement of variable.
int stateOfProblem() const
State of problem.
double & reducedCostAddress(int sequence)
Return region.
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements) ...
void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus)
Return region.
void setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
int numberColumns() const
Number of rows.
double & costAddress(int sequence)
Return address of row or column cost.
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
double rawObjectiveValue_
Sum of costs (raw objective value)
double * columnUseScale_
use this instead of columnScale
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
double * columnScale2() const
factorization
void setCurrentDualTolerance(double value)
Given an existing factorization computes and checks primal and dual solutions.
void clearArrays(int which)
Clears an array and says available (-1 does all)
int maximumAbcNumberRows() const
Maximum rows.
int maximumTotal() const
factorization
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
Primal Column Pivot Abstract Base Class.
void clearActive(int iRow)
Swaps two variables.
Base class for Clp disaster handling.
void checkSolutionBasic() const
For debug - checks solutionBasic.
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed...
unsigned char * internalStatusSaved_
Saved status.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
double objectiveValue_
Objective value.
int arrayForReplaceColumn_
Sum of nonbasic costs.
int sequenceIn_
Sequence of In variable.
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal) ...
#define COLUMN_UPPER_SAME
Whats changed since last solve.
void clearFlagged(int sequence)
Swaps two variables.
ClpDataSave saveData_
For saving stuff at beginning.
int multipleSequenceIn_[4]
Multiple sequence in.
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well) ...
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
double btranAlpha_
Btran alpha.
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
double perturbationFactor_
Perturbation factor If <0.0 then virtual if 0.0 none if >0.0 use this as factor.
unsigned char * internalStatus() const
Return region.
int ordinaryVariables_
Set to 1 if no free or super basic.
double * scaleFromExternal_
Points from external to internal.
This solves LPs using the simplex method.
double * offsetRhs_
Offset for accumulated offsets*matrix.
double lower(int sequence)
Return region.
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows)
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
int arrayForDualColumn() const
factorization
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
double * inverseColumnScale2() const
factorization
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
int numberFlipped_
Sum of nonbasic costs.
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
CoinBigIndex getNumElements() const
Number of elements in matrix.
void crash(int type)
Does sort of crash.
Status
enums for status of various sorts.
double upperTheta_
upper theta from dual column
double initialSumInfeasibilities_
Initial sum of infeasibilities.
void createStatus()
Set up status array (can be used by OsiAbc).
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
Dual Row Pivot Abstract Base Class.
double objectiveOffset_
Objective offset (from offset_)
int factorizationFrequency() const
Factorization frequency.
bool active(int iRow) const
Swaps two variables.
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
void setFlagged(int sequence)
To flag a variable.
double * upperRegion() const
Return region.
double originalUpper(int iSequence) const
Return original lower bound.
This just implements AbcFactorization when an AbcMatrix object is passed.
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
double upperTheta() const
upper theta from dual column
double * djSaved_
Saved scaled dual solution.
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs) ...
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert...
AbcSimplexFactorization * abcFactorization_
factorization
double * djBasic() const
Return region.
bool pivoted(int sequence) const
Swaps two variables.
void dropNames()
Drops names - makes lengthnames 0 and names empty.
double * rowLower_
Row lower.
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
void setUsedArray(int which) const
Say array going to be used.
int lastFirstFree() const
Last firstFree_.
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
double upper(int sequence)
Return region.
double & upperAddress(int sequence)
Return address of row or column upper bound.
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
void makeBaseModel()
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
Given an existing factorization computes and checks primal and dual solutions.
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
double * fakeDjs() const
Fake djs.
void setSequenceIn(int sequence)
Set sequenceIn or Out.
int startFixed_
Start of fixed variables.
void printStuff() const
Print stuff.
void moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
int arrayForReplaceColumn() const
factorization
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
Sum of nonbasic costs.
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
AbcSimplexFactorization * factorization() const
factorization
double * solutionBasic_
Working scaled basic primal solution.
int firstFree() const
First Free_.
int sequenceOut_
Sequence of Out variable.
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
#define COLUMN_LOWER_SAME
Whats changed since last solve.
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
int stateOfIteration_
Where we are in iteration.
Objective function constant.
void cleanStatus()
Clean up status.
void setColumnSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously The default implementation just invokes setColL...
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
double * lowerRegion() const
Return region.
int internalFactorize(int solveType)
Factorizes using current basis.
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
double dblParam_[ClpLastDblParam]
Array of double parameters.
int maximumAbcNumberRows_
Maximum number rows.
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
Return region.
double * djRegion(int which) const
Return region.
void putStuffInBasis(int type)
Puts more stuff in basis 1 bit set - do even if basis exists 2 bit set - don't bother staying triangu...
int arrayForBtran_
Sum of nonbasic costs.
#define inverseRowUseScale_
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation. ...
double * costBasic() const
Return region.
int numberTotal_
Number of variables (includes spare rows)
double * solutionRegion() const
Return region.
int freeSequenceIn() const
Free chosen vector.
double * perturbationSaved_
saved perturbation
AbcSimplex * abcBaseModel_
Saved version of solution.
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
int lastCleaned_
Last time cleaned up.
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
double * lowerBasic_
Working scaled copy of basic lower bounds.
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
AbcSimplex(bool emptyMessages=false)
Default constructor.
int stateOfProblem_
Sum of nonbasic costs.
void setFactorizationFrequency(int value)
factorization
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
void swapPrimalStuff()
Swaps primal stuff.
int sequenceIn() const
Return sequence In or Out.
double lastPrimalError_
Last primal error.
int startOther_
Start of superBasic, free or awkward bounds variables.
double * rowScale2() const
corresponds to rowScale etc
The default COIN simplex (basis-oriented) warm start class.
int sequenceWithin(int sequence) const
Returns sequence number within section.
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
double * costSaved_
Saved scaled copy of objective.
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
int arrayForTableauRow() const
factorization
double clpObjectiveValue() const
Objective value.
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual)
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual) ...
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
double * lowerSaved_
Saved scaled copy of lower bounds.
void moveToBasic(int which=15)
Moves basic stuff to basic area.
double lastDualError_
Last dual error.
double * upperBasic_
Working scaled copy of basic upper bounds.
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular...
double * djRegion() const
Return region.
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
double primalTolerance_
Current primal tolerance for algorithm.
int maximumNumberTotal_
Maximum numberTotal.
double currentAcceptablePivot_
Acceptable pivot for this iteration.
bool flagged(int sequence) const
Swaps two variables.
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements) ...