00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #ifndef ClpSimplex_H
00012 #define ClpSimplex_H
00013
00014 #include <iostream>
00015 #include <cfloat>
00016 #include "ClpModel.hpp"
00017 #include "ClpMatrixBase.hpp"
00018 #include "ClpSolve.hpp"
00019 #include "ClpConfig.h"
00020 class ClpDualRowPivot;
00021 class ClpPrimalColumnPivot;
00022 class ClpFactorization;
00023 class CoinIndexedVector;
00024 class ClpNonLinearCost;
00025 class ClpNodeStuff;
00026 class CoinStructuredModel;
00027 class OsiClpSolverInterface;
00028 class CoinWarmStartBasis;
00029 class ClpDisasterHandler;
00030 class ClpConstraint;
00031 #ifdef CLP_HAS_ABC
00032 #include "AbcCommon.hpp"
00033 class AbcTolerancesEtc;
00034 class AbcSimplex;
00035 #include "CoinAbcCommon.hpp"
00036 #endif
00037
00055 class ClpSimplex : public ClpModel {
00056 friend void ClpSimplexUnitTest(const std::string & mpsDir);
00057
00058 public:
00063 enum Status {
00064 isFree = 0x00,
00065 basic = 0x01,
00066 atUpperBound = 0x02,
00067 atLowerBound = 0x03,
00068 superBasic = 0x04,
00069 isFixed = 0x05
00070 };
00071
00072 enum FakeBound {
00073 noFake = 0x00,
00074 lowerFake = 0x01,
00075 upperFake = 0x02,
00076 bothFake = 0x03
00077 };
00078
00081
00082 ClpSimplex (bool emptyMessages = false );
00083
00088 ClpSimplex(const ClpSimplex & rhs, int scalingMode = -1);
00093 ClpSimplex(const ClpModel & rhs, int scalingMode = -1);
00100 ClpSimplex (const ClpModel * wholeModel,
00101 int numberRows, const int * whichRows,
00102 int numberColumns, const int * whichColumns,
00103 bool dropNames = true, bool dropIntegers = true,
00104 bool fixOthers = false);
00111 ClpSimplex (const ClpSimplex * wholeModel,
00112 int numberRows, const int * whichRows,
00113 int numberColumns, const int * whichColumns,
00114 bool dropNames = true, bool dropIntegers = true,
00115 bool fixOthers = false);
00119 ClpSimplex (ClpSimplex * wholeModel,
00120 int numberColumns, const int * whichColumns);
00123 void originalModel(ClpSimplex * miniModel);
00124 inline int abcState() const
00125 { return abcState_;}
00126 inline void setAbcState(int state)
00127 { abcState_=state;}
00128 #ifdef ABC_INHERIT
00129 inline AbcSimplex * abcSimplex() const
00130 { return abcSimplex_;}
00131 inline void setAbcSimplex(AbcSimplex * simplex)
00132 { abcSimplex_=simplex;}
00134 int doAbcDual();
00136 int doAbcPrimal(int ifValuesPass);
00137 #endif
00138
00143 void setPersistenceFlag(int value);
00145 void makeBaseModel();
00147 void deleteBaseModel();
00149 inline ClpSimplex * baseModel() const {
00150 return baseModel_;
00151 }
00155 void setToBaseModel(ClpSimplex * model = NULL);
00157 ClpSimplex & operator=(const ClpSimplex & rhs);
00159 ~ClpSimplex ( );
00160
00172 void loadProblem ( const ClpMatrixBase& matrix,
00173 const double* collb, const double* colub,
00174 const double* obj,
00175 const double* rowlb, const double* rowub,
00176 const double * rowObjective = NULL);
00177 void loadProblem ( const CoinPackedMatrix& matrix,
00178 const double* collb, const double* colub,
00179 const double* obj,
00180 const double* rowlb, const double* rowub,
00181 const double * rowObjective = NULL);
00182
00185 void loadProblem ( const int numcols, const int numrows,
00186 const CoinBigIndex* start, const int* index,
00187 const double* value,
00188 const double* collb, const double* colub,
00189 const double* obj,
00190 const double* rowlb, const double* rowub,
00191 const double * rowObjective = NULL);
00193 void loadProblem ( const int numcols, const int numrows,
00194 const CoinBigIndex* start, const int* index,
00195 const double* value, const int * length,
00196 const double* collb, const double* colub,
00197 const double* obj,
00198 const double* rowlb, const double* rowub,
00199 const double * rowObjective = NULL);
00204 int loadProblem ( CoinModel & modelObject, bool keepSolution = false);
00206 int readMps(const char *filename,
00207 bool keepNames = false,
00208 bool ignoreErrors = false);
00210 int readGMPL(const char *filename, const char * dataName,
00211 bool keepNames = false);
00214 int readLp(const char *filename, const double epsilon = 1e-5);
00219 void borrowModel(ClpModel & otherModel);
00220 void borrowModel(ClpSimplex & otherModel);
00222 void passInEventHandler(const ClpEventHandler * eventHandler);
00224 void getbackSolution(const ClpSimplex & smallModel, const int * whichRow, const int * whichColumn);
00233 int loadNonLinear(void * info, int & numberConstraints,
00234 ClpConstraint ** & constraints);
00235 #ifdef ABC_INHERIT
00237 void loadTolerancesEtc(const AbcTolerancesEtc & data);
00239 void unloadTolerancesEtc(AbcTolerancesEtc & data);
00240 #endif
00241
00242
00248 int initialSolve(ClpSolve & options);
00250 int initialSolve();
00252 int initialDualSolve();
00254 int initialPrimalSolve();
00256 int initialBarrierSolve();
00258 int initialBarrierNoCrossSolve();
00269 int dual(int ifValuesPass = 0, int startFinishOptions = 0);
00270
00271 int dualDebug(int ifValuesPass = 0, int startFinishOptions = 0);
00282 int primal(int ifValuesPass = 0, int startFinishOptions = 0);
00288 int nonlinearSLP(int numberPasses, double deltaTolerance);
00294 int nonlinearSLP(int numberConstraints, ClpConstraint ** constraints,
00295 int numberPasses, double deltaTolerance);
00298 int barrier(bool crossover = true);
00301 int reducedGradient(int phase = 0);
00303 int solve(CoinStructuredModel * model);
00304 #ifdef ABC_INHERIT
00305
00309 void dealWithAbc(int solveType,int startUp,bool interrupt=false);
00310 #endif
00311
00317 int loadProblem ( CoinStructuredModel & modelObject,
00318 bool originalOrder = true, bool keepSolution = false);
00333 int cleanup(int cleanupScaling);
00354 int dualRanging(int numberCheck, const int * which,
00355 double * costIncrease, int * sequenceIncrease,
00356 double * costDecrease, int * sequenceDecrease,
00357 double * valueIncrease = NULL, double * valueDecrease = NULL);
00372 int primalRanging(int numberCheck, const int * which,
00373 double * valueIncrease, int * sequenceIncrease,
00374 double * valueDecrease, int * sequenceDecrease);
00384 int modifyCoefficientsAndPivot(int number,
00385 const int * which,
00386 const CoinBigIndex * start,
00387 const int * row,
00388 const double * newCoefficient,
00389 const unsigned char * newStatus=NULL,
00390 const double * newLower=NULL,
00391 const double * newUpper=NULL,
00392 const double * newObjective=NULL);
00400 int outDuplicateRows(int numberLook,int * whichRows, bool noOverlaps=false, double tolerance=-1.0,
00401 double cleanUp=0.0);
00404 double moveTowardsPrimalFeasible();
00407 void removeSuperBasicSlacks(int threshold=0);
00420 ClpSimplex * miniPresolve(char * rowType, char * columnType,void ** info);
00422 void miniPostsolve(const ClpSimplex * presolvedModel,void * info);
00437 int writeBasis(const char *filename,
00438 bool writeValues = false,
00439 int formatType = 0) const;
00442 int readBasis(const char *filename);
00444 CoinWarmStartBasis * getBasis() const;
00446 void setFactorization( ClpFactorization & factorization);
00447
00448 ClpFactorization * swapFactorization( ClpFactorization * factorization);
00450 void copyFactorization( ClpFactorization & factorization);
00460 int tightenPrimalBounds(double factor = 0.0, int doTight = 0, bool tightIntegers = false);
00477 int crash(double gap, int pivot);
00479 void setDualRowPivotAlgorithm(ClpDualRowPivot & choice);
00481 void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice);
00490 int strongBranching(int numberVariables, const int * variables,
00491 double * newLower, double * newUpper,
00492 double ** outputSolution,
00493 int * outputStatus, int * outputIterations,
00494 bool stopOnFirstInfeasible = true,
00495 bool alwaysFinish = false,
00496 int startFinishOptions = 0);
00498 int fathom(void * stuff);
00504 int fathomMany(void * stuff);
00506 double doubleCheck();
00508 int startFastDual2(ClpNodeStuff * stuff);
00510 int fastDual2(ClpNodeStuff * stuff);
00512 void stopFastDual2(ClpNodeStuff * stuff);
00519 ClpSimplex * fastCrunch(ClpNodeStuff * stuff, int mode);
00521
00529 int pivot();
00530
00536 int primalPivotResult();
00537
00543 int dualPivotResultPart1();
00547 int pivotResultPart2(int algorithm,int state);
00548
00560 int startup(int ifValuesPass, int startFinishOptions = 0);
00561 void finish(int startFinishOptions = 0);
00562
00564 bool statusOfProblem(bool initial = false);
00566 void defaultFactorizationFrequency();
00568 void copyEnabledStuff(const ClpSimplex * rhs);
00570
00573
00574 inline bool primalFeasible() const {
00575 return (numberPrimalInfeasibilities_ == 0);
00576 }
00578 inline bool dualFeasible() const {
00579 return (numberDualInfeasibilities_ == 0);
00580 }
00582 inline ClpFactorization * factorization() const {
00583 return factorization_;
00584 }
00586 bool sparseFactorization() const;
00587 void setSparseFactorization(bool value);
00589 int factorizationFrequency() const;
00590 void setFactorizationFrequency(int value);
00592 inline double dualBound() const {
00593 return dualBound_;
00594 }
00595 void setDualBound(double value);
00597 inline double infeasibilityCost() const {
00598 return infeasibilityCost_;
00599 }
00600 void setInfeasibilityCost(double value);
00617 inline int perturbation() const {
00618 return perturbation_;
00619 }
00620 void setPerturbation(int value);
00622 inline int algorithm() const {
00623 return algorithm_;
00624 }
00626 inline void setAlgorithm(int value) {
00627 algorithm_ = value;
00628 }
00630 bool isObjectiveLimitTestValid() const ;
00632 inline double sumDualInfeasibilities() const {
00633 return sumDualInfeasibilities_;
00634 }
00635 inline void setSumDualInfeasibilities(double value) {
00636 sumDualInfeasibilities_ = value;
00637 }
00639 inline double sumOfRelaxedDualInfeasibilities() const {
00640 return sumOfRelaxedDualInfeasibilities_;
00641 }
00642 inline void setSumOfRelaxedDualInfeasibilities(double value) {
00643 sumOfRelaxedDualInfeasibilities_ = value;
00644 }
00646 inline int numberDualInfeasibilities() const {
00647 return numberDualInfeasibilities_;
00648 }
00649 inline void setNumberDualInfeasibilities(int value) {
00650 numberDualInfeasibilities_ = value;
00651 }
00653 inline int numberDualInfeasibilitiesWithoutFree() const {
00654 return numberDualInfeasibilitiesWithoutFree_;
00655 }
00657 inline double sumPrimalInfeasibilities() const {
00658 return sumPrimalInfeasibilities_;
00659 }
00660 inline void setSumPrimalInfeasibilities(double value) {
00661 sumPrimalInfeasibilities_ = value;
00662 }
00664 inline double sumOfRelaxedPrimalInfeasibilities() const {
00665 return sumOfRelaxedPrimalInfeasibilities_;
00666 }
00667 inline void setSumOfRelaxedPrimalInfeasibilities(double value) {
00668 sumOfRelaxedPrimalInfeasibilities_ = value;
00669 }
00671 inline int numberPrimalInfeasibilities() const {
00672 return numberPrimalInfeasibilities_;
00673 }
00674 inline void setNumberPrimalInfeasibilities(int value) {
00675 numberPrimalInfeasibilities_ = value;
00676 }
00683 int saveModel(const char * fileName);
00686 int restoreModel(const char * fileName);
00687
00695 void checkSolution(int setToBounds = 0);
00698 void checkSolutionInternal();
00700 void checkUnscaledSolution();
00702 inline CoinIndexedVector * rowArray(int index) const {
00703 return rowArray_[index];
00704 }
00706 inline CoinIndexedVector * columnArray(int index) const {
00707 return columnArray_[index];
00708 }
00710
00711
00717 int getSolution ( const double * rowActivities,
00718 const double * columnActivities);
00722 int getSolution ();
00729 int createPiecewiseLinearCosts(const int * starts,
00730 const double * lower, const double * gradient);
00732 inline ClpDualRowPivot * dualRowPivot() const {
00733 return dualRowPivot_;
00734 }
00736 inline ClpPrimalColumnPivot * primalColumnPivot() const {
00737 return primalColumnPivot_;
00738 }
00740 inline bool goodAccuracy() const {
00741 return (largestPrimalError_ < 1.0e-7 && largestDualError_ < 1.0e-7);
00742 }
00744 void returnModel(ClpSimplex & otherModel);
00752 int internalFactorize(int solveType);
00754 ClpDataSave saveData() ;
00756 void restoreData(ClpDataSave saved);
00758 void cleanStatus();
00760 int factorize();
00763 void computeDuals(double * givenDjs);
00765 void computePrimals ( const double * rowActivities,
00766 const double * columnActivities);
00768 void add(double * array,
00769 int column, double multiplier) const;
00775 void unpack(CoinIndexedVector * rowArray) const ;
00781 void unpack(CoinIndexedVector * rowArray, int sequence) const;
00788 void unpackPacked(CoinIndexedVector * rowArray) ;
00795 void unpackPacked(CoinIndexedVector * rowArray, int sequence);
00796 #ifndef CLP_USER_DRIVEN
00797 protected:
00798 #endif
00799
00803 int housekeeping(double objectiveChange);
00806 void checkPrimalSolution(const double * rowActivities = NULL,
00807 const double * columnActivies = NULL);
00810 void checkDualSolution();
00812 void checkBothSolutions();
00817 double scaleObjective(double value);
00819 int solveDW(CoinStructuredModel * model);
00821 int solveBenders(CoinStructuredModel * model);
00822 public:
00833 void setValuesPassAction(double incomingInfeasibility,
00834 double allowedInfeasibility);
00837 int cleanFactorization(int ifValuesPass);
00839
00841 public:
00843 inline double alphaAccuracy() const {
00844 return alphaAccuracy_;
00845 }
00846 inline void setAlphaAccuracy(double value) {
00847 alphaAccuracy_ = value;
00848 }
00849 public:
00851
00852
00853
00855 inline void setDisasterHandler(ClpDisasterHandler * handler) {
00856 disasterArea_ = handler;
00857 }
00859 inline ClpDisasterHandler * disasterHandler() const {
00860 return disasterArea_;
00861 }
00863 inline double largeValue() const {
00864 return largeValue_;
00865 }
00866 void setLargeValue( double value) ;
00868 inline double largestPrimalError() const {
00869 return largestPrimalError_;
00870 }
00872 inline double largestDualError() const {
00873 return largestDualError_;
00874 }
00876 inline void setLargestPrimalError(double value) {
00877 largestPrimalError_ = value;
00878 }
00880 inline void setLargestDualError(double value) {
00881 largestDualError_ = value;
00882 }
00884 inline double zeroTolerance() const {
00885 return zeroTolerance_;
00886 }
00888 inline void setZeroTolerance( double value) {
00889 zeroTolerance_ = value;
00890 }
00892 inline int * pivotVariable() const {
00893 return pivotVariable_;
00894 }
00896 inline bool automaticScaling() const {
00897 return automaticScale_ != 0;
00898 }
00899 inline void setAutomaticScaling(bool onOff) {
00900 automaticScale_ = onOff ? 1 : 0;
00901 }
00903 inline double currentDualTolerance() const {
00904 return dualTolerance_;
00905 }
00906 inline void setCurrentDualTolerance(double value) {
00907 dualTolerance_ = value;
00908 }
00910 inline double currentPrimalTolerance() const {
00911 return primalTolerance_;
00912 }
00913 inline void setCurrentPrimalTolerance(double value) {
00914 primalTolerance_ = value;
00915 }
00917 inline int numberRefinements() const {
00918 return numberRefinements_;
00919 }
00920 void setNumberRefinements( int value) ;
00922 inline double alpha() const {
00923 return alpha_;
00924 }
00925 inline void setAlpha(double value) {
00926 alpha_ = value;
00927 }
00929 inline double dualIn() const {
00930 return dualIn_;
00931 }
00933 inline void setDualIn(double value) {
00934 dualIn_ = value;
00935 }
00937 inline int pivotRow() const {
00938 return pivotRow_;
00939 }
00940 inline void setPivotRow(int value) {
00941 pivotRow_ = value;
00942 }
00944 double valueIncomingDual() const;
00946
00947 #ifndef CLP_USER_DRIVEN
00948 protected:
00949 #endif
00950
00955 int gutsOfSolution ( double * givenDuals,
00956 const double * givenPrimals,
00957 bool valuesPass = false);
00959 void gutsOfDelete(int type);
00961 void gutsOfCopy(const ClpSimplex & rhs);
00973 bool createRim(int what, bool makeRowCopy = false, int startFinishOptions = 0);
00975 void createRim1(bool initial);
00977 void createRim4(bool initial);
00979 void createRim5(bool initial);
00984 void deleteRim(int getRidOfFactorizationData = 2);
00986 bool sanityCheck();
00988 public:
00993 inline double * solutionRegion(int section) const {
00994 if (!section) return rowActivityWork_;
00995 else return columnActivityWork_;
00996 }
00997 inline double * djRegion(int section) const {
00998 if (!section) return rowReducedCost_;
00999 else return reducedCostWork_;
01000 }
01001 inline double * lowerRegion(int section) const {
01002 if (!section) return rowLowerWork_;
01003 else return columnLowerWork_;
01004 }
01005 inline double * upperRegion(int section) const {
01006 if (!section) return rowUpperWork_;
01007 else return columnUpperWork_;
01008 }
01009 inline double * costRegion(int section) const {
01010 if (!section) return rowObjectiveWork_;
01011 else return objectiveWork_;
01012 }
01014 inline double * solutionRegion() const {
01015 return solution_;
01016 }
01017 inline double * djRegion() const {
01018 return dj_;
01019 }
01020 inline double * lowerRegion() const {
01021 return lower_;
01022 }
01023 inline double * upperRegion() const {
01024 return upper_;
01025 }
01026 inline double * costRegion() const {
01027 return cost_;
01028 }
01029 inline Status getStatus(int sequence) const {
01030 return static_cast<Status> (status_[sequence] & 7);
01031 }
01032 inline void setStatus(int sequence, Status newstatus) {
01033 unsigned char & st_byte = status_[sequence];
01034 st_byte = static_cast<unsigned char>(st_byte & ~7);
01035 st_byte = static_cast<unsigned char>(st_byte | newstatus);
01036 }
01038 bool startPermanentArrays();
01043 void setInitialDenseFactorization(bool onOff);
01044 bool initialDenseFactorization() const;
01046 inline int sequenceIn() const {
01047 return sequenceIn_;
01048 }
01049 inline int sequenceOut() const {
01050 return sequenceOut_;
01051 }
01053 inline void setSequenceIn(int sequence) {
01054 sequenceIn_ = sequence;
01055 }
01056 inline void setSequenceOut(int sequence) {
01057 sequenceOut_ = sequence;
01058 }
01060 inline int directionIn() const {
01061 return directionIn_;
01062 }
01063 inline int directionOut() const {
01064 return directionOut_;
01065 }
01067 inline void setDirectionIn(int direction) {
01068 directionIn_ = direction;
01069 }
01070 inline void setDirectionOut(int direction) {
01071 directionOut_ = direction;
01072 }
01074 inline double valueOut() const {
01075 return valueOut_;
01076 }
01078 inline void setValueOut(double value) {
01079 valueOut_ = value;
01080 }
01082 inline double dualOut() const {
01083 return dualOut_;
01084 }
01086 inline void setDualOut(double value) {
01087 dualOut_ = value;
01088 }
01090 inline void setLowerOut(double value) {
01091 lowerOut_ = value;
01092 }
01094 inline void setUpperOut(double value) {
01095 upperOut_ = value;
01096 }
01098 inline void setTheta(double value) {
01099 theta_ = value;
01100 }
01102 inline int isColumn(int sequence) const {
01103 return sequence < numberColumns_ ? 1 : 0;
01104 }
01106 inline int sequenceWithin(int sequence) const {
01107 return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
01108 }
01110 inline double solution(int sequence) {
01111 return solution_[sequence];
01112 }
01114 inline double & solutionAddress(int sequence) {
01115 return solution_[sequence];
01116 }
01117 inline double reducedCost(int sequence) {
01118 return dj_[sequence];
01119 }
01120 inline double & reducedCostAddress(int sequence) {
01121 return dj_[sequence];
01122 }
01123 inline double lower(int sequence) {
01124 return lower_[sequence];
01125 }
01127 inline double & lowerAddress(int sequence) {
01128 return lower_[sequence];
01129 }
01130 inline double upper(int sequence) {
01131 return upper_[sequence];
01132 }
01134 inline double & upperAddress(int sequence) {
01135 return upper_[sequence];
01136 }
01137 inline double cost(int sequence) {
01138 return cost_[sequence];
01139 }
01141 inline double & costAddress(int sequence) {
01142 return cost_[sequence];
01143 }
01145 inline double originalLower(int iSequence) const {
01146 if (iSequence < numberColumns_) return columnLower_[iSequence];
01147 else
01148 return rowLower_[iSequence-numberColumns_];
01149 }
01151 inline double originalUpper(int iSequence) const {
01152 if (iSequence < numberColumns_) return columnUpper_[iSequence];
01153 else
01154 return rowUpper_[iSequence-numberColumns_];
01155 }
01157 inline double theta() const {
01158 return theta_;
01159 }
01162 inline double bestPossibleImprovement() const {
01163 return bestPossibleImprovement_;
01164 }
01166 inline ClpNonLinearCost * nonLinearCost() const {
01167 return nonLinearCost_;
01168 }
01188 inline int moreSpecialOptions() const {
01189 return moreSpecialOptions_;
01190 }
01211 inline void setMoreSpecialOptions(int value) {
01212 moreSpecialOptions_ = value;
01213 }
01215
01217 inline void setFakeBound(int sequence, FakeBound fakeBound) {
01218 unsigned char & st_byte = status_[sequence];
01219 st_byte = static_cast<unsigned char>(st_byte & ~24);
01220 st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3));
01221 }
01222 inline FakeBound getFakeBound(int sequence) const {
01223 return static_cast<FakeBound> ((status_[sequence] >> 3) & 3);
01224 }
01225 inline void setRowStatus(int sequence, Status newstatus) {
01226 unsigned char & st_byte = status_[sequence+numberColumns_];
01227 st_byte = static_cast<unsigned char>(st_byte & ~7);
01228 st_byte = static_cast<unsigned char>(st_byte | newstatus);
01229 }
01230 inline Status getRowStatus(int sequence) const {
01231 return static_cast<Status> (status_[sequence+numberColumns_] & 7);
01232 }
01233 inline void setColumnStatus(int sequence, Status newstatus) {
01234 unsigned char & st_byte = status_[sequence];
01235 st_byte = static_cast<unsigned char>(st_byte & ~7);
01236 st_byte = static_cast<unsigned char>(st_byte | newstatus);
01237 }
01238 inline Status getColumnStatus(int sequence) const {
01239 return static_cast<Status> (status_[sequence] & 7);
01240 }
01241 inline void setPivoted( int sequence) {
01242 status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32);
01243 }
01244 inline void clearPivoted( int sequence) {
01245 status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32);
01246 }
01247 inline bool pivoted(int sequence) const {
01248 return (((status_[sequence] >> 5) & 1) != 0);
01249 }
01251 void setFlagged( int sequence);
01252 inline void clearFlagged( int sequence) {
01253 status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64);
01254 }
01255 inline bool flagged(int sequence) const {
01256 return ((status_[sequence] & 64) != 0);
01257 }
01259 inline void setActive( int iRow) {
01260 status_[iRow] = static_cast<unsigned char>(status_[iRow] | 128);
01261 }
01262 inline void clearActive( int iRow) {
01263 status_[iRow] = static_cast<unsigned char>(status_[iRow] & ~128);
01264 }
01265 inline bool active(int iRow) const {
01266 return ((status_[iRow] & 128) != 0);
01267 }
01270 void createStatus() ;
01273 void allSlackBasis(bool resetSolution = false);
01274
01276 inline int lastBadIteration() const {
01277 return lastBadIteration_;
01278 }
01280 inline void setLastBadIteration(int value) {
01281 lastBadIteration_=value;
01282 }
01284 inline int progressFlag() const {
01285 return (progressFlag_ & 3);
01286 }
01288 inline ClpSimplexProgress * progress()
01289 { return &progress_;}
01291 inline int forceFactorization() const {
01292 return forceFactorization_ ;
01293 }
01295 inline void forceFactorization(int value) {
01296 forceFactorization_ = value;
01297 }
01299 inline double rawObjectiveValue() const {
01300 return objectiveValue_;
01301 }
01303 void computeObjectiveValue(bool useWorkingSolution = false);
01305 double computeInternalObjectiveValue();
01308 double * infeasibilityRay(bool fullRay=false) const;
01312 inline int numberExtraRows() const {
01313 return numberExtraRows_;
01314 }
01317 inline int maximumBasic() const {
01318 return maximumBasic_;
01319 }
01321 inline int baseIteration() const {
01322 return baseIteration_;
01323 }
01325 void generateCpp( FILE * fp, bool defaultFactor = false);
01327 ClpFactorization * getEmptyFactorization();
01329 void setEmptyFactorization();
01331 void moveInfo(const ClpSimplex & rhs, bool justStatus = false);
01333
01335
01336
01337
01339 void getBInvARow(int row, double* z, double * slack = NULL);
01340
01342 void getBInvRow(int row, double* z);
01343
01345 void getBInvACol(int col, double* vec);
01346
01348 void getBInvCol(int col, double* vec);
01349
01354 void getBasics(int* index);
01355
01357
01361 void setObjectiveCoefficient( int elementIndex, double elementValue );
01363 inline void setObjCoeff( int elementIndex, double elementValue ) {
01364 setObjectiveCoefficient( elementIndex, elementValue);
01365 }
01366
01369 void setColumnLower( int elementIndex, double elementValue );
01370
01373 void setColumnUpper( int elementIndex, double elementValue );
01374
01376 void setColumnBounds( int elementIndex,
01377 double lower, double upper );
01378
01387 void setColumnSetBounds(const int* indexFirst,
01388 const int* indexLast,
01389 const double* boundList);
01390
01393 inline void setColLower( int elementIndex, double elementValue ) {
01394 setColumnLower(elementIndex, elementValue);
01395 }
01398 inline void setColUpper( int elementIndex, double elementValue ) {
01399 setColumnUpper(elementIndex, elementValue);
01400 }
01401
01403 inline void setColBounds( int elementIndex,
01404 double newlower, double newupper ) {
01405 setColumnBounds(elementIndex, newlower, newupper);
01406 }
01407
01414 inline void setColSetBounds(const int* indexFirst,
01415 const int* indexLast,
01416 const double* boundList) {
01417 setColumnSetBounds(indexFirst, indexLast, boundList);
01418 }
01419
01422 void setRowLower( int elementIndex, double elementValue );
01423
01426 void setRowUpper( int elementIndex, double elementValue ) ;
01427
01429 void setRowBounds( int elementIndex,
01430 double lower, double upper ) ;
01431
01438 void setRowSetBounds(const int* indexFirst,
01439 const int* indexLast,
01440 const double* boundList);
01442 void resize (int newNumberRows, int newNumberColumns);
01443
01445
01447 protected:
01448
01457 double bestPossibleImprovement_;
01459 double zeroTolerance_;
01461 int columnPrimalSequence_;
01463 int rowPrimalSequence_;
01465 double bestObjectiveValue_;
01467 int moreSpecialOptions_;
01469 int baseIteration_;
01471 double primalToleranceToGetOptimal_;
01473 double largeValue_;
01475 double largestPrimalError_;
01477 double largestDualError_;
01479 double alphaAccuracy_;
01481 double dualBound_;
01483 double alpha_;
01485 double theta_;
01487 double lowerIn_;
01489 double valueIn_;
01491 double upperIn_;
01493 double dualIn_;
01495 double lowerOut_;
01497 double valueOut_;
01499 double upperOut_;
01501 double dualOut_;
01503 double dualTolerance_;
01505 double primalTolerance_;
01507 double sumDualInfeasibilities_;
01509 double sumPrimalInfeasibilities_;
01511 double infeasibilityCost_;
01513 double sumOfRelaxedDualInfeasibilities_;
01515 double sumOfRelaxedPrimalInfeasibilities_;
01517 double acceptablePivot_;
01519 double * lower_;
01521 double * rowLowerWork_;
01523 double * columnLowerWork_;
01525 double * upper_;
01527 double * rowUpperWork_;
01529 double * columnUpperWork_;
01531 double * cost_;
01533 double * rowObjectiveWork_;
01535 double * objectiveWork_;
01537 CoinIndexedVector * rowArray_[6];
01539 CoinIndexedVector * columnArray_[6];
01541 int sequenceIn_;
01543 int directionIn_;
01545 int sequenceOut_;
01547 int directionOut_;
01549 int pivotRow_;
01551 int lastGoodIteration_;
01553 double * dj_;
01555 double * rowReducedCost_;
01557 double * reducedCostWork_;
01559 double * solution_;
01561 double * rowActivityWork_;
01563 double * columnActivityWork_;
01565 int numberDualInfeasibilities_;
01567 int numberDualInfeasibilitiesWithoutFree_;
01569 int numberPrimalInfeasibilities_;
01571 int numberRefinements_;
01573 ClpDualRowPivot * dualRowPivot_;
01575 ClpPrimalColumnPivot * primalColumnPivot_;
01577 int * pivotVariable_;
01579 ClpFactorization * factorization_;
01581 double * savedSolution_;
01583 int numberTimesOptimal_;
01585 ClpDisasterHandler * disasterArea_;
01587 int changeMade_;
01589 int algorithm_;
01592 int forceFactorization_;
01600 int perturbation_;
01602 unsigned char * saveStatus_;
01607 ClpNonLinearCost * nonLinearCost_;
01609 int lastBadIteration_;
01611 int lastFlaggedIteration_;
01613 int numberFake_;
01615 int numberChanged_;
01617 int progressFlag_;
01619 int firstFree_;
01623 int numberExtraRows_;
01626 int maximumBasic_;
01628 int dontFactorizePivots_;
01638 double incomingInfeasibility_;
01639 double allowedInfeasibility_;
01641 int automaticScale_;
01643 int maximumPerturbationSize_;
01645 double * perturbationArray_;
01647 ClpSimplex * baseModel_;
01649 ClpSimplexProgress progress_;
01650 #ifdef ABC_INHERIT
01651 AbcSimplex * abcSimplex_;
01652 #define CLP_ABC_WANTED 1
01653 #define CLP_ABC_WANTED_PARALLEL 2
01654 #define CLP_ABC_FULL_DONE 8
01655
01656 #endif
01657 #define CLP_ABC_BEEN_FEASIBLE 65536
01658 int abcState_;
01659 public:
01661 mutable int spareIntArray_[4];
01663 mutable double spareDoubleArray_[4];
01664 protected:
01666 friend class OsiClpSolverInterface;
01668 };
01669
01678 void
01679 ClpSimplexUnitTest(const std::string & mpsDir);
01680
01681
01682 #define DEVEX_TRY_NORM 1.0e-4
01683 #define DEVEX_ADD_ONE 1.0
01684 #endif