18 #include "CoinIndexedVector.hpp" 28 class OsiAbcSolverInterface;
29 class CoinWarmStartBasis;
31 class AbcSimplexProgress;
53 #if ABC_NORMAL_DEBUG>0 57 #define HEAVY_PERTURBATION 57 116 int numberRows,
const int * whichRows,
117 int numberColumns,
const int * whichColumns,
118 bool dropNames =
true,
bool dropIntegers =
true,
119 bool fixOthers =
false);
127 int numberRows,
const int * whichRows,
128 int numberColumns,
const int * whichColumns,
129 bool dropNames =
true,
bool dropIntegers =
true,
130 bool fixOthers =
false);
135 int numberColumns,
const int * whichColumns);
150 void makeBaseModel();
152 void deleteBaseModel();
155 return abcBaseModel_;
160 void setToBaseModel(
AbcSimplex * model = NULL);
175 int primal(
int ifValuesPass);
176 int doAbcPrimal(
int ifValuesPass);
178 CoinWarmStartBasis * getBasis()
const;
194 int tightenPrimalBounds();
200 void defaultFactorizationFrequency();
210 #ifdef EARLY_FACTORIZE 216 int factorizationFrequency()
const;
218 void setFactorizationFrequency(
int value);
221 {
return maximumAbcNumberRows_;}
224 {
return maximumNumberTotal_;}
226 {
return maximumNumberTotal_;}
228 bool isObjectiveLimitTestValid()
const ;
231 {
return numberTotal_;}
234 {
return numberTotalWithoutFixed_;}
237 return & usefulArray_[index];
240 return const_cast<CoinPartitionedVector *
>(&usefulArray_[index]);
252 void setClpSimplexObjectiveValue();
258 void setupDualValuesPass(
const double * fakeDuals,
259 const double * fakePrimals,
266 {
return currentDualTolerance_;}
268 currentDualTolerance_ = value;
272 return abcNonLinearCost_;
276 {
return perturbationSaved_;}
279 {
return acceptablePivot_;}
282 {
return ordinaryVariables_;}
285 {
return numberOrdinary_;}
288 { numberOrdinary_=number;}
291 {
return currentDualBound_;}
294 return abcDualRowPivot_;
298 return abcPrimalColumnPivot_;
313 int internalFactorize(
int solveType);
333 void permuteOut(
int whatsWanted);
342 int computeDuals(
double * givenDjs, CoinIndexedVector * array1, CoinIndexedVector * array2);
344 int computePrimals (CoinIndexedVector * array1, CoinIndexedVector * array2);
346 void computeObjective ();
348 void setMultipleSequenceIn(
int sequenceIn[4]);
353 inline void unpack(CoinIndexedVector & rowArray)
const 354 {unpack(rowArray,sequenceIn_);}
358 void unpack(CoinIndexedVector & rowArray,
int sequence)
const;
366 void checkPrimalSolution(
bool justBasic);
369 void checkDualSolution();
372 void checkDualSolutionPlusFake();
374 void checkBothSolutions();
376 int gutsOfSolution(
int type);
378 int gutsOfPrimalSolution(
int type);
380 void saveGoodStatus();
382 void restoreGoodStatus(
int type);
383 #define rowUseScale_ scaleFromExternal_ 384 #define inverseRowUseScale_ scaleToExternal_ 390 void setupPointers(
int maxRows,
int maxColumns);
392 void copyFromSaved(
int type=31);
394 void fillPerturbation(
int start,
int number);
396 void checkArrays(
int ignoreEmpty=0)
const;
398 void checkDjs(
int type=1)
const;
400 void checkSolutionBasic()
const;
402 void checkMoveBack(
bool checkDuals);
414 void setValuesPassAction(
double incomingInfeasibility,
415 double allowedInfeasibility);
418 int cleanFactorization(
int ifValuesPass);
422 void moveStatusFromClp(
ClpSimplex * clpModel);
430 return (objectiveValue_+objectiveOffset_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[
ClpObjOffset];
435 return abcPivotVariable_;
439 {
return stateOfProblem_;}
442 { stateOfProblem_=value;}
452 {
return scaleFromExternal_;}
456 {
return scaleToExternal_;}
463 {
return inverseColumnUseScale_;}
465 {
return columnUseScale_;}
467 {
return arrayForDualColumn_;}
470 {
return upperTheta_;}
472 {
return arrayForReplaceColumn_;}
474 {
return arrayForFlipBounds_;}
476 {
return arrayForFlipRhs_;}
478 {
return arrayForBtran_;}
480 {
return arrayForFtran_;}
482 {
return arrayForTableauRow_;}
484 double valueIncomingDual()
const;
486 const double * getColSolution()
const;
489 const double * getRowPrice()
const;
492 const double * getReducedCost()
const;
496 const double * getRowActivity()
const;
504 int gutsOfSolution (
double * givenDuals,
505 const double * givenPrimals,
506 bool valuesPass =
false);
508 void gutsOfDelete(
int type);
512 void gutsOfInitialize(
int numberRows,
int numberColumns,
bool doMore);
514 void gutsOfResize(
int numberRows,
int numberColumns);
518 void translate(
int type);
520 void moveToBasic(
int which=15);
525 inline double * solutionRegion()
const {
543 return abcSolution_+which*maximumAbcNumberRows_;
546 return abcDj_+which*maximumAbcNumberRows_;
549 return abcLower_+which*maximumAbcNumberRows_;
552 return abcUpper_+which*maximumAbcNumberRows_;
555 return abcCost_+which*maximumAbcNumberRows_;
559 return solutionBasic_;
575 {
return abcPerturbation_;}
580 {
return internalStatus_;}
582 return static_cast<Status> (internalStatus_[sequence] & 7);
585 return static_cast<Status> (internalStatus_[sequence+maximumAbcNumberRows_] & 7);
588 unsigned char & st_byte = internalStatus_[sequence];
589 st_byte =
static_cast<unsigned char>(st_byte & ~7);
590 st_byte =
static_cast<unsigned char>(st_byte | newstatus);
593 unsigned char & st_byte = internalStatus_[sequence+maximumAbcNumberRows_];
594 st_byte =
static_cast<unsigned char>(st_byte & ~7);
595 st_byte =
static_cast<unsigned char>(st_byte | newstatus);
601 void setInitialDenseFactorization(
bool onOff);
602 bool initialDenseFactorization()
const;
612 sequenceIn_ = sequence;
615 sequenceOut_ = sequence;
619 inline int sequenceInternalIn()
const {
620 return sequenceInternalIn_;
622 inline int sequenceInternalOut()
const {
623 return sequenceInternalOut_;
626 inline void setSequenceInternalIn(
int sequence) {
627 sequenceInternalIn_ = sequence;
629 inline void setSequenceInternalOut(
int sequence) {
630 sequenceInternalOut_ = sequence;
633 inline int isColumn(
int sequence)
const {
635 return sequence >= maximumAbcNumberRows_ ? 1 : 0;
639 return sequence < maximumAbcNumberRows_ ? sequence : sequence - maximumAbcNumberRows_;
643 {
return lastPivotRow_;}
646 {
return firstFree_;}
649 {
return lastFirstFree_;}
652 {
return freeSequenceIn_;}
655 {
return currentAcceptablePivot_;}
664 if ((internalStatus_[iSequence]&7)==4)
666 if ((internalStatus_[iSequence]&7)!=5)
668 double value=abcSolution_[iSequence];
670 if(abcDj_[iSequence]>=-currentDualTolerance_) {
671 setInternalStatus(iSequence,atLowerBound);
673 printf(
"Pansetting %d to lb\n",iSequence);
680 if (abcDj_[iSequence]<=currentDualTolerance_) {
681 setInternalStatus(iSequence,atUpperBound);
683 printf(
"Pansetting %d to ub\n",iSequence);
694 inline double solution(
int sequence) {
696 return abcSolution_[sequence];
700 return abcSolution_[sequence];
703 return abcDj_[sequence];
706 return abcDj_[sequence];
709 return abcLower_[sequence];
713 return abcLower_[sequence];
716 return abcUpper_[sequence];
720 return abcUpper_[sequence];
722 inline double cost(
int sequence) {
723 return abcCost_[sequence];
727 return abcCost_[sequence];
731 if (iSequence < numberColumns_)
return columnLower_[iSequence];
733 return rowLower_[iSequence-numberColumns_];
737 if (iSequence < numberColumns_)
return columnUpper_[iSequence];
739 return rowUpper_[iSequence-numberColumns_];
743 {
return &abcProgress_;}
748 { clearArrays(which);}
752 {
return getAvailableArray();}
754 inline int parallelMode()
const 756 {
return parallelMode_;}
758 inline void setParallelMode(
int value)
759 { parallelMode_=value;}
761 inline int numberCpus()
const 762 {
return parallelMode_+1;}
764 inline void setStopStart(
int value)
771 void clearArrays(
int which);
773 void clearArrays(CoinPartitionedVector * which);
775 int getAvailableArray()
const;
778 {
int check=1<<which;assert ((stateOfProblem_&check)==0);stateOfProblem_|=check;}
781 {
int check=1<<which;assert ((stateOfProblem_&check)!=0);
782 assert (!usefulArray_[which].getNumElements());stateOfProblem_&=~check;}
784 void swapPrimalStuff();
786 void swapDualStuff(
int lastSequenceOut,
int lastDirectionOut);
791 void swap(
int pivotRow,
int nonBasicPosition,
Status newStatus);
794 unsigned char & st_byte = internalStatus_[sequence];
795 st_byte =
static_cast<unsigned char>(st_byte & ~24);
796 st_byte =
static_cast<unsigned char>(st_byte | (fakeBound << 3));
799 return static_cast<FakeBound> ((internalStatus_[sequence] >> 3) & 3);
801 bool atFakeBound(
int sequence)
const;
803 internalStatus_[sequence] =
static_cast<unsigned char>(internalStatus_[sequence] | 32);
806 internalStatus_[sequence] =
static_cast<unsigned char>(internalStatus_[sequence] & ~32);
809 return (((internalStatus_[sequence] >> 5) & 1) != 0);
813 void swap(
int pivotRow,
int nonBasicPosition);
815 void setFlagged(
int sequence);
817 internalStatus_[sequence] =
static_cast<unsigned char>(internalStatus_[sequence] & ~64);
820 return ((internalStatus_[sequence] & 64) != 0);
825 internalStatus_[iRow] =
static_cast<unsigned char>(internalStatus_[iRow] | 128);
828 internalStatus_[iRow] =
static_cast<unsigned char>(internalStatus_[iRow] & ~128);
831 return ((internalStatus_[iRow] & 128) != 0);
836 void createStatus() ;
838 void crash(
int type);
843 void putStuffInBasis(
int type);
846 void allSlackBasis();
848 void checkConsistentPivots()
const;
850 void printStuff()
const;
852 int startup(
int ifValuesPass);
856 return objectiveValue_;
859 void computeObjectiveValue(
bool useWorkingSolution =
false);
861 double computeInternalObjectiveValue();
863 void moveInfo(
const AbcSimplex & rhs,
bool justStatus =
false);
864 #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];}
874 {
return threadInfo_+thread;}
875 void startParallelStuff(
int type);
876 int stopParallelStuff(
int type);
878 int whichThread()
const;
879 #elif ABC_PARALLEL==2 889 void setObjectiveCoefficient(
int elementIndex,
double elementValue );
891 inline void setObjCoeff(
int elementIndex,
double elementValue ) {
892 setObjectiveCoefficient( elementIndex, elementValue);
897 void setColumnLower(
int elementIndex,
double elementValue );
901 void setColumnUpper(
int elementIndex,
double elementValue );
904 void setColumnBounds(
int elementIndex,
905 double lower,
double upper );
915 void setColumnSetBounds(
const int* indexFirst,
916 const int* indexLast,
917 const double* boundList);
921 inline void setColLower(
int elementIndex,
double elementValue ) {
922 setColumnLower(elementIndex, elementValue);
926 inline void setColUpper(
int elementIndex,
double elementValue ) {
927 setColumnUpper(elementIndex, elementValue);
932 double newlower,
double newupper ) {
933 setColumnBounds(elementIndex, newlower, newupper);
943 const int* indexLast,
944 const double* boundList) {
945 setColumnSetBounds(indexFirst, indexLast, boundList);
950 void setRowLower(
int elementIndex,
double elementValue );
954 void setRowUpper(
int elementIndex,
double elementValue ) ;
957 void setRowBounds(
int elementIndex,
958 double lower,
double upper ) ;
966 void setRowSetBounds(
const int* indexFirst,
967 const int* indexLast,
968 const double* boundList);
970 void resize (
int newNumberRows,
int newNumberColumns);
983 double sumNonBasicCosts_;
1017 #ifdef ABC_LONG_FACTORIZATION 1059 #define startAtLowerNoOther_ maximumAbcNumberRows_ 1060 int startAtLowerOther_;
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 1114 int numberOrdinary_;
1216 #ifdef EARLY_FACTORIZE 1220 #ifdef TEMPORARY_FACTORIZATION 1239 #define ABC_NUMBER_USEFUL 8 1248 int multipleSequenceIn_[4];
1264 pthread_barrier_t barrier_;
1269 #elif ABC_PARALLEL==2 double * costRegion(int which) const
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
double * djRegion(int which) const
int arrayForDualColumn() const
int maximumNumberTotal_
Maximum numberTotal.
int maximumAbcNumberRows() const
Maximum rows.
double originalLower(int iSequence) const
Return original lower bound.
unsigned char * internalStatusSaved_
Saved status.
int arrayForFlipBounds() const
bool pivoted(int sequence) const
double * offsetRhs_
Offset for accumulated offsets*matrix.
CoinPartitionedVector * usefulArray(int index) const
void setAvailableArray(int which) const
Say array going available.
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
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.
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.
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
int maximumAbcNumberColumns_
Maximum number columns.
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
unsigned char * internalStatus() const
void setUsedArray(int which) const
Say array going to be used.
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
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.
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.
int sequenceWithin(int sequence) const
Returns sequence number within section.
double * solutionBasic() const
Return region.
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
double primalTolerance_
Current primal tolerance for algorithm.
Base class for Clp disaster handling.
double * scaleFromExternal() const
Points from external to internal.
void setActive(int iRow)
To say row active in primal pivot row choice.
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 getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
double * perturbationSaved_
saved perturbation
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)
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
double originalUpper(int iSequence) const
Return original lower bound.
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
FakeBound getFakeBound(int sequence) const
int sequenceIn() const
Return sequence In or Out.
AbcSimplex::Status getInternalColumnStatus(int sequence) const
int numberTotal() const
Number of variables (includes spare rows)
double initialSumInfeasibilities_
Initial sum of infeasibilities.
double * inverseRowScale2() const
double * upperRegion() const
bool active(int iRow) const
double movement_
Movement of variable.
double * inverseColumnScale2() const
double * fakeDjs() const
Fake djs.
double upperTheta_
upper theta from dual column
int startFixed_
Start of fixed variables.
double * rowScale2() const
corresponds to rowScale etc
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
double * abcPerturbation() const
Perturbation.
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_
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. ...
double reducedCost(int sequence)
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
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 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 setSequenceOut(int sequence)
int arrayForFlipRhs() const
double & reducedCostAddress(int sequence)
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 clearFlagged(int sequence)
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.
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_)
Objective function constant.
This is a tiny class where data can be saved round calls.
int numberFreeNonBasic_
Number of free nonbasic variables.
int ordinaryVariables() const
Set to 1 if no free or super basic.
double * djRegion() const
int startAtUpperOther_
Start of variables at upper bound with lower.
AbcSimplex * abcBaseModel_
Saved version of solution.
double * columnScale2() const
AbcSimplexFactorization * abcFactorization_
factorization
double * costBasic() const
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
double * upperBasic() const
double * scaleFromExternal_
Points from external to internal.
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)
AbcTolerancesEtc & operator=(const AbcTolerancesEtc &rhs)
Assignment operator.
double * lowerBasic_
Working scaled copy of basic lower bounds.
int arrayForFtran() const
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.
AbcSimplex::Status getInternalStatus(int sequence) const
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.
double & upperAddress(int sequence)
Return address of row or column upper bound.
double * columnUseScale_
use this instead of columnScale
int freeSequenceIn() const
Free chosen vector.
int firstFree() const
First Free_.
void setSequenceIn(int sequence)
Set sequenceIn or Out.
int arrayForTableauRow() const
#define COLUMN_LOWER_SAME
double * djBasic_
Working scaled basic dual solution (want it to be zero)
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
double * solutionBasic_
Working scaled basic primal solution.
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
double cost(int sequence)
double * solutionRegion(int which) const
Return region.
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
double minimumThetaMovement_
Minimum theta movement.
double & costAddress(int sequence)
Return address of row or column cost.
void setPivoted(int sequence)
#define COLUMN_UPPER_SAME
int numberTotal_
Number of variables (includes spare rows)
void setStateOfProblem(int value)
State of problem.
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
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
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 * 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 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