Go to the documentation of this file.
18 #include "CoinIndexedVector.hpp"
28 class OsiAbcSolverInterface;
29 class CoinWarmStartBasis;
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);
202 #ifdef EARLY_FACTORIZE
232 return const_cast<CoinPartitionedVector *
>(&
usefulArray_[index]);
251 const double * fakePrimals,
334 int computeDuals(
double * givenDjs, CoinIndexedVector * array1, CoinIndexedVector * array2);
375 #define rowUseScale_ scaleFromExternal_
376 #define inverseRowUseScale_ scaleToExternal_
407 double allowedInfeasibility);
497 const double * givenPrimals,
498 bool valuesPass =
false);
581 st_byte =
static_cast<unsigned char>(st_byte & ~7);
582 st_byte =
static_cast<unsigned char>(st_byte | newstatus);
586 st_byte =
static_cast<unsigned char>(st_byte & ~7);
587 st_byte =
static_cast<unsigned char>(st_byte | newstatus);
611 inline int sequenceInternalIn()
const {
612 return sequenceInternalIn_;
614 inline int sequenceInternalOut()
const {
615 return sequenceInternalOut_;
618 inline void setSequenceInternalIn(
int sequence) {
619 sequenceInternalIn_ = sequence;
621 inline void setSequenceInternalOut(
int sequence) {
622 sequenceInternalOut_ = sequence;
625 inline int isColumn(
int sequence)
const {
665 printf(
"Pansetting %d to lb\n",iSequence);
675 printf(
"Pansetting %d to ub\n",iSequence);
686 inline double solution(
int sequence) {
714 inline double cost(
int sequence) {
740 void restoreFromSubProblem(
AbcSimplex * fullProblem,
const int * whichColumn);
752 inline int parallelMode()
const
754 {
return parallelMode_;}
756 inline void setParallelMode(
int value)
757 { parallelMode_=value;}
759 inline int numberCpus()
const
760 {
return parallelMode_+1;}
762 inline void setStopStart(
int value)
793 st_byte =
static_cast<unsigned char>(st_byte & ~24);
794 st_byte =
static_cast<unsigned char>(st_byte | (fakeBound << 3));
862 #ifndef NUMBER_THREADS
863 #define NUMBER_THREADS 3
867 inline pthread_mutex_t * mutexPointer(
int which,
int thread=0)
868 {
return mutex_+which+3*thread;}
869 inline pthread_barrier_t * barrierPointer()
871 inline int whichLocked(
int thread=0)
const
872 {
return locked_[thread];}
873 inline CoinThreadInfo * threadInfoPointer(
int thread=0)
874 {
return threadInfo_+thread;}
875 void startParallelStuff(
int type);
876 int stopParallelStuff(
int type);
878 int whichThread()
const;
879 #elif ABC_PARALLEL==2
891 inline void setObjCoeff(
int elementIndex,
double elementValue ) {
916 const int* indexLast,
917 const double* boundList);
921 inline void setColLower(
int elementIndex,
double elementValue ) {
926 inline void setColUpper(
int elementIndex,
double elementValue ) {
932 double newlower,
double newupper ) {
943 const int* indexLast,
944 const double* boundList) {
967 const int* indexLast,
968 const double* boundList);
970 void resize (
int newNumberRows,
int newNumberColumns);
1017 #ifdef ABC_LONG_FACTORIZATION
1059 #define startAtLowerNoOther_ maximumAbcNumberRows_
1070 #ifdef EARLY_FACTORIZE
1091 #define ALL_STATUS_OK 2048
1092 #define ROW_PRIMAL_OK 4096
1093 #define ROW_DUAL_OK 8192
1094 #define COLUMN_PRIMAL_OK 16384
1095 #define COLUMN_DUAL_OK 32768
1096 #define PESSIMISTIC 65536
1097 #define ADD_A_BIT 131072
1098 #define DO_SCALE_AND_MATRIX 262144
1099 #define DO_BASIS_AND_ORDER 524288
1100 #define DO_STATUS 1048576
1101 #define DO_SOLUTION 2097152
1102 #define DO_JUST_BOUNDS 0x400000
1103 #define NEED_BASIS_SORT 0x800000
1104 #define FAKE_SUPERBASIC 0x1000000
1105 #define VALUES_PASS 0x2000000
1106 #define VALUES_PASS2 0x4000000
1216 #ifdef EARLY_FACTORIZE
1220 #ifdef TEMPORARY_FACTORIZATION
1239 #define ABC_NUMBER_USEFUL 8
1264 pthread_barrier_t barrier_;
1269 #elif ABC_PARALLEL==2
This solves LPs using the simplex method.
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
double * costBasic_
Working scaled copy of basic objective.
double * solutionRegion() const
Return region.
#define COLUMN_UPPER_SAME
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
@ ClpObjOffset
Objective function constant.
#define inverseRowUseScale_
void saveGoodStatus()
Saves good status etc.
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
double valueIncomingDual() const
value of incoming variable (in Dual)
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
int firstFree_
First free/super-basic variable (-1 if none)
double * upperBasic_
Working scaled copy of basic upper bounds.
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
void crash(int type)
Does sort of crash.
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows)
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed.
double * rowScale2() const
corresponds to rowScale etc
CoinPartitionedVector * usefulArray(int index) const
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
double * columnUpper_
Column Upper.
double * upperRegion(int which) const
int ordinaryVariables() const
Set to 1 if no free or super basic.
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
double solution(int sequence)
Return row or column values.
double reducedCost(int sequence)
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
double * upperRegion() const
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
double * columnUseScale_
use this instead of columnScale
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
AbcSimplex(const AbcSimplex &rhs)
Copy constructor.
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual)
double * solutionRegion(int which) const
Return region.
void cleanStatus(bool valuesPass=false)
Clean up status - make sure no superbasic etc.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
double & solutionAddress(int sequence)
Return address of row or column values.
int arrayForReplaceColumn_
int startOther_
Start of superBasic, free or awkward bounds variables.
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
int firstFree() const
First Free_.
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual.
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
void clearPivoted(int sequence)
int housekeeping()
This does basis housekeeping and does values for in/out variables.
int gutsOfSolution(double *givenDuals, const double *givenPrimals, bool valuesPass=false)
May change basis and then returns number changed.
double * inverseColumnScale2() const
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
AbcSimplex(AbcSimplex *wholeModel, int numberColumns, const int *whichColumns)
This constructor modifies original AbcSimplex and stores original stuff in created AbcSimplex.
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
bool active(int iRow) const
double * columnLower_
Column Lower.
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
void createStatus()
Set up status array (can be used by OsiAbc).
double objectiveChange_
Objective change.
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
double acceptablePivot() const
Acceptable pivot for this iteration.
unsigned char * internalStatus() const
int lastFirstFree() const
Last firstFree_.
int numberFlagged_
Current number of variables flagged.
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
int maximumNumberTotal_
Maximum numberTotal.
double cost(int sequence)
This is a tiny class where data can be saved round calls.
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
void swapPrimalStuff()
Swaps primal stuff.
double originalLower(int iSequence) const
Return original lower bound.
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well)
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
double * inverseRowScale2() const
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
double btranAlpha_
Btran alpha.
int arrayForReplaceColumn() const
double currentDualBound() const
Current dualBound (will end up as dualBound_)
double * lowerBasic() const
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
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...
int arrayForFlipRhs() const
double lastDualError_
Last dual error.
double * abcPerturbation() const
Perturbation.
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
double upperTheta_
upper theta from dual column
void setFactorizationFrequency(int value)
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
void clearArrays(CoinPartitionedVector *which)
Clears an array and says available.
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
double & reducedCostAddress(int sequence)
void setCurrentDualTolerance(double value)
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
void clearFlagged(int sequence)
void makeBaseModel()
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
double * costSaved_
Saved scaled copy of objective.
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
void setFakeBound(int sequence, FakeBound fakeBound)
void setAvailableArray(int which) const
Say array going available.
void unpack(CoinIndexedVector &rowArray, int sequence) const
Unpacks one column of the matrix into indexed array.
double lastDualBound_
Last dual bound.
unsigned char * internalStatusSaved_
Saved status.
double * costBasic() const
double * lowerBasic_
Working scaled copy of basic lower bounds.
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
int getNumElements() const
Number of elements in matrix.
double * costRegion(int which) const
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
int lastCleaned_
Last time cleaned up.
void swap(int pivotRow, int nonBasicPosition)
Swaps two variables.
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
int getAvailableArray() const
Returns first available empty array (and sets flag)
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal)
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
FakeBound getFakeBound(int sequence) const
double * solutionSaved_
Saved scaled primal solution.
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
int stateOfIteration_
Where we are in iteration.
int sequenceIn_
Sequence of In variable.
double * tempArray_
Useful array of numberTotal length.
int maximumNumberTotal() const
Maximum Total.
int arrayForDualColumn() const
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
ClpDataSave saveData()
Save data.
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
int maximumAbcNumberRows_
Maximum number rows.
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert.
void moveToBasic(int which=15)
Moves basic stuff to basic area.
double * upperBasic() const
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
double * fakeDjs() const
Fake djs.
AbcSimplex(const ClpSimplex &rhs)
Copy constructor from model.
Base class for Clp disaster handling.
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
This just implements AbcFactorization when an AbcMatrix object is passed.
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
double initialSumInfeasibilities_
Initial sum of infeasibilities.
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
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 startAtLowerOther_
Start of variables at lower bound with upper.
double * upperSaved_
Saved scaled copy of upper bounds.
AbcSimplex(bool emptyMessages=false)
Default constructor.
AbcSimplex(const ClpSimplex *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true, bool fixOthers=false)
Subproblem constructor.
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
bool flagged(int sequence) const
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
AbcSimplex(const AbcSimplex *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true, bool fixOthers=false)
Subproblem constructor.
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
double * costRegion() const
void setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
int numberColumns_
Number of columns.
AbcSimplex * abcBaseModel_
Saved version of solution.
double * lowerRegion(int which) const
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
double & upperAddress(int sequence)
Return address of row or column upper bound.
double & costAddress(int sequence)
Return address of row or column cost.
int lastFirstFree_
Last firstFree_.
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
Dual Row Pivot Abstract Base Class.
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs)
void setUsedArray(int which) const
Say array going to be used.
AbcMatrix * abcMatrix() const
Abc Matrix.
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
void setSequenceOut(int sequence)
double acceptablePivot_
Acceptable pivot value just after factorization.
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
double * lowerRegion() const
unsigned char * internalStatus_
Working status ? may be signed ? link pi_ to an indexed array? may have saved from last factorization...
int freeSequenceIn() const
Free chosen vector.
double rawObjectiveValue_
Sum of costs (raw objective value)
void computeObjective()
Computes nonbasic cost and total cost.
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
double primalTolerance_
Current primal tolerance for algorithm.
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
void deleteBaseModel()
Switch off base model.
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
double * solutionBasic() const
Return region.
double objectiveValue_
Objective value.
double sumNonBasicCosts_
Sum of nonbasic costs.
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
int factorizationFrequency() const
Factorization frequency.
int arrayForFtran() const
double originalUpper(int iSequence) const
Return original lower bound.
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
AbcSimplex * baseModel() const
See if we have base model.
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
AbcSimplexFactorization * factorization() const
factorization
AbcMatrix * abcMatrix_
Working matrix.
double upper(int sequence)
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
int startFixed_
Start of fixed variables.
void setSequenceIn(int sequence)
Set sequenceIn or Out.
void setStateOfProblem(int value)
State of problem.
int startAtUpperOther_
Start of variables at upper bound with lower.
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
bool pivoted(int sequence) const
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
int stateOfProblem() const
State of problem.
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
double * solutionBasic_
Working scaled basic primal solution.
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual.
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
bool initialDenseFactorization() const
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
double currentDualBound_
Current dualBound (will end up as dualBound_)
double * offsetRhs_
Offset for accumulated offsets*matrix.
AbcSimplex::Status getInternalColumnStatus(int sequence) const
AbcSimplex::Status getInternalStatus(int sequence) const
int freeSequenceIn_
Free chosen vector.
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
double * djSaved_
Saved scaled dual solution.
#define COLUMN_LOWER_SAME
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual)
double * rowLower_
Row lower.
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
double lower(int sequence)
void setPivoted(int sequence)
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
int arrayForBtran() const
double * columnScale2() const
double * scaleFromExternal_
Points from external to internal.
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
double * djBasic_
Working scaled basic dual solution (want it to be zero)
void printStuff() const
Print stuff.
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular.
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
int doAbcPrimal(int ifValuesPass)
double objectiveOffset_
Objective offset (from offset_)
void clearActive(int iRow)
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
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 checkSolutionBasic() const
For debug - checks solutionBasic.
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
ClpDataSave saveData_
For saving stuff at beginning.
double largestGap_
Largest gap.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
bool atFakeBound(int sequence) const
int numberColumns() const
void clearArrays(int which)
Clears an array and says available (-1 does all)
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
double & lowerAddress(int sequence)
Return address of row or column lower bound.
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
int arrayForFlipBounds() const
double perturbationFactor_
Perturbation factor If <0.0 then virtual if 0.0 none if >0.0 use this as factor.
double lastPrimalError_
Last primal error.
double * scaleFromExternal() const
Points from external to internal.
AbcSimplex(const ClpSimplex *clpSimplex)
This constructor copies from ClpSimplex.
int sequenceOut_
Sequence of Out variable.
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...
Status
enums for status of various sorts.
double clpObjectiveValue() const
Objective value.
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)
double * djRegion(int which) const
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
void restoreData(ClpDataSave saved)
Restore data.
AbcSimplexFactorization * abcFactorization_
factorization
void setFlagged(int sequence)
To flag a variable.
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
double minimumThetaMovement_
Minimum theta movement.
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
double upperTheta() const
upper theta from dual column
int sequenceIn() const
Return sequence In or Out.
int arrayForTableauRow() const
int internalFactorize(int solveType)
Factorizes using current basis.
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously
int initialNumberInfeasibilities_
Initial number of infeasibilities.
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
int maximumAbcNumberColumns_
Maximum number columns.
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.
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
double * djRegion() const
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
double * lowerSaved_
Saved scaled copy of lower bounds.
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation.
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
int maximumAbcNumberRows() const
Maximum rows.
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
int numberRows() const
Number of rows.
int numberTotal() const
Number of variables (includes spare rows)
int multipleSequenceIn_[4]
Multiple sequence in.
double * rowUpper_
Row upper.
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
double * perturbationBasic_
basic perturbation
void dropNames()
Drops names - makes lengthnames 0 and names empty.
double dblParam_[ClpLastDblParam]
Array of double parameters.
void moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
void setActive(int iRow)
To say row active in primal pivot row choice.
double * perturbationSaved_
saved perturbation
int sequenceWithin(int sequence) const
Returns sequence number within section.
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
Primal Column Pivot Abstract Base Class.
double movement_
Movement of variable.
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
double currentAcceptablePivot_
Acceptable pivot for this iteration.
int numberTotal_
Number of variables (includes spare rows)
double * inverseColumnUseScale_
use this instead of inverseColumnScale