- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# /home/coin/SVN-release/Cgl-0.52.0/Clp/src/ClpSimplex.hpp

Go to the documentation of this file.

    00001 // Copyright (C) 2002, International Business Machines
    00002 // Corporation and others.  All Rights Reserved.
    00003
    00004 /*
    00005    Authors
    00006
    00007    John Forrest
    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   // For Dual
    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   // Ones below are just ClpModel with some changes
    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   // If using Debug
    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   /******************** End of most useful part **************/
    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   // These are only to be used using startFinishOptions (ClpSimplexDual, ClpSimplexPrimal)
    01006   // *** At present only without scaling
    01007   // *** Slacks havve -1.0 element (so == row activity) - take care
    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 // For Devex stuff
    01335 #define DEVEX_TRY_NORM 1.0e-4
    01336 #define DEVEX_ADD_ONE 1.0
    01337 #endif