Clp  1.16.11
AbcSimplex.hpp
Go to the documentation of this file.
1 /* $Id: AbcSimplex.hpp 2070 2014-11-18 11:12:54Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others, Copyright (C) 2012, FasterCoin. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 /*
6  Authors
7 
8  John Forrest
9 
10 */
11 #ifndef AbcSimplex_H
12 #define AbcSimplex_H
13 
14 #include <iostream>
15 #include <cfloat>
16 #include "ClpModel.hpp"
17 #include "ClpMatrixBase.hpp"
18 #include "CoinIndexedVector.hpp"
19 #include "AbcCommon.hpp"
20 class AbcSimplex;
21 #include "ClpSolve.hpp"
22 #include "CoinAbcCommon.hpp"
23 #include "ClpSimplex.hpp"
24 class AbcDualRowPivot;
27 class AbcNonLinearCost;
28 class OsiAbcSolverInterface;
29 class CoinWarmStartBasis;
30 class ClpDisasterHandler;
31 class AbcSimplexProgress;
32 class AbcMatrix;
33 class AbcTolerancesEtc;
34 
52 #define PAN
53 #if ABC_NORMAL_DEBUG>0
54 #define PRINT_PAN 1
55 #endif
56 #define TRY_ABC_GUS
57 #define HEAVY_PERTURBATION 57
58 #if ABC_PARALLEL==1
59 // Use pthreads
60 #include <pthread.h>
61 #endif
62 class AbcSimplex : public ClpSimplex {
63  friend void AbcSimplexUnitTest(const std::string & mpsDir);
64 
65 public:
74  enum Status {
75  atLowerBound = 0x00, // so we can use bottom two bits to sort and swap signs
76  atUpperBound = 0x01,
77  isFree = 0x04,
78  superBasic = 0x05,
79  basic = 0x06,
80  isFixed = 0x07
81  };
82  // For Dual
83  enum FakeBound {
84  noFake = 0x00,
85  lowerFake = 0x01,
86  upperFake = 0x02,
87  bothFake = 0x03
88  };
89 
92  AbcSimplex (bool emptyMessages = false );
94 
97  AbcSimplex(const AbcSimplex & rhs);
100  AbcSimplex(const ClpSimplex & rhs);
107  AbcSimplex (const ClpSimplex * wholeModel,
108  int numberRows, const int * whichRows,
109  int numberColumns, const int * whichColumns,
110  bool dropNames = true, bool dropIntegers = true,
111  bool fixOthers = false);
118  AbcSimplex (const AbcSimplex * wholeModel,
119  int numberRows, const int * whichRows,
120  int numberColumns, const int * whichColumns,
121  bool dropNames = true, bool dropIntegers = true,
122  bool fixOthers = false);
126  AbcSimplex (AbcSimplex * wholeModel,
127  int numberColumns, const int * whichColumns);
130  void originalModel(AbcSimplex * miniModel);
132  AbcSimplex (const ClpSimplex * clpSimplex);
134  void putBackSolution(ClpSimplex * simplex);
140  //void setPersistenceFlag(int value);
146  inline AbcSimplex * baseModel() const {
147  return abcBaseModel_;
148  }
152  void setToBaseModel(AbcSimplex * model = NULL);
158 
163  int dual();
164  int doAbcDual();
167  int primal(int ifValuesPass);
168  int doAbcPrimal(int ifValuesPass);
170  CoinWarmStartBasis * getBasis() const;
195 
198  inline AbcSimplexFactorization * factorization() const {
200  return reinterpret_cast<AbcSimplexFactorization *>(abcFactorization_);
201  }
202 #ifdef EARLY_FACTORIZE
203  inline AbcSimplexFactorization * earlyFactorization() const {
205  return reinterpret_cast<AbcSimplexFactorization *>(abcEarlyFactorization_);
206  }
207 #endif
208  int factorizationFrequency() const;
210  void setFactorizationFrequency(int value);
212  inline int maximumAbcNumberRows() const
213  { return maximumAbcNumberRows_;}
215  inline int maximumNumberTotal() const
216  { return maximumNumberTotal_;}
217  inline int maximumTotal() const
218  { return maximumNumberTotal_;}
222  inline int numberTotal() const
223  { return numberTotal_;}
225  inline int numberTotalWithoutFixed() const
226  { return numberTotalWithoutFixed_;}
228  inline CoinPartitionedVector * usefulArray(int index) {
229  return & usefulArray_[index];
230  }
231  inline CoinPartitionedVector * usefulArray(int index) const {
232  return const_cast<CoinPartitionedVector *>(&usefulArray_[index]);
233  }
235 
236  /******************** End of most useful part **************/
242  int getSolution ();
250  void setupDualValuesPass(const double * fakeDuals,
251  const double * fakePrimals,
252  int type);
254  inline double minimizationObjectiveValue() const
257  inline double currentDualTolerance() const
258  { return currentDualTolerance_;}
259  inline void setCurrentDualTolerance(double value) {
260  currentDualTolerance_ = value;
261  }
264  return abcNonLinearCost_;
265  }
267  double * perturbationSaved() const
268  { return perturbationSaved_;}
270  inline double acceptablePivot() const
271  { return acceptablePivot_;}
273  inline int ordinaryVariables() const
274  { return ordinaryVariables_;}
276  inline int numberOrdinary() const
277  { return numberOrdinary_;}
279  inline void setNumberOrdinary(int number)
280  { numberOrdinary_=number;}
282  inline double currentDualBound() const
283  { return currentDualBound_;}
285  inline AbcDualRowPivot * dualRowPivot() const {
286  return abcDualRowPivot_;
287  }
290  return abcPrimalColumnPivot_;
291  }
293  inline AbcMatrix * abcMatrix() const {
294  return abcMatrix_;
295  }
321  void permuteIn();
323  void permuteBasis();
325  void permuteOut(int whatsWanted);
331  void cleanStatus(bool valuesPass=false);
334  int computeDuals(double * givenDjs, CoinIndexedVector * array1, CoinIndexedVector * array2);
336  int computePrimals (CoinIndexedVector * array1, CoinIndexedVector * array2);
345  inline void unpack(CoinIndexedVector & rowArray) const
350  void unpack(CoinIndexedVector & rowArray, int sequence) const;
355  int housekeeping(/*double objectiveChange*/);
358  void checkPrimalSolution(bool justBasic);
368  int gutsOfSolution(int type);
370  int gutsOfPrimalSolution(int type);
374  void restoreGoodStatus(int type);
375 #define rowUseScale_ scaleFromExternal_
376 #define inverseRowUseScale_ scaleToExternal_
377  void refreshCosts();
379  void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME));
380  void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME));
382  void setupPointers(int maxRows,int maxColumns);
384  void copyFromSaved(int type=31);
386  void fillPerturbation(int start, int number);
388  void checkArrays(int ignoreEmpty=0) const;
390  void checkDjs(int type=1) const;
392  void checkSolutionBasic() const;
394  void checkMoveBack(bool checkDuals);
395 public:
406  void setValuesPassAction(double incomingInfeasibility,
407  double allowedInfeasibility);
410  int cleanFactorization(int ifValuesPass);
412  void moveStatusToClp(ClpSimplex * clpModel);
414  void moveStatusFromClp(ClpSimplex * clpModel);
416 
418 public:
419 
421  inline double clpObjectiveValue() const {
423  }
426  inline int * pivotVariable() const {
427  return abcPivotVariable_;
428  }
430  inline int stateOfProblem() const
431  { return stateOfProblem_;}
433  inline void setStateOfProblem(int value)
434  { stateOfProblem_=value;}
436  //inline int * fromExternal() const
437  //{ return fromExternal_;}
439  //inline int * toExternal() const
440  //{return toExternal_;}
443  inline double * scaleFromExternal() const
444  {return scaleFromExternal_;}
447  inline double * scaleToExternal() const
448  {return scaleToExternal_;}
450  inline double * rowScale2() const
451  {return rowUseScale_;}
452  inline double * inverseRowScale2() const
453  {return inverseRowUseScale_;}
454  inline double * inverseColumnScale2() const
455  {return inverseColumnUseScale_;}
456  inline double * columnScale2() const
457  {return columnUseScale_;}
458  inline int arrayForDualColumn() const
459  {return arrayForDualColumn_;}
461  inline double upperTheta() const
462  {return upperTheta_;}
463  inline int arrayForReplaceColumn() const
464  { return arrayForReplaceColumn_;}
465  inline int arrayForFlipBounds() const
466  { return arrayForFlipBounds_;}
467  inline int arrayForFlipRhs() const
468  { return arrayForFlipRhs_;}
469  inline int arrayForBtran() const
470  { return arrayForBtran_;}
471  inline int arrayForFtran() const
472  { return arrayForFtran_;}
473  inline int arrayForTableauRow() const
474  { return arrayForTableauRow_;}
476  double valueIncomingDual() const;
478  const double * getColSolution() const;
479 
481  const double * getRowPrice() const;
482 
484  const double * getReducedCost() const;
485 
488  const double * getRowActivity() const;
490 
496  int gutsOfSolution ( double * givenDuals,
497  const double * givenPrimals,
498  bool valuesPass = false);
500  void gutsOfDelete(int type);
502  void gutsOfCopy(const AbcSimplex & rhs);
504  void gutsOfInitialize(int numberRows,int numberColumns,bool doMore);
510  void translate(int type);
512  void moveToBasic(int which=15);
514 public:
517  inline double * solutionRegion() const {
519  return abcSolution_;
520  }
521  inline double * djRegion() const {
522  return abcDj_;
523  }
524  inline double * lowerRegion() const {
525  return abcLower_;
526  }
527  inline double * upperRegion() const {
528  return abcUpper_;
529  }
530  inline double * costRegion() const {
531  return abcCost_;
532  }
534  inline double * solutionRegion(int which) const {
535  return abcSolution_+which*maximumAbcNumberRows_;
536  }
537  inline double * djRegion(int which) const {
538  return abcDj_+which*maximumAbcNumberRows_;
539  }
540  inline double * lowerRegion(int which) const {
541  return abcLower_+which*maximumAbcNumberRows_;
542  }
543  inline double * upperRegion(int which) const {
544  return abcUpper_+which*maximumAbcNumberRows_;
545  }
546  inline double * costRegion(int which) const {
547  return abcCost_+which*maximumAbcNumberRows_;
548  }
550  inline double * solutionBasic() const {
551  return solutionBasic_;
552  }
553  inline double * djBasic() const {
554  return djBasic_;
555  }
556  inline double * lowerBasic() const {
557  return lowerBasic_;
558  }
559  inline double * upperBasic() const {
560  return upperBasic_;
561  }
562  inline double * costBasic() const {
563  return costBasic_;
564  }
566  inline double * abcPerturbation() const
567  { return abcPerturbation_;}
569  inline double * fakeDjs() const
570  { return djSaved_;}
571  inline unsigned char * internalStatus() const
572  { return internalStatus_;}
573  inline AbcSimplex::Status getInternalStatus(int sequence) const {
574  return static_cast<Status> (internalStatus_[sequence] & 7);
575  }
576  inline AbcSimplex::Status getInternalColumnStatus(int sequence) const {
577  return static_cast<Status> (internalStatus_[sequence+maximumAbcNumberRows_] & 7);
578  }
579  inline void setInternalStatus(int sequence, AbcSimplex::Status newstatus) {
580  unsigned char & st_byte = internalStatus_[sequence];
581  st_byte = static_cast<unsigned char>(st_byte & ~7);
582  st_byte = static_cast<unsigned char>(st_byte | newstatus);
583  }
584  inline void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus) {
585  unsigned char & st_byte = internalStatus_[sequence+maximumAbcNumberRows_];
586  st_byte = static_cast<unsigned char>(st_byte & ~7);
587  st_byte = static_cast<unsigned char>(st_byte | newstatus);
588  }
596  inline int sequenceIn() const {
597  return sequenceIn_;
598  }
599  inline int sequenceOut() const {
600  return sequenceOut_;
601  }
603  inline void setSequenceIn(int sequence) {
604  sequenceIn_ = sequence;
605  }
606  inline void setSequenceOut(int sequence) {
607  sequenceOut_ = sequence;
608  }
609 #if 0
610 
611  inline int sequenceInternalIn() const {
612  return sequenceInternalIn_;
613  }
614  inline int sequenceInternalOut() const {
615  return sequenceInternalOut_;
616  }
618  inline void setSequenceInternalIn(int sequence) {
619  sequenceInternalIn_ = sequence;
620  }
621  inline void setSequenceInternalOut(int sequence) {
622  sequenceInternalOut_ = sequence;
623  }
624 #endif
625  inline int isColumn(int sequence) const {
627  return sequence >= maximumAbcNumberRows_ ? 1 : 0;
628  }
630  inline int sequenceWithin(int sequence) const {
631  return sequence < maximumAbcNumberRows_ ? sequence : sequence - maximumAbcNumberRows_;
632  }
634  inline int lastPivotRow() const
635  { return lastPivotRow_;}
637  inline int firstFree() const
638  { return firstFree_;}
640  inline int lastFirstFree() const
641  { return lastFirstFree_;}
643  inline int freeSequenceIn() const
644  { return freeSequenceIn_;}
646  inline double currentAcceptablePivot() const
647  { return currentAcceptablePivot_;}
648 #ifdef PAN
649 
655  inline int fakeSuperBasic(int iSequence) {
656  if ((internalStatus_[iSequence]&7)==4)
657  return 0; // free
658  if ((internalStatus_[iSequence]&7)!=5)
659  return -2;
660  double value=abcSolution_[iSequence];
661  if (value<abcLower_[iSequence]+primalTolerance_) {
662  if(abcDj_[iSequence]>=-currentDualTolerance_) {
663  setInternalStatus(iSequence,atLowerBound);
664 #if PRINT_PAN>1
665  printf("Pansetting %d to lb\n",iSequence);
666 #endif
667  return -1;
668  } else {
669  return 1;
670  }
671  } else if (value>abcUpper_[iSequence]-primalTolerance_) {
672  if (abcDj_[iSequence]<=currentDualTolerance_) {
673  setInternalStatus(iSequence,atUpperBound);
674 #if PRINT_PAN>1
675  printf("Pansetting %d to ub\n",iSequence);
676 #endif
677  return -1;
678  } else {
679  return 1;
680  }
681  } else {
682  return 0;
683  }
684  }
685 #endif
686  inline double solution(int sequence) {
688  return abcSolution_[sequence];
689  }
691  inline double & solutionAddress(int sequence) {
692  return abcSolution_[sequence];
693  }
694  inline double reducedCost(int sequence) {
695  return abcDj_[sequence];
696  }
697  inline double & reducedCostAddress(int sequence) {
698  return abcDj_[sequence];
699  }
700  inline double lower(int sequence) {
701  return abcLower_[sequence];
702  }
704  inline double & lowerAddress(int sequence) {
705  return abcLower_[sequence];
706  }
707  inline double upper(int sequence) {
708  return abcUpper_[sequence];
709  }
711  inline double & upperAddress(int sequence) {
712  return abcUpper_[sequence];
713  }
714  inline double cost(int sequence) {
715  return abcCost_[sequence];
716  }
718  inline double & costAddress(int sequence) {
719  return abcCost_[sequence];
720  }
722  inline double originalLower(int iSequence) const {
723  if (iSequence < numberColumns_) return columnLower_[iSequence];
724  else
725  return rowLower_[iSequence-numberColumns_];
726  }
728  inline double originalUpper(int iSequence) const {
729  if (iSequence < numberColumns_) return columnUpper_[iSequence];
730  else
731  return rowUpper_[iSequence-numberColumns_];
732  }
734  inline AbcSimplexProgress * abcProgress()
735  { return &abcProgress_;}
736 #ifdef ABC_SPRINT
737  AbcSimplex * createSubProblem(int numberColumns,const int * whichColumn);
740  void restoreFromSubProblem(AbcSimplex * fullProblem, const int * whichColumn);
741 #endif
742 public:
745  inline void clearArraysPublic(int which)
746  { clearArrays(which);}
749  inline int getAvailableArrayPublic() const
750  { return getAvailableArray();}
751 #if ABC_PARALLEL
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;}
761 #if ABC_PARALLEL==1
762  inline void setStopStart(int value)
764  { stopStart_=value;}
765 #endif
766 #endif
767  //protected:
769  void clearArrays(int which);
771  void clearArrays(CoinPartitionedVector * which);
773  int getAvailableArray() const;
775  inline void setUsedArray(int which) const
776  {int check=1<<which;assert ((stateOfProblem_&check)==0);stateOfProblem_|=check;}
778  inline void setAvailableArray(int which) const
779  {int check=1<<which;assert ((stateOfProblem_&check)!=0);
780  assert (!usefulArray_[which].getNumElements());stateOfProblem_&=~check;}
784  void swapDualStuff(int lastSequenceOut,int lastDirectionOut);
785 protected:
787 
789  void swap(int pivotRow,int nonBasicPosition,Status newStatus);
791  inline void setFakeBound(int sequence, FakeBound fakeBound) {
792  unsigned char & st_byte = internalStatus_[sequence];
793  st_byte = static_cast<unsigned char>(st_byte & ~24);
794  st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3));
795  }
796  inline FakeBound getFakeBound(int sequence) const {
797  return static_cast<FakeBound> ((internalStatus_[sequence] >> 3) & 3);
798  }
799  bool atFakeBound(int sequence) const;
800  inline void setPivoted( int sequence) {
801  internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] | 32);
802  }
803  inline void clearPivoted( int sequence) {
804  internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~32);
805  }
806  inline bool pivoted(int sequence) const {
807  return (((internalStatus_[sequence] >> 5) & 1) != 0);
808  }
809 public:
811  void swap(int pivotRow,int nonBasicPosition);
813  void setFlagged( int sequence);
814  inline void clearFlagged( int sequence) {
815  internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~64);
816  }
817  inline bool flagged(int sequence) const {
818  return ((internalStatus_[sequence] & 64) != 0);
819  }
820 protected:
822  inline void setActive( int iRow) {
823  internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] | 128);
824  }
825  inline void clearActive( int iRow) {
826  internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] & ~128);
827  }
828  inline bool active(int iRow) const {
829  return ((internalStatus_[iRow] & 128) != 0);
830  }
831 public:
834  void createStatus() ;
836  void crash(int type);
841  void putStuffInBasis(int type);
846  void checkConsistentPivots() const;
848  void printStuff() const;
850  int startup(int ifValuesPass);
851 
853  inline double rawObjectiveValue() const {
854  return objectiveValue_;
855  }
857  void computeObjectiveValue(bool useWorkingSolution = false);
861  void moveInfo(const AbcSimplex & rhs, bool justStatus = false);
862 #ifndef NUMBER_THREADS
863 #define NUMBER_THREADS 3
864 #endif
865 #if ABC_PARALLEL==1
866  // For waking up thread
867  inline pthread_mutex_t * mutexPointer(int which,int thread=0)
868  { return mutex_+which+3*thread;}
869  inline pthread_barrier_t * barrierPointer()
870  { return &barrier_;}
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
880  //inline CoinThreadInfo * threadInfoPointer(int thread=0)
881  //{ return threadInfo_+thread;}
882 #endif
883 
884 
885  //-------------------------------------------------------------------------
889  void setObjectiveCoefficient( int elementIndex, double elementValue );
891  inline void setObjCoeff( int elementIndex, double elementValue ) {
892  setObjectiveCoefficient( elementIndex, elementValue);
893  }
894 
897  void setColumnLower( int elementIndex, double elementValue );
898 
901  void setColumnUpper( int elementIndex, double elementValue );
902 
904  void setColumnBounds( int elementIndex,
905  double lower, double upper );
906 
915  void setColumnSetBounds(const int* indexFirst,
916  const int* indexLast,
917  const double* boundList);
918 
921  inline void setColLower( int elementIndex, double elementValue ) {
922  setColumnLower(elementIndex, elementValue);
923  }
926  inline void setColUpper( int elementIndex, double elementValue ) {
927  setColumnUpper(elementIndex, elementValue);
928  }
929 
931  inline void setColBounds( int elementIndex,
932  double newlower, double newupper ) {
933  setColumnBounds(elementIndex, newlower, newupper);
934  }
935 
942  inline void setColSetBounds(const int* indexFirst,
943  const int* indexLast,
944  const double* boundList) {
945  setColumnSetBounds(indexFirst, indexLast, boundList);
946  }
947 
950  void setRowLower( int elementIndex, double elementValue );
951 
954  void setRowUpper( int elementIndex, double elementValue ) ;
955 
957  void setRowBounds( int elementIndex,
958  double lower, double upper ) ;
959 
966  void setRowSetBounds(const int* indexFirst,
967  const int* indexLast,
968  const double* boundList);
970  void resize (int newNumberRows, int newNumberColumns);
971 
973 
975 protected:
976 
983  double sumNonBasicCosts_;
999  double largestGap_;
1011  double movement_;
1015  double btranAlpha_;
1017 #ifdef ABC_LONG_FACTORIZATION
1018  long
1019 #endif
1020  double ftAlpha_;
1025 public:
1028 protected:
1049  /*
1050  May want to put some arrays into struct
1051  Two arrays point to/from external
1052  Order is basic,unused basic, at lower, at upper, superbasic, free, fixed with starts
1053  */
1059 #define startAtLowerNoOther_ maximumAbcNumberRows_
1060  int startAtLowerOther_;
1070 #ifdef EARLY_FACTORIZE
1071  int numberEarly_;
1073 #endif
1074 
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
1107  mutable int stateOfProblem_;
1108 #if ABC_PARALLEL
1109 public:
1111  int parallelMode_;
1112 protected:
1113 #endif
1114  int numberOrdinary_;
1129  //int * fromExternal_;
1131  //int * toExternal_;
1145  double * offset_;
1147  double * offsetRhs_;
1149  double * tempArray_;
1154  unsigned char * internalStatus_;
1156  unsigned char * internalStatusSaved_;
1168  double * abcLower_;
1171  double * abcUpper_;
1177  double * abcCost_;
1180  double * abcSolution_;
1183  double * abcDj_;
1185  double * lowerSaved_;
1187  double * upperSaved_;
1189  double * costSaved_;
1191  double * solutionSaved_;
1193  double * djSaved_;
1195  double * lowerBasic_;
1197  double * upperBasic_;
1199  double * costBasic_;
1201  double * solutionBasic_;
1203  double * djBasic_;
1216 #ifdef EARLY_FACTORIZE
1217  AbcSimplexFactorization * abcEarlyFactorization_;
1219 #endif
1220 #ifdef TEMPORARY_FACTORIZATION
1221  AbcSimplexFactorization * abcOtherFactorization_;
1223 #endif
1224  //double * savedSolution_;
1236  /* has secondary offset and counts so row goes first then column
1237  Probably back to CoinPartitionedVector as AbcMatrix has slacks
1238  also says if in use - so we can just get next available one */
1239 #define ABC_NUMBER_USEFUL 8
1240  mutable CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL];
1242  AbcSimplexProgress abcProgress_;
1246  double upperTheta_;
1249 public:
1253  int arrayForFlipRhs_; // if sequential can re-use
1254  int arrayForBtran_; // 0
1255  int arrayForFtran_; // 1
1257 protected:
1260  //int nextCleanNonBasicIteration_;
1261 #if ABC_PARALLEL==1
1262  // For waking up thread
1263  pthread_mutex_t mutex_[3*NUMBER_THREADS];
1264  pthread_barrier_t barrier_;
1265  CoinThreadInfo threadInfo_[NUMBER_THREADS];
1266  pthread_t abcThread_[NUMBER_THREADS];
1267  int locked_[NUMBER_THREADS];
1268  int stopStart_;
1269 #elif ABC_PARALLEL==2
1270  //CoinThreadInfo threadInfo_[NUMBER_THREADS];
1271 #endif
1272 
1273 };
1274 //#############################################################################
1283 void
1284 AbcSimplexUnitTest(const std::string & mpsDir);
1285 #endif
ClpSimplex
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
AbcSimplex::refreshCosts
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
AbcSimplex::upperFake
@ upperFake
Definition: AbcSimplex.hpp:86
AbcSimplex::arrayForFlipBounds_
int arrayForFlipBounds_
Definition: AbcSimplex.hpp:1252
AbcSimplex::costBasic_
double * costBasic_
Working scaled copy of basic objective.
Definition: AbcSimplex.hpp:1199
AbcSimplex::solutionRegion
double * solutionRegion() const
Return region.
Definition: AbcSimplex.hpp:518
COLUMN_UPPER_SAME
#define COLUMN_UPPER_SAME
Definition: ClpModel.hpp:1210
AbcSimplex::startup
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
ClpObjOffset
@ ClpObjOffset
Objective function constant.
Definition: ClpParameters.hpp:60
inverseRowUseScale_
#define inverseRowUseScale_
Definition: AbcSimplex.hpp:376
AbcSimplex::saveGoodStatus
void saveGoodStatus()
Saves good status etc.
AbcSimplex::usefulArray_
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
Definition: AbcSimplex.hpp:1240
AbcSimplex::valueIncomingDual
double valueIncomingDual() const
value of incoming variable (in Dual)
AbcSimplex::moveStatusFromClp
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
ClpSimplex::firstFree_
int firstFree_
First free/super-basic variable (-1 if none)
Definition: ClpSimplex.hpp:1666
AbcSimplex::upperBasic_
double * upperBasic_
Working scaled copy of basic upper bounds.
Definition: AbcSimplex.hpp:1197
AbcSimplex::permuteBasis
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
AbcSimplex::dualRowPivot
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
Definition: AbcSimplex.hpp:285
AbcSimplex::lastPivotRow
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
Definition: AbcSimplex.hpp:634
AbcSimplex::crash
void crash(int type)
Does sort of crash.
AbcSimplex::numberTotalWithoutFixed_
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows)
Definition: AbcSimplex.hpp:1057
AbcSimplex::abcPivotVariable_
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed.
Definition: AbcSimplex.hpp:1211
AbcSimplex::rowScale2
double * rowScale2() const
corresponds to rowScale etc
Definition: AbcSimplex.hpp:450
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index) const
Definition: AbcSimplex.hpp:231
AbcSimplex::setObjCoeff
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
Definition: AbcSimplex.hpp:891
ClpModel::columnUpper_
double * columnUpper_
Column Upper.
Definition: ClpModel.hpp:1146
AbcSimplex::upperRegion
double * upperRegion(int which) const
Definition: AbcSimplex.hpp:543
AbcSimplex::ordinaryVariables
int ordinaryVariables() const
Set to 1 if no free or super basic.
Definition: AbcSimplex.hpp:273
AbcSimplex::getEmptyFactorization
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
ClpSimplex::rowArray
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
Definition: ClpSimplex.hpp:727
AbcSimplex::solution
double solution(int sequence)
Return row or column values.
Definition: AbcSimplex.hpp:687
AbcSimplex::reducedCost
double reducedCost(int sequence)
Definition: AbcSimplex.hpp:694
AbcSimplex::swap
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
AbcSimplex::checkBothSolutions
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
AbcSimplex::abcNonLinearCost
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
Definition: AbcSimplex.hpp:263
ClpModel::solveType
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
Definition: ClpModel.hpp:373
AbcSimplex::upperRegion
double * upperRegion() const
Definition: AbcSimplex.hpp:527
AbcSimplex::offset_
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
Definition: AbcSimplex.hpp:1145
AbcSimplex::columnUseScale_
double * columnUseScale_
use this instead of columnScale
Definition: AbcSimplex.hpp:1139
AbcSimplex::isColumn
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
Definition: AbcSimplex.hpp:626
AbcSimplex::AbcSimplex
AbcSimplex(const AbcSimplex &rhs)
Copy constructor.
AbcSimplex::lastPivotRow_
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual)
Definition: AbcSimplex.hpp:1123
AbcSimplex::solutionRegion
double * solutionRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:534
AbcSimplex::cleanStatus
void cleanStatus(bool valuesPass=false)
Clean up status - make sure no superbasic etc.
AbcSimplex::getColSolution
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
AbcSimplex::solutionAddress
double & solutionAddress(int sequence)
Return address of row or column values.
Definition: AbcSimplex.hpp:691
AbcSimplex::arrayForReplaceColumn_
int arrayForReplaceColumn_
Definition: AbcSimplex.hpp:1251
AbcSimplex::startOther_
int startOther_
Start of superBasic, free or awkward bounds variables.
Definition: AbcSimplex.hpp:1067
AbcSimplex::sequenceOut
int sequenceOut() const
Definition: AbcSimplex.hpp:599
AbcSimplex::permuteIn
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
AbcSimplex::firstFree
int firstFree() const
First Free_.
Definition: AbcSimplex.hpp:637
AbcSimplex::scaleToExternal
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual.
Definition: AbcSimplex.hpp:447
AbcSimplex::primalColumnPivot
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
Definition: AbcSimplex.hpp:289
AbcSimplex::clearPivoted
void clearPivoted(int sequence)
Definition: AbcSimplex.hpp:803
AbcSimplex::housekeeping
int housekeeping()
This does basis housekeeping and does values for in/out variables.
AbcSimplex::gutsOfSolution
int gutsOfSolution(double *givenDuals, const double *givenPrimals, bool valuesPass=false)
May change basis and then returns number changed.
AbcSimplex::inverseColumnScale2
double * inverseColumnScale2() const
Definition: AbcSimplex.hpp:454
AbcSimplex::checkDualSolutionPlusFake
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
AbcSimplex::AbcSimplex
AbcSimplex(AbcSimplex *wholeModel, int numberColumns, const int *whichColumns)
This constructor modifies original AbcSimplex and stores original stuff in created AbcSimplex.
AbcSimplex::gutsOfInitialize
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
AbcSimplex::active
bool active(int iRow) const
Definition: AbcSimplex.hpp:828
ClpModel::columnLower_
double * columnLower_
Column Lower.
Definition: ClpModel.hpp:1144
AbcSimplex::putBackSolution
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
AbcSimplex::createStatus
void createStatus()
Set up status array (can be used by OsiAbc).
AbcSimplex::objectiveChange_
double objectiveChange_
Objective change.
Definition: AbcSimplex.hpp:1013
AbcSimplex::setColBounds
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
Definition: AbcSimplex.hpp:931
AbcSimplex::AbcSimplexUnitTest
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
AbcSimplex::acceptablePivot
double acceptablePivot() const
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:270
AbcSimplex::internalStatus
unsigned char * internalStatus() const
Definition: AbcSimplex.hpp:571
AbcSimplex::lastFirstFree
int lastFirstFree() const
Last firstFree_.
Definition: AbcSimplex.hpp:640
AbcSimplex::numberFlagged_
int numberFlagged_
Current number of variables flagged.
Definition: AbcSimplex.hpp:1040
AbcSimplex::swapFactorization
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
AbcSimplex::maximumNumberTotal_
int maximumNumberTotal_
Maximum numberTotal.
Definition: AbcSimplex.hpp:1038
AbcSimplex::cost
double cost(int sequence)
Definition: AbcSimplex.hpp:714
ClpDataSave
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1269
AbcSimplex::abcCost_
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
Definition: AbcSimplex.hpp:1177
AbcSimplex::swapPrimalStuff
void swapPrimalStuff()
Swaps primal stuff.
AbcSimplex::originalLower
double originalLower(int iSequence) const
Return original lower bound.
Definition: AbcSimplex.hpp:722
AbcSimplex::checkDjs
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well)
AbcSimplex::numberOrdinary_
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:1115
AbcSimplex::inverseRowScale2
double * inverseRowScale2() const
Definition: AbcSimplex.hpp:452
AbcSimplex::rawObjectiveValue
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
Definition: AbcSimplex.hpp:853
AbcSimplex::btranAlpha_
double btranAlpha_
Btran alpha.
Definition: AbcSimplex.hpp:1015
AbcSimplex::atUpperBound
@ atUpperBound
Definition: AbcSimplex.hpp:76
AbcSimplex::arrayForReplaceColumn
int arrayForReplaceColumn() const
Definition: AbcSimplex.hpp:463
AbcSimplex::currentDualBound
double currentDualBound() const
Current dualBound (will end up as dualBound_)
Definition: AbcSimplex.hpp:282
AbcSimplex::lowerBasic
double * lowerBasic() const
Definition: AbcSimplex.hpp:556
AbcSimplex::setDualRowPivotAlgorithm
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
AbcSimplex::tightenPrimalBounds
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
AbcSimplex::fakeSuperBasic
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...
Definition: AbcSimplex.hpp:655
AbcSimplex::arrayForFlipRhs
int arrayForFlipRhs() const
Definition: AbcSimplex.hpp:467
AbcSimplex::lastDualError_
double lastDualError_
Last dual error.
Definition: AbcSimplex.hpp:1007
AbcSimplex::atLowerBound
@ atLowerBound
Definition: AbcSimplex.hpp:75
AbcSimplex::abcPerturbation
double * abcPerturbation() const
Perturbation.
Definition: AbcSimplex.hpp:566
AbcSimplex::abcSolution_
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
Definition: AbcSimplex.hpp:1180
AbcSimplex::moveStatusToClp
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
AbcSimplex::unpack
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
Definition: AbcSimplex.hpp:345
AbcSimplex::upperTheta_
double upperTheta_
upper theta from dual column
Definition: AbcSimplex.hpp:1246
AbcSimplex::setFactorizationFrequency
void setFactorizationFrequency(int value)
AbcSimplex::checkArrays
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
AbcNonLinearCost
Definition: AbcNonLinearCost.hpp:72
ClpMatrixBase.hpp
AbcSimplex::clearArrays
void clearArrays(CoinPartitionedVector *which)
Clears an array and says available.
AbcSimplex::gutsOfDelete
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
AbcSimplex::reducedCostAddress
double & reducedCostAddress(int sequence)
Definition: AbcSimplex.hpp:697
AbcSimplex::setCurrentDualTolerance
void setCurrentDualTolerance(double value)
Definition: AbcSimplex.hpp:259
AbcSimplex::setToBaseModel
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
AbcSimplex::clearFlagged
void clearFlagged(int sequence)
Definition: AbcSimplex.hpp:814
AbcSimplex::makeBaseModel
void makeBaseModel()
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
AbcSimplex::costSaved_
double * costSaved_
Saved scaled copy of objective.
Definition: AbcSimplex.hpp:1189
AbcSimplex::isFixed
@ isFixed
Definition: AbcSimplex.hpp:80
AbcSimplex::arrayForBtran_
int arrayForBtran_
Definition: AbcSimplex.hpp:1254
AbcSimplex::abcNonLinearCost_
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
Definition: AbcSimplex.hpp:1234
ClpModel.hpp
AbcSimplex::setFakeBound
void setFakeBound(int sequence, FakeBound fakeBound)
Definition: AbcSimplex.hpp:791
AbcSimplex::setAvailableArray
void setAvailableArray(int which) const
Say array going available.
Definition: AbcSimplex.hpp:778
AbcSimplex::unpack
void unpack(CoinIndexedVector &rowArray, int sequence) const
Unpacks one column of the matrix into indexed array.
AbcSimplex::lastDualBound_
double lastDualBound_
Last dual bound.
Definition: AbcSimplex.hpp:1001
AbcSimplex::internalStatusSaved_
unsigned char * internalStatusSaved_
Saved status.
Definition: AbcSimplex.hpp:1156
AbcSimplex::costBasic
double * costBasic() const
Definition: AbcSimplex.hpp:562
ROW_LOWER_SAME
#define ROW_LOWER_SAME
Definition: ClpModel.hpp:1206
AbcSimplex::lowerBasic_
double * lowerBasic_
Working scaled copy of basic lower bounds.
Definition: AbcSimplex.hpp:1195
ClpSimplex::bestPossibleImprovement_
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
Definition: ClpSimplex.hpp:1499
ClpModel::getNumElements
int getNumElements() const
Number of elements in matrix.
Definition: ClpModel.hpp:702
AbcSimplex::costRegion
double * costRegion(int which) const
Definition: AbcSimplex.hpp:546
AbcSimplex::setNumberOrdinary
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:279
AbcSimplex::lastCleaned_
int lastCleaned_
Last time cleaned up.
Definition: AbcSimplex.hpp:1121
AbcSimplex::swap
void swap(int pivotRow, int nonBasicPosition)
Swaps two variables.
AbcSimplex::bothFake
@ bothFake
Definition: AbcSimplex.hpp:87
AbcSimplex::refreshUpper
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
AbcSimplex::getAvailableArray
int getAvailableArray() const
Returns first available empty array (and sets flag)
ClpModel::optimizationDirection_
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: ClpModel.hpp:1112
AbcSimplex::checkPrimalSolution
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal)
AbcSimplex::allSlackBasis
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
AbcSimplex::stateOfProblem_
int stateOfProblem_
Definition: AbcSimplex.hpp:1107
AbcSimplex::clearArraysPublic
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
Definition: AbcSimplex.hpp:745
AbcSimplex::restoreGoodStatus
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
AbcSimplex::getFakeBound
FakeBound getFakeBound(int sequence) const
Definition: AbcSimplex.hpp:796
AbcSimplex::solutionSaved_
double * solutionSaved_
Saved scaled primal solution.
Definition: AbcSimplex.hpp:1191
AbcSimplex::setColUpper
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
Definition: AbcSimplex.hpp:926
AbcSimplex::stateOfIteration_
int stateOfIteration_
Where we are in iteration.
Definition: AbcSimplex.hpp:1027
ClpSimplex::sequenceIn_
int sequenceIn_
Sequence of In variable.
Definition: ClpSimplex.hpp:1588
AbcSimplex::tempArray_
double * tempArray_
Useful array of numberTotal length.
Definition: AbcSimplex.hpp:1149
AbcSimplex::maximumNumberTotal
int maximumNumberTotal() const
Maximum Total.
Definition: AbcSimplex.hpp:215
AbcSimplex::lowerFake
@ lowerFake
Definition: AbcSimplex.hpp:85
AbcSimplex::arrayForDualColumn
int arrayForDualColumn() const
Definition: AbcSimplex.hpp:458
AbcSimplex::reversePivotVariable_
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
Definition: AbcSimplex.hpp:1213
AbcSimplex::ftAlpha_
double ftAlpha_
FT alpha.
Definition: AbcSimplex.hpp:1020
AbcSimplex::translate
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
AbcSimplex::saveData
ClpDataSave saveData()
Save data.
AbcSimplex::refreshLower
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
AbcSimplex::isFree
@ isFree
Definition: AbcSimplex.hpp:77
AbcSimplex::maximumAbcNumberRows_
int maximumAbcNumberRows_
Maximum number rows.
Definition: AbcSimplex.hpp:1034
AbcSimplex::pivotVariable
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert.
Definition: AbcSimplex.hpp:426
AbcSimplex::moveToBasic
void moveToBasic(int which=15)
Moves basic stuff to basic area.
AbcSimplex::upperBasic
double * upperBasic() const
Definition: AbcSimplex.hpp:559
AbcSimplex::isObjectiveLimitTestValid
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
AbcSimplex::fakeDjs
double * fakeDjs() const
Fake djs.
Definition: AbcSimplex.hpp:569
AbcCommon.hpp
AbcSimplex::AbcSimplex
AbcSimplex(const ClpSimplex &rhs)
Copy constructor from model.
ClpDisasterHandler
Base class for Clp disaster handling.
Definition: ClpEventHandler.hpp:134
AbcSimplex::resize
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
AbcSimplexFactorization
This just implements AbcFactorization when an AbcMatrix object is passed.
Definition: AbcSimplexFactorization.hpp:28
AbcSimplex::arrayForFtran_
int arrayForFtran_
Definition: AbcSimplex.hpp:1255
AbcSimplex::setRowUpper
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
AbcSimplex::initialSumInfeasibilities_
double initialSumInfeasibilities_
Initial sum of infeasibilities.
Definition: AbcSimplex.hpp:1024
AbcSimplex::setRowLower
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
AbcSimplex::numberFreeNonBasic_
int numberFreeNonBasic_
Number of free nonbasic variables.
Definition: AbcSimplex.hpp:1119
AbcSimplex::setColumnSetBounds
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...
AbcSimplex::startAtLowerOther_
int startAtLowerOther_
Start of variables at lower bound with upper.
Definition: AbcSimplex.hpp:1061
AbcSimplex::upperSaved_
double * upperSaved_
Saved scaled copy of upper bounds.
Definition: AbcSimplex.hpp:1187
AbcSimplex::~AbcSimplex
~AbcSimplex()
Destructor.
AbcSimplex::AbcSimplex
AbcSimplex(bool emptyMessages=false)
Default constructor.
AbcSimplex::AbcSimplex
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.
AbcSimplex::getSolution
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
AbcSimplex::flagged
bool flagged(int sequence) const
Definition: AbcSimplex.hpp:817
AbcSimplex::computePrimals
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
AbcSimplex::AbcSimplex
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.
AbcSimplex::abcPrimalColumnPivot_
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
Definition: AbcSimplex.hpp:1207
AbcSimplex::costRegion
double * costRegion() const
Definition: AbcSimplex.hpp:530
AbcSimplex::setupPointers
void setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
ClpModel::numberColumns_
int numberColumns_
Number of columns.
Definition: ClpModel.hpp:1126
AbcSimplex::abcBaseModel_
AbcSimplex * abcBaseModel_
Saved version of solution.
Definition: AbcSimplex.hpp:1227
AbcSimplex::lowerRegion
double * lowerRegion(int which) const
Definition: AbcSimplex.hpp:540
AbcSimplex::getRowPrice
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
AbcSimplex::upperAddress
double & upperAddress(int sequence)
Return address of row or column upper bound.
Definition: AbcSimplex.hpp:711
AbcSimplex::FakeBound
FakeBound
Definition: AbcSimplex.hpp:83
AbcSimplex::costAddress
double & costAddress(int sequence)
Return address of row or column cost.
Definition: AbcSimplex.hpp:718
AbcSimplex::lastFirstFree_
int lastFirstFree_
Last firstFree_.
Definition: AbcSimplex.hpp:1030
AbcSimplex::setColumnUpper
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
AbcDualRowPivot
Dual Row Pivot Abstract Base Class.
Definition: AbcDualRowPivot.hpp:23
AbcSimplex::setFactorization
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
AbcSimplex::checkMoveBack
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs)
AbcSimplex::setUsedArray
void setUsedArray(int which) const
Say array going to be used.
Definition: AbcSimplex.hpp:775
AbcSimplex::abcMatrix
AbcMatrix * abcMatrix() const
Abc Matrix.
Definition: AbcSimplex.hpp:293
AbcSimplex::gutsOfPrimalSolution
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
ClpSimplex.hpp
AbcSimplex::setSequenceOut
void setSequenceOut(int sequence)
Definition: AbcSimplex.hpp:606
ClpSimplex::acceptablePivot_
double acceptablePivot_
Acceptable pivot value just after factorization.
Definition: ClpSimplex.hpp:1559
AbcSimplex::setRowBounds
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
AbcSimplex::superBasic
@ superBasic
Definition: AbcSimplex.hpp:78
AbcSimplex::lowerRegion
double * lowerRegion() const
Definition: AbcSimplex.hpp:524
AbcSimplex::internalStatus_
unsigned char * internalStatus_
Working status ? may be signed ? link pi_ to an indexed array? may have saved from last factorization...
Definition: AbcSimplex.hpp:1154
AbcSimplex::freeSequenceIn
int freeSequenceIn() const
Free chosen vector.
Definition: AbcSimplex.hpp:643
AbcSimplex::rawObjectiveValue_
double rawObjectiveValue_
Sum of costs (raw objective value)
Definition: AbcSimplex.hpp:986
AbcSimplex::computeObjective
void computeObjective()
Computes nonbasic cost and total cost.
AbcSimplex::abcProgress_
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
Definition: AbcSimplex.hpp:1242
AbcSimplex::primal
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
AbcSimplex::permuteOut
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
AbcSimplex::computeObjectiveValue
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
AbcSimplex::setObjectiveCoefficient
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
ClpSimplex::primalTolerance_
double primalTolerance_
Current primal tolerance for algorithm.
Definition: ClpSimplex.hpp:1547
AbcSimplex::abcLower_
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
Definition: AbcSimplex.hpp:1168
AbcMatrix
Definition: AbcMatrix.hpp:22
AbcSimplex::deleteBaseModel
void deleteBaseModel()
Switch off base model.
AbcSimplex::copyFromSaved
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
AbcSimplex::solutionBasic
double * solutionBasic() const
Return region.
Definition: AbcSimplex.hpp:550
ClpModel::objectiveValue_
double objectiveValue_
Objective value.
Definition: ClpModel.hpp:1116
AbcSimplex::sumNonBasicCosts_
double sumNonBasicCosts_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:984
rowUseScale_
#define rowUseScale_
Definition: AbcSimplex.hpp:375
AbcSimplexUnitTest
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
AbcSimplex::factorizationFrequency
int factorizationFrequency() const
Factorization frequency.
AbcSimplex::arrayForFtran
int arrayForFtran() const
Definition: AbcSimplex.hpp:471
AbcSimplex::originalUpper
double originalUpper(int iSequence) const
Return original lower bound.
Definition: AbcSimplex.hpp:728
AbcSimplex::setPrimalColumnPivotAlgorithm
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
AbcSimplex::noFake
@ noFake
Definition: AbcSimplex.hpp:84
AbcSimplex
Definition: AbcSimplex.hpp:62
ClpSolve.hpp
AbcSimplex::baseModel
AbcSimplex * baseModel() const
See if we have base model.
Definition: AbcSimplex.hpp:146
AbcSimplex::cleanFactorization
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
AbcSimplex::factorization
AbcSimplexFactorization * factorization() const
factorization
Definition: AbcSimplex.hpp:199
AbcSimplex::abcMatrix_
AbcMatrix * abcMatrix_
Working matrix.
Definition: AbcSimplex.hpp:1165
AbcSimplex::upper
double upper(int sequence)
Definition: AbcSimplex.hpp:707
AbcSimplex::doAbcDual
int doAbcDual()
ClpSimplex::pivotRow
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
Definition: ClpSimplex.hpp:962
AbcSimplex::numberOrdinary
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:276
AbcSimplex::getBasis
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
AbcSimplex::startFixed_
int startFixed_
Start of fixed variables.
Definition: AbcSimplex.hpp:1069
AbcSimplex::setSequenceIn
void setSequenceIn(int sequence)
Set sequenceIn or Out.
Definition: AbcSimplex.hpp:603
AbcSimplex::setStateOfProblem
void setStateOfProblem(int value)
State of problem.
Definition: AbcSimplex.hpp:433
AbcSimplex::startAtUpperOther_
int startAtUpperOther_
Start of variables at upper bound with lower.
Definition: AbcSimplex.hpp:1065
AbcSimplex::fillPerturbation
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
AbcSimplex::pivoted
bool pivoted(int sequence) const
Definition: AbcSimplex.hpp:806
AbcSimplex::abcPerturbation_
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
Definition: AbcSimplex.hpp:1159
AbcSimplex::originalModel
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
AbcSimplex::setColumnBounds
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
AbcSimplex::stateOfProblem
int stateOfProblem() const
State of problem.
Definition: AbcSimplex.hpp:430
AbcSimplex::setInternalStatus
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
Definition: AbcSimplex.hpp:579
AbcSimplex::solutionBasic_
double * solutionBasic_
Working scaled basic primal solution.
Definition: AbcSimplex.hpp:1201
AbcSimplex::scaleToExternal_
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual.
Definition: AbcSimplex.hpp:1137
AbcSimplex::djBasic
double * djBasic() const
Definition: AbcSimplex.hpp:553
AbcSimplex::sumFakeInfeasibilities_
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
Definition: AbcSimplex.hpp:1003
AbcSimplex::initialDenseFactorization
bool initialDenseFactorization() const
AbcSimplex::currentDualTolerance_
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
Definition: AbcSimplex.hpp:995
AbcSimplex::currentDualBound_
double currentDualBound_
Current dualBound (will end up as dualBound_)
Definition: AbcSimplex.hpp:997
AbcSimplex::offsetRhs_
double * offsetRhs_
Offset for accumulated offsets*matrix.
Definition: AbcSimplex.hpp:1147
AbcSimplex::getInternalColumnStatus
AbcSimplex::Status getInternalColumnStatus(int sequence) const
Definition: AbcSimplex.hpp:576
AbcSimplex::getInternalStatus
AbcSimplex::Status getInternalStatus(int sequence) const
Definition: AbcSimplex.hpp:573
AbcSimplex::freeSequenceIn_
int freeSequenceIn_
Free chosen vector.
Definition: AbcSimplex.hpp:1032
AbcSimplex::numberFlipped_
int numberFlipped_
Definition: AbcSimplex.hpp:1258
AbcSimplex::arrayForDualColumn_
int arrayForDualColumn_
Definition: AbcSimplex.hpp:1250
AbcSimplex::operator=
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
AbcSimplex::djSaved_
double * djSaved_
Saved scaled dual solution.
Definition: AbcSimplex.hpp:1193
COLUMN_LOWER_SAME
#define COLUMN_LOWER_SAME
Definition: ClpModel.hpp:1209
AbcSimplex::checkDualSolution
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual)
ClpModel::rowLower_
double * rowLower_
Row lower.
Definition: ClpModel.hpp:1136
AbcSimplex::setColLower
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
Definition: AbcSimplex.hpp:921
AbcSimplex::lower
double lower(int sequence)
Definition: AbcSimplex.hpp:700
AbcSimplex::setPivoted
void setPivoted(int sequence)
Definition: AbcSimplex.hpp:800
AbcSimplex::stateDualColumn_
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
Definition: AbcSimplex.hpp:1048
AbcSimplex::swappedAlgorithm_
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
Definition: AbcSimplex.hpp:1125
AbcSimplex::arrayForBtran
int arrayForBtran() const
Definition: AbcSimplex.hpp:469
AbcSimplex::columnScale2
double * columnScale2() const
Definition: AbcSimplex.hpp:456
AbcSimplex::scaleFromExternal_
double * scaleFromExternal_
Points from external to internal.
Definition: AbcSimplex.hpp:1134
ABC_NUMBER_USEFUL
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
Definition: AbcSimplex.hpp:1239
AbcSimplex::djBasic_
double * djBasic_
Working scaled basic dual solution (want it to be zero)
Definition: AbcSimplex.hpp:1203
AbcSimplex::printStuff
void printStuff() const
Print stuff.
AbcSimplex::setMultipleSequenceIn
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
AbcSimplex::setInitialDenseFactorization
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular.
AbcSimplex::setColumnLower
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
AbcSimplex::doAbcPrimal
int doAbcPrimal(int ifValuesPass)
AbcSimplex::objectiveOffset_
double objectiveOffset_
Objective offset (from offset_)
Definition: AbcSimplex.hpp:988
AbcSimplex::clearActive
void clearActive(int iRow)
Definition: AbcSimplex.hpp:825
AbcSimplex::maximumTotal
int maximumTotal() const
Definition: AbcSimplex.hpp:217
AbcSimplex::minimizationObjectiveValue
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
Definition: AbcSimplex.hpp:254
AbcSimplex::putStuffInBasis
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...
AbcSimplex::checkSolutionBasic
void checkSolutionBasic() const
For debug - checks solutionBasic.
AbcSimplex::computeDuals
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
AbcSimplex::saveData_
ClpDataSave saveData_
For saving stuff at beginning.
Definition: AbcSimplex.hpp:1244
AbcSimplex::largestGap_
double largestGap_
Largest gap.
Definition: AbcSimplex.hpp:999
AbcSimplex::getReducedCost
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
AbcSimplex::abcDualRowPivot_
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
Definition: AbcSimplex.hpp:1205
AbcSimplex::getAvailableArrayPublic
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
Definition: AbcSimplex.hpp:749
AbcSimplex::atFakeBound
bool atFakeBound(int sequence) const
ClpModel::numberColumns
int numberColumns() const
Definition: ClpModel.hpp:325
AbcSimplex::clearArrays
void clearArrays(int which)
Clears an array and says available (-1 does all)
AbcSimplex::clpModel_
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
Definition: AbcSimplex.hpp:1229
AbcSimplex::lowerAddress
double & lowerAddress(int sequence)
Return address of row or column lower bound.
Definition: AbcSimplex.hpp:704
AbcSimplex::basic
@ basic
Definition: AbcSimplex.hpp:79
AbcSimplex::currentAcceptablePivot
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:646
AbcSimplex::arrayForFlipBounds
int arrayForFlipBounds() const
Definition: AbcSimplex.hpp:465
AbcSimplex::perturbationFactor_
double perturbationFactor_
Perturbation factor If <0.0 then virtual if 0.0 none if >0.0 use this as factor.
Definition: AbcSimplex.hpp:993
AbcSimplex::lastPrimalError_
double lastPrimalError_
Last primal error.
Definition: AbcSimplex.hpp:1005
AbcSimplex::scaleFromExternal
double * scaleFromExternal() const
Points from external to internal.
Definition: AbcSimplex.hpp:443
AbcSimplex::AbcSimplex
AbcSimplex(const ClpSimplex *clpSimplex)
This constructor copies from ClpSimplex.
ClpSimplex::sequenceOut_
int sequenceOut_
Sequence of Out variable.
Definition: ClpSimplex.hpp:1592
AbcSimplex::setupDualValuesPass
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...
AbcSimplex::Status
Status
enums for status of various sorts.
Definition: AbcSimplex.hpp:74
AbcSimplex::clpObjectiveValue
double clpObjectiveValue() const
Objective value.
Definition: AbcSimplex.hpp:421
AbcSimplex::setColSetBounds
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously
Definition: AbcSimplex.hpp:942
AbcSimplex::setInternalColumnStatus
void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus)
Definition: AbcSimplex.hpp:584
CoinAbcCommon.hpp
AbcSimplex::djRegion
double * djRegion(int which) const
Definition: AbcSimplex.hpp:537
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
Definition: AbcSimplex.hpp:228
AbcSimplex::restoreData
void restoreData(ClpDataSave saved)
Restore data.
AbcSimplex::abcFactorization_
AbcSimplexFactorization * abcFactorization_
factorization
Definition: AbcSimplex.hpp:1215
AbcSimplex::setFlagged
void setFlagged(int sequence)
To flag a variable.
AbcSimplex::setClpSimplexObjectiveValue
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
AbcSimplex::minimumThetaMovement_
double minimumThetaMovement_
Minimum theta movement.
Definition: AbcSimplex.hpp:1022
AbcSimplex::startAtUpperNoOther_
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
Definition: AbcSimplex.hpp:1063
AbcSimplex::upperTheta
double upperTheta() const
upper theta from dual column
Definition: AbcSimplex.hpp:461
AbcSimplex::sequenceIn
int sequenceIn() const
Return sequence In or Out.
Definition: AbcSimplex.hpp:596
AbcSimplex::arrayForTableauRow
int arrayForTableauRow() const
Definition: AbcSimplex.hpp:473
AbcSimplex::internalFactorize
int internalFactorize(int solveType)
Factorizes using current basis.
AbcSimplex::setRowSetBounds
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously
AbcSimplex::initialNumberInfeasibilities_
int initialNumberInfeasibilities_
Initial number of infeasibilities.
Definition: AbcSimplex.hpp:1127
AbcSimplex::checkConsistentPivots
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
AbcSimplex::maximumAbcNumberColumns_
int maximumAbcNumberColumns_
Maximum number columns.
Definition: AbcSimplex.hpp:1036
AbcSimplex::abcProgress
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
Definition: AbcSimplex.hpp:734
AbcSimplex::ordinaryVariables_
int ordinaryVariables_
Set to 1 if no free or super basic.
Definition: AbcSimplex.hpp:1117
AbcSimplex::defaultFactorizationFrequency
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
AbcSimplex::arrayForFlipRhs_
int arrayForFlipRhs_
Definition: AbcSimplex.hpp:1253
AbcTolerancesEtc
Definition: CoinAbcCommon.hpp:256
AbcSimplex::gutsOfSolution
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements)
AbcSimplex::currentDualTolerance
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
Definition: AbcSimplex.hpp:257
AbcSimplex::gutsOfCopy
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
NUMBER_THREADS
#define NUMBER_THREADS
Definition: AbcSimplex.hpp:863
AbcSimplex::numberTotalWithoutFixed
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
Definition: AbcSimplex.hpp:225
AbcSimplex::dual
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
AbcSimplex::djRegion
double * djRegion() const
Definition: AbcSimplex.hpp:521
AbcSimplex::setValuesPassAction
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
AbcSimplex::lowerSaved_
double * lowerSaved_
Saved scaled copy of lower bounds.
Definition: AbcSimplex.hpp:1185
AbcSimplex::computeInternalObjectiveValue
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation.
AbcSimplex::getRowActivity
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
AbcSimplex::maximumAbcNumberRows
int maximumAbcNumberRows() const
Maximum rows.
Definition: AbcSimplex.hpp:212
AbcSimplex::gutsOfResize
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
ClpModel::numberRows
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
AbcSimplex::numberTotal
int numberTotal() const
Number of variables (includes spare rows)
Definition: AbcSimplex.hpp:222
AbcSimplex::numberDisasters_
int numberDisasters_
Definition: AbcSimplex.hpp:1259
AbcSimplex::multipleSequenceIn_
int multipleSequenceIn_[4]
Multiple sequence in.
Definition: AbcSimplex.hpp:1248
ClpModel::rowUpper_
double * rowUpper_
Row upper.
Definition: ClpModel.hpp:1138
AbcSimplex::abcDj_
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
Definition: AbcSimplex.hpp:1183
AbcSimplex::swapDualStuff
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
AbcSimplex::arrayForTableauRow_
int arrayForTableauRow_
Definition: AbcSimplex.hpp:1256
AbcSimplex::perturbationBasic_
double * perturbationBasic_
basic perturbation
Definition: AbcSimplex.hpp:1163
ClpModel::dropNames
void dropNames()
Drops names - makes lengthnames 0 and names empty.
ClpModel::dblParam_
double dblParam_[ClpLastDblParam]
Array of double parameters.
Definition: ClpModel.hpp:1114
AbcSimplex::moveInfo
void moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
AbcSimplex::normalDualColumnIteration_
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
Definition: AbcSimplex.hpp:1042
AbcSimplex::setActive
void setActive(int iRow)
To say row active in primal pivot row choice.
Definition: AbcSimplex.hpp:822
AbcSimplex::perturbationSaved_
double * perturbationSaved_
saved perturbation
Definition: AbcSimplex.hpp:1161
AbcSimplex::sequenceWithin
int sequenceWithin(int sequence) const
Returns sequence number within section.
Definition: AbcSimplex.hpp:630
AbcSimplex::abcUpper_
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
Definition: AbcSimplex.hpp:1171
AbcPrimalColumnPivot
Primal Column Pivot Abstract Base Class.
Definition: AbcPrimalColumnPivot.hpp:26
AbcSimplex::movement_
double movement_
Movement of variable.
Definition: AbcSimplex.hpp:1011
AbcSimplex::perturbationSaved
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
Definition: AbcSimplex.hpp:267
AbcSimplex::currentAcceptablePivot_
double currentAcceptablePivot_
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:1009
AbcSimplex::numberTotal_
int numberTotal_
Number of variables (includes spare rows)
Definition: AbcSimplex.hpp:1055
AbcSimplex::inverseColumnUseScale_
double * inverseColumnUseScale_
use this instead of inverseColumnScale
Definition: AbcSimplex.hpp:1141