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
double * costRegion(int which) const
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
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...
double * djRegion(int which) const
int arrayForDualColumn() const
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements) ...
int maximumNumberTotal_
Maximum numberTotal.
int maximumAbcNumberRows() const
Maximum rows.
double originalLower(int iSequence) const
Return original lower bound.
void printStuff() const
Print stuff.
unsigned char * internalStatusSaved_
Saved status.
int arrayForFlipBounds() const
bool pivoted(int sequence) const
void clearArrays(int which)
Clears an array and says available (-1 does all)
double * offsetRhs_
Offset for accumulated offsets*matrix.
CoinPartitionedVector * usefulArray(int index) const
void setAvailableArray(int which) const
Say array going available.
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
double * rowUpper_
Row upper.
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
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...
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.
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
double * lowerRegion(int which) const
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.
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
bool initialDenseFactorization() const
int maximumAbcNumberColumns_
Maximum number columns.
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
int internalFactorize(int solveType)
Factorizes using current basis.
unsigned char * internalStatus() const
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
void setUsedArray(int which) const
Say array going to be used.
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
void crash(int type)
Does sort of crash.
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 currentAcceptablePivot() const
Acceptable pivot for this iteration.
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.
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
double lastDualError_
Last dual error.
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
void checkSolutionBasic() const
For debug - checks solutionBasic.
void deleteBaseModel()
Switch off base model.
int sequenceWithin(int sequence) const
Returns sequence number within section.
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
double * solutionBasic() const
Return region.
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
Base class for Clp disaster handling.
double * scaleFromExternal() const
Points from external to internal.
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.
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) ...
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
double * perturbationSaved_
saved perturbation
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
double * lowerRegion() const
double rawObjectiveValue_
Sum of costs (raw objective value)
The default COIN simplex (basis-oriented) warm start class.
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
double originalUpper(int iSequence) const
Return original lower bound.
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.
FakeBound getFakeBound(int sequence) const
double sumNonBasicCosts_
Sum of nonbasic costs.
int sequenceIn() const
Return sequence In or Out.
AbcSimplex::Status getInternalColumnStatus(int sequence) const
double valueIncomingDual() const
value of incoming variable (in Dual)
int numberTotal() const
Number of variables (includes spare rows)
int multipleSequenceIn_[4]
Multiple sequence in.
void cleanStatus()
Clean up status.
double initialSumInfeasibilities_
Initial sum of infeasibilities.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
double * inverseRowScale2() const
double * upperRegion() const
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
bool active(int iRow) const
int numberColumns() const
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual) ...
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.
double * inverseColumnScale2() const
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
double * fakeDjs() const
Fake djs.
double upperTheta_
upper theta from dual column
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
int startFixed_
Start of fixed variables.
double * rowScale2() const
corresponds to rowScale etc
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
ClpDataSave saveData()
Save data.
int factorizationFrequency() const
Factorization frequency.
double * abcPerturbation() const
Perturbation.
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
void clearActive(int iRow)
AbcSimplex * baseModel() const
See if we have base model.
ClpDataSave saveData_
For saving stuff at beginning.
double largestGap_
Largest gap.
int stateOfProblem() const
State of problem.
#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. ...
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual. ...
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
double reducedCost(int sequence)
#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.
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
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.
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
int lastCleaned_
Last time cleaned up.
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
int lastFirstFree_
Last firstFree_.
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 unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
void clearPivoted(int sequence)
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
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.
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
int arrayForFlipRhs() const
double & reducedCostAddress(int sequence)
void createStatus()
Set up status array (can be used by OsiAbc).
int lastFirstFree() const
Last firstFree_.
double upperTheta() const
upper theta from dual column
int maximumAbcNumberRows_
Maximum number rows.
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
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
void clearFlagged(int sequence)
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
bool flagged(int sequence) const
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
int arrayForBtran() const
int ordinaryVariables_
Set to 1 if no free or super basic.
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
int maximumNumberTotal() const
Maximum Total.
double lastDualBound_
Last dual bound.
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
double currentDualBound_
Current dualBound (will end up as dualBound_)
int numberColumns_
Number of columns.
Objective function constant.
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 ordinaryVariables() const
Set to 1 if no free or super basic.
double * djRegion() const
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.
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.
double * columnScale2() const
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
AbcSimplexFactorization * abcFactorization_
factorization
double primalTolerance_
Current primal tolerance for algorithm.
double * costBasic() const
void restoreData(ClpDataSave saved)
Restore data.
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
double * upperBasic() const
double * scaleFromExternal_
Points from external to internal.
int doAbcPrimal(int ifValuesPass)
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
double * lowerBasic() const
double objectiveOffset_
Objective offset (from offset_)
void setFakeBound(int sequence, FakeBound fakeBound)
int stateOfIteration_
Where we are in iteration.
double upper(int sequence)
double acceptablePivot() const
Acceptable pivot for this iteration.
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
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.
int arrayForFtran() const
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
double * lowerSaved_
Saved scaled copy of lower bounds.
double clpObjectiveValue() const
Objective value.
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. ...
AbcSimplex::Status getInternalStatus(int sequence) const
int numberRows() const
Number of rows.
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
double currentDualBound() const
Current dualBound (will end up as dualBound_)
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.
AbcMatrix * abcMatrix() const
Abc Matrix.
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
double * solutionRegion() const
Return region.
double & upperAddress(int sequence)
Return address of row or column upper bound.
double * columnUseScale_
use this instead of columnScale
AbcSimplexFactorization * factorization() const
factorization
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
int freeSequenceIn() const
Free chosen vector.
int firstFree() const
First Free_.
void setSequenceIn(int sequence)
Set sequenceIn or Out.
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
bool atFakeBound(int sequence) const
CoinBigIndex getNumElements() const
Number of elements in matrix.
int arrayForTableauRow() const
#define COLUMN_LOWER_SAME
double * djBasic_
Working scaled basic dual solution (want it to be zero)
int getAvailableArray() const
Returns first available empty array (and sets flag)
int sequenceOut_
Sequence of Out variable.
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
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.
double * solutionBasic_
Working scaled basic primal solution.
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well) ...
void swapPrimalStuff()
Swaps primal stuff.
double cost(int sequence)
double * solutionRegion(int which) const
Return region.
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
double minimumThetaMovement_
Minimum theta movement.
double * rowLower_
Row lower.
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
double & costAddress(int sequence)
Return address of row or column cost.
void setPivoted(int sequence)
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
#define COLUMN_UPPER_SAME
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
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.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
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.
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
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)
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
double * upperRegion(int which) const
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
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...
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
Status
enums for status of various sorts.
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.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
int arrayForReplaceColumn() const
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert...
double * costRegion() const
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
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...