00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #ifndef ClpSimplex_H
00011 #define ClpSimplex_H
00012
00013 #include <iostream>
00014 #include <cfloat>
00015 #include "ClpModel.hpp"
00016 #include "ClpMatrixBase.hpp"
00017 #include "ClpSolve.hpp"
00018 class ClpDualRowPivot;
00019 class ClpPrimalColumnPivot;
00020 class ClpFactorization;
00021 class CoinIndexedVector;
00022 class ClpNonLinearCost;
00023 class CoinModel;
00024 class OsiClpSolverInterface;
00025 class CoinWarmStartBasis;
00026 class ClpDisasterHandler;
00027 class ClpConstraint;
00028
00047 class ClpSimplex : public ClpModel {
00048 friend void ClpSimplexUnitTest(const std::string & mpsDir);
00049
00050 public:
00055 enum Status {
00056 isFree = 0x00,
00057 basic = 0x01,
00058 atUpperBound = 0x02,
00059 atLowerBound = 0x03,
00060 superBasic = 0x04,
00061 isFixed = 0x05
00062 };
00063
00064 enum FakeBound {
00065 noFake = 0x00,
00066 bothFake = 0x01,
00067 upperFake = 0x02,
00068 lowerFake = 0x03
00069 };
00070
00073
00074 ClpSimplex (bool emptyMessages = false );
00075
00080 ClpSimplex(const ClpSimplex & rhs, int scalingMode =-1);
00085 ClpSimplex(const ClpModel & rhs, int scalingMode=-1);
00092 ClpSimplex (const ClpModel * wholeModel,
00093 int numberRows, const int * whichRows,
00094 int numberColumns, const int * whichColumns,
00095 bool dropNames=true, bool dropIntegers=true,
00096 bool fixOthers=false);
00103 ClpSimplex (const ClpSimplex * wholeModel,
00104 int numberRows, const int * whichRows,
00105 int numberColumns, const int * whichColumns,
00106 bool dropNames=true, bool dropIntegers=true,
00107 bool fixOthers=false);
00111 ClpSimplex (ClpSimplex * wholeModel,
00112 int numberColumns, const int * whichColumns);
00115 void originalModel(ClpSimplex * miniModel);
00121 void setPersistenceFlag(int value);
00135 void auxiliaryModel(int options);
00137 void deleteAuxiliaryModel();
00139 inline bool usingAuxiliaryModel() const
00140 { return auxiliaryModel_!=NULL;}
00142 void makeBaseModel();
00144 void deleteBaseModel();
00146 inline ClpSimplex * baseModel() const
00147 { return baseModel_;}
00151 void setToBaseModel(ClpSimplex * model=NULL);
00153 ClpSimplex & operator=(const ClpSimplex & rhs);
00155 ~ClpSimplex ( );
00156
00168 void loadProblem ( const ClpMatrixBase& matrix,
00169 const double* collb, const double* colub,
00170 const double* obj,
00171 const double* rowlb, const double* rowub,
00172 const double * rowObjective=NULL);
00173 void loadProblem ( const CoinPackedMatrix& matrix,
00174 const double* collb, const double* colub,
00175 const double* obj,
00176 const double* rowlb, const double* rowub,
00177 const double * rowObjective=NULL);
00178
00181 void loadProblem ( const int numcols, const int numrows,
00182 const CoinBigIndex* start, const int* index,
00183 const double* value,
00184 const double* collb, const double* colub,
00185 const double* obj,
00186 const double* rowlb, const double* rowub,
00187 const double * rowObjective=NULL);
00189 void loadProblem ( const int numcols, const int numrows,
00190 const CoinBigIndex* start, const int* index,
00191 const double* value,const int * length,
00192 const double* collb, const double* colub,
00193 const double* obj,
00194 const double* rowlb, const double* rowub,
00195 const double * rowObjective=NULL);
00200 int loadProblem ( CoinModel & modelObject,bool keepSolution=false);
00202 int readMps(const char *filename,
00203 bool keepNames=false,
00204 bool ignoreErrors = false);
00206 int readGMPL(const char *filename,const char * dataName,
00207 bool keepNames=false);
00210 int readLp(const char *filename, const double epsilon = 1e-5);
00215 void borrowModel(ClpModel & otherModel);
00216 void borrowModel(ClpSimplex & otherModel);
00218 void passInEventHandler(const ClpEventHandler * eventHandler);
00220 void getbackSolution(const ClpSimplex & smallModel,const int * whichRow, const int * whichColumn);
00229 int loadNonLinear(void * info, int & numberConstraints,
00230 ClpConstraint ** & constraints);
00232
00238 int initialSolve(ClpSolve & options);
00240 int initialSolve();
00242 int initialDualSolve();
00244 int initialPrimalSolve();
00246 int initialBarrierSolve();
00248 int initialBarrierNoCrossSolve();
00259 int dual(int ifValuesPass=0, int startFinishOptions=0);
00260
00261 int dualDebug(int ifValuesPass=0, int startFinishOptions=0);
00272 int primal(int ifValuesPass=0, int startFinishOptions=0);
00278 int nonlinearSLP(int numberPasses,double deltaTolerance);
00284 int nonlinearSLP(int numberConstraints, ClpConstraint ** constraints,
00285 int numberPasses,double deltaTolerance);
00288 int barrier(bool crossover=true);
00291 int reducedGradient(int phase=0);
00306 int cleanup(int cleanupScaling);
00327 int dualRanging(int numberCheck,const int * which,
00328 double * costIncrease, int * sequenceIncrease,
00329 double * costDecrease, int * sequenceDecrease,
00330 double * valueIncrease=NULL, double * valueDecrease=NULL);
00345 int primalRanging(int numberCheck,const int * which,
00346 double * valueIncrease, int * sequenceIncrease,
00347 double * valueDecrease, int * sequenceDecrease);
00362 int writeBasis(const char *filename,
00363 bool writeValues=false,
00364 int formatType=0) const;
00367 int readBasis(const char *filename);
00369 CoinWarmStartBasis * getBasis() const;
00371 void setFactorization( ClpFactorization & factorization);
00381 int tightenPrimalBounds(double factor=0.0,int doTight=0,bool tightIntegers=false);
00398 int crash(double gap,int pivot);
00400 void setDualRowPivotAlgorithm(ClpDualRowPivot & choice);
00402 void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice);
00411 int strongBranching(int numberVariables,const int * variables,
00412 double * newLower, double * newUpper,
00413 double ** outputSolution,
00414 int * outputStatus, int * outputIterations,
00415 bool stopOnFirstInfeasible=true,
00416 bool alwaysFinish=false,
00417 int startFinishOptions=0);
00419
00427 int pivot();
00428
00434 int primalPivotResult();
00435
00442 int dualPivotResult();
00443
00455 int startup(int ifValuesPass,int startFinishOptions=0);
00456 void finish(int startFinishOptions=0);
00457
00459 bool statusOfProblem(bool initial=false);
00461 void defaultFactorizationFrequency();
00463
00466
00467 inline bool primalFeasible() const
00468 { return (numberPrimalInfeasibilities_==0);}
00470 inline bool dualFeasible() const
00471 { return (numberDualInfeasibilities_==0);}
00473 inline ClpFactorization * factorization() const
00474 { return factorization_;}
00476 bool sparseFactorization() const;
00477 void setSparseFactorization(bool value);
00479 int factorizationFrequency() const;
00480 void setFactorizationFrequency(int value);
00482 inline double dualBound() const
00483 { return dualBound_;}
00484 void setDualBound(double value);
00486 inline double infeasibilityCost() const
00487 { return infeasibilityCost_;}
00488 void setInfeasibilityCost(double value);
00505 inline int perturbation() const
00506 { return perturbation_;}
00507 void setPerturbation(int value);
00509 inline int algorithm() const
00510 {return algorithm_; }
00512 inline void setAlgorithm(int value)
00513 {algorithm_=value; }
00515 inline double sumDualInfeasibilities() const
00516 { return sumDualInfeasibilities_;}
00517 inline void setSumDualInfeasibilities(double value)
00518 { sumDualInfeasibilities_=value;}
00520 inline double sumOfRelaxedDualInfeasibilities() const
00521 { return sumOfRelaxedDualInfeasibilities_;}
00522 inline void setSumOfRelaxedDualInfeasibilities(double value)
00523 { sumOfRelaxedDualInfeasibilities_=value;}
00525 inline int numberDualInfeasibilities() const
00526 { return numberDualInfeasibilities_;}
00527 inline void setNumberDualInfeasibilities(int value)
00528 { numberDualInfeasibilities_=value;}
00530 inline int numberDualInfeasibilitiesWithoutFree() const
00531 { return numberDualInfeasibilitiesWithoutFree_;}
00533 inline double sumPrimalInfeasibilities() const
00534 { return sumPrimalInfeasibilities_;}
00535 inline void setSumPrimalInfeasibilities(double value)
00536 { sumPrimalInfeasibilities_=value;}
00538 inline double sumOfRelaxedPrimalInfeasibilities() const
00539 { return sumOfRelaxedPrimalInfeasibilities_;}
00540 inline void setSumOfRelaxedPrimalInfeasibilities(double value)
00541 { sumOfRelaxedPrimalInfeasibilities_=value;}
00543 inline int numberPrimalInfeasibilities() const
00544 { return numberPrimalInfeasibilities_;}
00545 inline void setNumberPrimalInfeasibilities(int value)
00546 { numberPrimalInfeasibilities_=value;}
00553 int saveModel(const char * fileName);
00556 int restoreModel(const char * fileName);
00557
00565 void checkSolution(int setToBounds=false);
00568 void checkSolutionInternal();
00570 inline CoinIndexedVector * rowArray(int index) const
00571 { return rowArray_[index];}
00573 inline CoinIndexedVector * columnArray(int index) const
00574 { return columnArray_[index];}
00576
00577
00583 int getSolution ( const double * rowActivities,
00584 const double * columnActivities);
00588 int getSolution ();
00595 int createPiecewiseLinearCosts(const int * starts,
00596 const double * lower, const double * gradient);
00598 ClpDualRowPivot * dualRowPivot() const
00599 { return dualRowPivot_;}
00601 void returnModel(ClpSimplex & otherModel);
00609 int internalFactorize(int solveType);
00611 ClpDataSave saveData() ;
00613 void restoreData(ClpDataSave saved);
00615 void cleanStatus();
00617 int factorize();
00620 void computeDuals(double * givenDjs);
00622 void computePrimals ( const double * rowActivities,
00623 const double * columnActivities);
00625 void add(double * array,
00626 int column, double multiplier) const;
00632 void unpack(CoinIndexedVector * rowArray) const ;
00638 void unpack(CoinIndexedVector * rowArray,int sequence) const;
00645 void unpackPacked(CoinIndexedVector * rowArray) ;
00652 void unpackPacked(CoinIndexedVector * rowArray,int sequence);
00653 protected:
00658 int housekeeping(double objectiveChange);
00661 void checkPrimalSolution(const double * rowActivities=NULL,
00662 const double * columnActivies=NULL);
00665 void checkDualSolution();
00667 void checkBothSolutions();
00668 public:
00679 void setValuesPassAction(double incomingInfeasibility,
00680 double allowedInfeasibility);
00682
00684 public:
00686 inline double alphaAccuracy() const
00687 { return alphaAccuracy_;}
00688 inline void setAlphaAccuracy(double value)
00689 { alphaAccuracy_ = value;}
00690 public:
00692 inline void setDisasterHandler(ClpDisasterHandler * handler)
00693 { disasterArea_= handler;}
00695 inline double largeValue() const
00696 { return largeValue_;}
00697 void setLargeValue( double value) ;
00699 inline double largestPrimalError() const
00700 { return largestPrimalError_;}
00702 inline double largestDualError() const
00703 { return largestDualError_;}
00705 inline void setLargestPrimalError(double value)
00706 { largestPrimalError_=value;}
00708 inline void setLargestDualError(double value)
00709 { largestDualError_=value;}
00711 inline int * pivotVariable() const
00712 { return pivotVariable_;}
00714 inline bool automaticScaling() const
00715 { return automaticScale_!=0;}
00716 inline void setAutomaticScaling(bool onOff)
00717 { automaticScale_ = onOff ? 1: 0;}
00719 inline double currentDualTolerance() const
00720 { return dualTolerance_;}
00721 inline void setCurrentDualTolerance(double value)
00722 { dualTolerance_ = value;}
00724 inline double currentPrimalTolerance() const
00725 { return primalTolerance_;}
00726 inline void setCurrentPrimalTolerance(double value)
00727 { primalTolerance_ = value;}
00729 inline int numberRefinements() const
00730 { return numberRefinements_;}
00731 void setNumberRefinements( int value) ;
00733 inline double alpha() const { return alpha_;}
00734 inline void setAlpha(double value) { alpha_ = value;}
00736 inline double dualIn() const { return dualIn_;}
00738 inline int pivotRow() const{ return pivotRow_;}
00739 inline void setPivotRow(int value) { pivotRow_=value;}
00741 double valueIncomingDual() const;
00743
00744 protected:
00750 int gutsOfSolution ( double * givenDuals,
00751 const double * givenPrimals,
00752 bool valuesPass=false);
00754 void gutsOfDelete(int type);
00756 void gutsOfCopy(const ClpSimplex & rhs);
00768 bool createRim(int what,bool makeRowCopy=false,int startFinishOptions=0);
00770 void createRim1(bool initial);
00772 void createRim4(bool initial);
00774 void createRim5(bool initial);
00779 void deleteRim(int getRidOfFactorizationData=2);
00781 bool sanityCheck();
00783 public:
00788 inline double * solutionRegion(int section) const
00789 { if (!section) return rowActivityWork_; else return columnActivityWork_;}
00790 inline double * djRegion(int section) const
00791 { if (!section) return rowReducedCost_; else return reducedCostWork_;}
00792 inline double * lowerRegion(int section) const
00793 { if (!section) return rowLowerWork_; else return columnLowerWork_;}
00794 inline double * upperRegion(int section) const
00795 { if (!section) return rowUpperWork_; else return columnUpperWork_;}
00796 inline double * costRegion(int section) const
00797 { if (!section) return rowObjectiveWork_; else return objectiveWork_;}
00799 inline double * solutionRegion() const
00800 { return solution_;}
00801 inline double * djRegion() const
00802 { return dj_;}
00803 inline double * lowerRegion() const
00804 { return lower_;}
00805 inline double * upperRegion() const
00806 { return upper_;}
00807 inline double * costRegion() const
00808 { return cost_;}
00809 inline Status getStatus(int sequence) const
00810 {return static_cast<Status> (status_[sequence]&7);}
00811 inline void setStatus(int sequence, Status status)
00812 {
00813 unsigned char & st_byte = status_[sequence];
00814 st_byte &= ~7;
00815 st_byte |= status;
00816 }
00818 bool startPermanentArrays();
00823 void setInitialDenseFactorization(bool onOff);
00824 bool initialDenseFactorization() const;
00826 inline int sequenceIn() const
00827 {return sequenceIn_;}
00828 inline int sequenceOut() const
00829 {return sequenceOut_;}
00831 inline void setSequenceIn(int sequence)
00832 { sequenceIn_=sequence;}
00833 inline void setSequenceOut(int sequence)
00834 { sequenceOut_=sequence;}
00836 inline int directionIn() const
00837 {return directionIn_;}
00838 inline int directionOut() const
00839 {return directionOut_;}
00841 inline void setDirectionIn(int direction)
00842 { directionIn_=direction;}
00843 inline void setDirectionOut(int direction)
00844 { directionOut_=direction;}
00846 inline double valueOut() const
00847 { return valueOut_;}
00849 inline int isColumn(int sequence) const
00850 { return sequence<numberColumns_ ? 1 : 0;}
00852 inline int sequenceWithin(int sequence) const
00853 { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;}
00855 inline double solution(int sequence)
00856 { return solution_[sequence];}
00858 inline double & solutionAddress(int sequence)
00859 { return solution_[sequence];}
00860 inline double reducedCost(int sequence)
00861 { return dj_[sequence];}
00862 inline double & reducedCostAddress(int sequence)
00863 { return dj_[sequence];}
00864 inline double lower(int sequence)
00865 { return lower_[sequence];}
00867 inline double & lowerAddress(int sequence)
00868 { return lower_[sequence];}
00869 inline double upper(int sequence)
00870 { return upper_[sequence];}
00872 inline double & upperAddress(int sequence)
00873 { return upper_[sequence];}
00874 inline double cost(int sequence)
00875 { return cost_[sequence];}
00877 inline double & costAddress(int sequence)
00878 { return cost_[sequence];}
00880 inline double originalLower(int iSequence) const
00881 { if (iSequence<numberColumns_) return columnLower_[iSequence]; else
00882 return rowLower_[iSequence-numberColumns_];}
00884 inline double originalUpper(int iSequence) const
00885 { if (iSequence<numberColumns_) return columnUpper_[iSequence]; else
00886 return rowUpper_[iSequence-numberColumns_];}
00888 inline double theta() const
00889 { return theta_;}
00891 inline ClpNonLinearCost * nonLinearCost() const
00892 { return nonLinearCost_;}
00898 inline int moreSpecialOptions() const
00899 { return moreSpecialOptions_;}
00905 inline void setMoreSpecialOptions(int value)
00906 { moreSpecialOptions_ = value;}
00908
00910 inline void setFakeBound(int sequence, FakeBound fakeBound)
00911 {
00912 unsigned char & st_byte = status_[sequence];
00913 st_byte &= ~24;
00914 st_byte |= fakeBound<<3;
00915 }
00916 inline FakeBound getFakeBound(int sequence) const
00917 {return static_cast<FakeBound> ((status_[sequence]>>3)&3);}
00918 inline void setRowStatus(int sequence, Status status)
00919 {
00920 unsigned char & st_byte = status_[sequence+numberColumns_];
00921 st_byte &= ~7;
00922 st_byte |= status;
00923 }
00924 inline Status getRowStatus(int sequence) const
00925 {return static_cast<Status> (status_[sequence+numberColumns_]&7);}
00926 inline void setColumnStatus(int sequence, Status status)
00927 {
00928 unsigned char & st_byte = status_[sequence];
00929 st_byte &= ~7;
00930 st_byte |= status;
00931 }
00932 inline Status getColumnStatus(int sequence) const
00933 {return static_cast<Status> (status_[sequence]&7);}
00934 inline void setPivoted( int sequence)
00935 { status_[sequence] |= 32;}
00936 inline void clearPivoted( int sequence)
00937 { status_[sequence] &= ~32; }
00938 inline bool pivoted(int sequence) const
00939 {return (((status_[sequence]>>5)&1)!=0);}
00941 void setFlagged( int sequence);
00942 inline void clearFlagged( int sequence)
00943 {
00944 status_[sequence] &= ~64;
00945 }
00946 inline bool flagged(int sequence) const
00947 {return ((status_[sequence]&64)!=0);}
00949 inline void setActive( int iRow)
00950 {
00951 status_[iRow] |= 128;
00952 }
00953 inline void clearActive( int iRow)
00954 {
00955 status_[iRow] &= ~128;
00956 }
00957 inline bool active(int iRow) const
00958 {return ((status_[iRow]&128)!=0);}
00961 void createStatus() ;
00964 void allSlackBasis(bool resetSolution=false);
00965
00967 inline int lastBadIteration() const
00968 {return lastBadIteration_;}
00970 inline int progressFlag() const
00971 {return progressFlag_;}
00973 inline void forceFactorization(int value)
00974 { forceFactorization_ = value;}
00976 inline double rawObjectiveValue() const
00977 { return objectiveValue_;}
00979 void computeObjectiveValue(bool useWorkingSolution=false);
00981 double computeInternalObjectiveValue();
00985 inline int numberExtraRows() const
00986 { return numberExtraRows_;}
00989 inline int maximumBasic() const
00990 { return maximumBasic_;}
00992 inline int baseIteration() const
00993 { return baseIteration_;}
00995 void generateCpp( FILE * fp,bool defaultFactor=false);
00997 ClpFactorization * getEmptyFactorization();
00999 void setEmptyFactorization();
01001 void moveInfo(const ClpSimplex & rhs, bool justStatus=false);
01003
01005
01006
01007
01009 void getBInvARow(int row, double* z, double * slack=NULL);
01010
01012 void getBInvRow(int row, double* z);
01013
01015 void getBInvACol(int col, double* vec);
01016
01018 void getBInvCol(int col, double* vec);
01019
01024 void getBasics(int* index);
01025
01027
01031 void setObjectiveCoefficient( int elementIndex, double elementValue );
01033 inline void setObjCoeff( int elementIndex, double elementValue )
01034 { setObjectiveCoefficient( elementIndex, elementValue);}
01035
01038 void setColumnLower( int elementIndex, double elementValue );
01039
01042 void setColumnUpper( int elementIndex, double elementValue );
01043
01045 void setColumnBounds( int elementIndex,
01046 double lower, double upper );
01047
01056 void setColumnSetBounds(const int* indexFirst,
01057 const int* indexLast,
01058 const double* boundList);
01059
01062 inline void setColLower( int elementIndex, double elementValue )
01063 { setColumnLower(elementIndex, elementValue);}
01066 inline void setColUpper( int elementIndex, double elementValue )
01067 { setColumnUpper(elementIndex, elementValue);}
01068
01070 inline void setColBounds( int elementIndex,
01071 double lower, double upper )
01072 { setColumnBounds(elementIndex, lower, upper);}
01073
01080 inline void setColSetBounds(const int* indexFirst,
01081 const int* indexLast,
01082 const double* boundList)
01083 { setColumnSetBounds(indexFirst, indexLast, boundList);}
01084
01087 void setRowLower( int elementIndex, double elementValue );
01088
01091 void setRowUpper( int elementIndex, double elementValue ) ;
01092
01094 void setRowBounds( int elementIndex,
01095 double lower, double upper ) ;
01096
01103 void setRowSetBounds(const int* indexFirst,
01104 const int* indexLast,
01105 const double* boundList);
01106
01108
01110 protected:
01111
01118
01119 double columnPrimalInfeasibility_;
01121 double rowPrimalInfeasibility_;
01123 int columnPrimalSequence_;
01125 int rowPrimalSequence_;
01127 double columnDualInfeasibility_;
01129 double rowDualInfeasibility_;
01131 int moreSpecialOptions_;
01133 int baseIteration_;
01135 double primalToleranceToGetOptimal_;
01137 double remainingDualInfeasibility_;
01139 double largeValue_;
01141 double largestPrimalError_;
01143 double largestDualError_;
01145 double alphaAccuracy_;
01147 double dualBound_;
01149 double alpha_;
01151 double theta_;
01153 double lowerIn_;
01155 double valueIn_;
01157 double upperIn_;
01159 double dualIn_;
01161 double lowerOut_;
01163 double valueOut_;
01165 double upperOut_;
01167 double dualOut_;
01169 double dualTolerance_;
01171 double primalTolerance_;
01173 double sumDualInfeasibilities_;
01175 double sumPrimalInfeasibilities_;
01177 double infeasibilityCost_;
01179 double sumOfRelaxedDualInfeasibilities_;
01181 double sumOfRelaxedPrimalInfeasibilities_;
01183 double acceptablePivot_;
01185 double * lower_;
01187 double * rowLowerWork_;
01189 double * columnLowerWork_;
01191 double * upper_;
01193 double * rowUpperWork_;
01195 double * columnUpperWork_;
01197 double * cost_;
01199 double * rowObjectiveWork_;
01201 double * objectiveWork_;
01203 CoinIndexedVector * rowArray_[6];
01205 CoinIndexedVector * columnArray_[6];
01207 int sequenceIn_;
01209 int directionIn_;
01211 int sequenceOut_;
01213 int directionOut_;
01215 int pivotRow_;
01217 int lastGoodIteration_;
01219 double * dj_;
01221 double * rowReducedCost_;
01223 double * reducedCostWork_;
01225 double * solution_;
01227 double * rowActivityWork_;
01229 double * columnActivityWork_;
01231 ClpSimplex * auxiliaryModel_;
01233 int numberDualInfeasibilities_;
01235 int numberDualInfeasibilitiesWithoutFree_;
01237 int numberPrimalInfeasibilities_;
01239 int numberRefinements_;
01241 ClpDualRowPivot * dualRowPivot_;
01243 ClpPrimalColumnPivot * primalColumnPivot_;
01245 int * pivotVariable_;
01247 ClpFactorization * factorization_;
01249 double * savedSolution_;
01251 int numberTimesOptimal_;
01253 ClpDisasterHandler * disasterArea_;
01255 int changeMade_;
01257 int algorithm_;
01260 int forceFactorization_;
01268 int perturbation_;
01270 unsigned char * saveStatus_;
01275 ClpNonLinearCost * nonLinearCost_;
01277 int lastBadIteration_;
01279 int lastFlaggedIteration_;
01281 int numberFake_;
01283 int numberChanged_;
01285 int progressFlag_;
01287 int firstFree_;
01291 int numberExtraRows_;
01294 int maximumBasic_;
01304 double incomingInfeasibility_;
01305 double allowedInfeasibility_;
01307 int automaticScale_;
01309 ClpSimplex * baseModel_;
01311 ClpSimplexProgress progress_;
01312 public:
01314 mutable int spareIntArray_[4];
01316 mutable double spareDoubleArray_[4];
01317 protected:
01319 friend class OsiClpSolverInterface;
01321 };
01322
01331 void
01332 ClpSimplexUnitTest(const std::string & mpsDir);
01333
01334
01335 #define DEVEX_TRY_NORM 1.0e-4
01336 #define DEVEX_ADD_ONE 1.0
01337 #endif