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 208 return reinterpret_cast< AbcSimplexFactorization * >(abcEarlyFactorization_);
247 return const_cast< CoinPartitionedVector * >(&
usefulArray_[index]);
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 sequenceIn() const
Return sequence In or Out.
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
CoinBigIndex getNumElements() const
Number of elements in matrix.
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
int maximumNumberTotal_
Maximum numberTotal.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
unsigned char * internalStatusSaved_
Saved status.
void clearArrays(int which)
Clears an array and says available (-1 does all)
double * offsetRhs_
Offset for accumulated offsets*matrix.
AbcSimplex::Status getInternalStatus(int sequence) const
double * upperBasic() const
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well)
double * rowUpper_
Row upper.
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
double * fakeDjs() const
Fake djs.
double dblParam_[ClpLastDblParam]
Array of double parameters.
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
AbcSimplex(bool emptyMessages=false)
Default constructor.
This just implements AbcFactorization when an AbcMatrix object is passed.
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
FakeBound getFakeBound(int sequence) const
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
double & solutionAddress(int sequence)
Return address of row or column values.
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
void setCurrentDualTolerance(double value)
Primal Column Pivot Abstract Base Class.
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual)
double currentAcceptablePivot_
Acceptable pivot for this iteration.
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
int maximumNumberTotal() const
Maximum Total.
int numberColumns() const
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
int lastFirstFree() const
Last firstFree_.
int maximumAbcNumberColumns_
Maximum number columns.
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
int internalFactorize(int solveType)
Factorizes using current basis.
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
void setAvailableArray(int which) const
Say array going available.
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
void crash(int type)
Does sort of crash.
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
unsigned char * internalStatus_
Working status ? may be signed ? link pi_ to an indexed array? may have saved from last factorization...
double * inverseRowScale2() const
double btranAlpha_
Btran alpha.
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed.
double objectiveChange_
Objective change.
int numberFlagged_
Current number of variables flagged.
double perturbationFactor_
Perturbation factor If <0.0 then virtual if 0.0 none if >0.0 use this as factor.
void computeObjective()
Computes nonbasic cost and total cost.
double * upperSaved_
Saved scaled copy of upper bounds.
double * upperRegion(int which) const
double lastDualError_
Last dual error.
double * djRegion(int which) const
double clpObjectiveValue() const
Objective value.
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
double * solutionBasic() const
Return region.
void deleteBaseModel()
Switch off base model.
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
int arrayForReplaceColumn() const
Base class for Clp disaster handling.
double * upperRegion() const
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 moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
void setActive(int iRow)
To say row active in primal pivot row choice.
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs)
double * solutionSaved_
Saved scaled primal solution.
int initialNumberInfeasibilities_
Initial number of infeasibilities.
AbcSimplexFactorization * factorization() const
factorization
int arrayForTableauRow() const
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
double * inverseColumnScale2() const
double * perturbationSaved_
saved perturbation
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
bool active(int iRow) const
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
double rawObjectiveValue_
Sum of costs (raw objective value)
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
double sumNonBasicCosts_
Sum of nonbasic costs.
int multipleSequenceIn_[4]
Multiple sequence in.
void cleanStatus()
Clean up status.
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
double initialSumInfeasibilities_
Initial sum of infeasibilities.
CoinPartitionedVector * usefulArray(int index) const
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
double * costRegion() const
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual)
double * lowerRegion(int which) const
void setFactorizationFrequency(int value)
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
double movement_
Movement of variable.
int sequenceIn_
Sequence of In variable.
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
double upperTheta_
upper theta from dual column
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
int startFixed_
Start of fixed variables.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
ClpDataSave saveData()
Save data.
void clearActive(int iRow)
ClpDataSave saveData_
For saving stuff at beginning.
double largestGap_
Largest gap.
#define inverseRowUseScale_
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual.
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
double reducedCost(int sequence)
double * costBasic() const
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
double solution(int sequence)
Return row or column values.
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
Dual Row Pivot Abstract Base Class.
double & lowerAddress(int sequence)
Return address of row or column lower bound.
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
int lastCleaned_
Last time cleaned up.
int lastFirstFree_
Last firstFree_.
double * solutionRegion(int which) const
Return region.
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
int startOther_
Start of superBasic, free or awkward bounds variables.
This solves LPs using the simplex method.
int arrayForReplaceColumn_
void clearPivoted(int sequence)
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
double * abcPerturbation() const
Perturbation.
int firstFree() const
First Free_.
void setSequenceOut(int sequence)
double * columnUpper_
Column Upper.
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 setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
double acceptablePivot() const
Acceptable pivot for this iteration.
bool flagged(int sequence) const
unsigned char * internalStatus() const
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
double & reducedCostAddress(int sequence)
void createStatus()
Set up status array (can be used by OsiAbc).
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
void setUsedArray(int which) const
Say array going to be used.
int maximumAbcNumberRows_
Maximum number rows.
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
int arrayForDualColumn() const
double * costSaved_
Saved scaled copy of objective.
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
AbcMatrix * abcMatrix() const
Abc Matrix.
void clearFlagged(int sequence)
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
int ordinaryVariables_
Set to 1 if no free or super basic.
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
double lastDualBound_
Last dual bound.
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
double currentDualBound_
Current dualBound (will end up as dualBound_)
double originalLower(int iSequence) const
Return original lower bound.
int numberColumns_
Number of columns.
Objective function constant.
double originalUpper(int iSequence) const
Return original lower bound.
This is a tiny class where data can be saved round calls.
int numberFreeNonBasic_
Number of free nonbasic variables.
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...
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
int startAtLowerOther_
Start of variables at lower bound with upper.
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
double * costRegion(int which) const
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
int startAtUpperOther_
Start of variables at upper bound with lower.
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal)
AbcSimplex * abcBaseModel_
Saved version of solution.
void setFlagged(int sequence)
To flag a variable.
int arrayForBtran() const
int getAvailableArray() const
Returns first available empty array (and sets flag)
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
AbcSimplexFactorization * abcFactorization_
factorization
double primalTolerance_
Current primal tolerance for algorithm.
int maximumAbcNumberRows() const
Maximum rows.
void restoreData(ClpDataSave saved)
Restore data.
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
double upperTheta() const
upper theta from dual column
double * scaleFromExternal_
Points from external to internal.
int arrayForFtran() const
int doAbcPrimal(int ifValuesPass)
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
double objectiveOffset_
Objective offset (from offset_)
void checkSolutionBasic() const
For debug - checks solutionBasic.
void setFakeBound(int sequence, FakeBound fakeBound)
int stateOfIteration_
Where we are in iteration.
double upper(int sequence)
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
bool initialDenseFactorization() const
double * djRegion() const
void moveToBasic(int which=15)
Moves basic stuff to basic area.
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
double * lowerBasic_
Working scaled copy of basic lower bounds.
double acceptablePivot_
Acceptable pivot value just after factorization.
AbcSimplex::Status getInternalColumnStatus(int sequence) const
double valueIncomingDual() const
value of incoming variable (in Dual)
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
int stateOfProblem() const
State of problem.
double * lowerSaved_
Saved scaled copy of lower bounds.
int numberTotal() const
Number of variables (includes spare rows)
double * rowScale2() const
corresponds to rowScale etc
double * upperBasic_
Working scaled copy of basic upper bounds.
double lastPrimalError_
Last primal error.
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation.
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
double * inverseColumnUseScale_
use this instead of inverseColumnScale
int freeSequenceIn_
Free chosen vector.
double * djSaved_
Saved scaled dual solution.
double * tempArray_
Useful array of numberTotal length.
AbcMatrix * abcMatrix_
Working matrix.
int numberRows() const
Number of rows.
double & upperAddress(int sequence)
Return address of row or column upper bound.
double * columnUseScale_
use this instead of columnScale
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert.
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
void setSequenceIn(int sequence)
Set sequenceIn or Out.
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
bool pivoted(int sequence) const
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
#define COLUMN_LOWER_SAME
double * djBasic_
Working scaled basic dual solution (want it to be zero)
int sequenceOut_
Sequence of Out variable.
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
double * lowerRegion() const
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
int freeSequenceIn() const
Free chosen vector.
double * solutionBasic_
Working scaled basic primal solution.
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
void swapPrimalStuff()
Swaps primal stuff.
bool atFakeBound(int sequence) const
int ordinaryVariables() const
Set to 1 if no free or super basic.
double cost(int sequence)
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
int factorizationFrequency() const
Factorization frequency.
double minimumThetaMovement_
Minimum theta movement.
double * rowLower_
Row lower.
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
double & costAddress(int sequence)
Return address of row or column cost.
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
void setPivoted(int sequence)
double * columnScale2() const
double * scaleFromExternal() const
Points from external to internal.
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
#define COLUMN_UPPER_SAME
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual.
int numberTotal_
Number of variables (includes spare rows)
int housekeeping()
This does basis housekeeping and does values for in/out variables.
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...
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
void setStateOfProblem(int value)
State of problem.
void dropNames()
Drops names - makes lengthnames 0 and names empty.
double objectiveValue_
Objective value.
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
void saveGoodStatus()
Saves good status etc.
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows)
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
int arrayForFlipBounds() const
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
double currentDualBound() const
Current dualBound (will end up as dualBound_)
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
double * columnLower_
Column Lower.
double * perturbationBasic_
basic perturbation
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...
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
int arrayForFlipRhs() const
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
AbcSimplex * baseModel() const
See if we have base model.
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
double * lowerBasic() const
Status
enums for status of various sorts.
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
int sequenceWithin(int sequence) const
Returns sequence number within section.
double lower(int sequence)
double * costBasic_
Working scaled copy of basic objective.
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously
void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus)
int firstFree_
First free/super-basic variable (-1 if none)
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
void printStuff() const
Print stuff.
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
double * solutionRegion() const
Return region.
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular.