Clp trunk
ClpModel.hpp
Go to the documentation of this file.
00001 /* $Id$ */
00002 // Copyright (C) 2002, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
00005 
00006 #ifndef ClpModel_H
00007 #define ClpModel_H
00008 
00009 #include "ClpConfig.h"
00010 
00011 #include <iostream>
00012 #include <cassert>
00013 #include <cmath>
00014 #include <vector>
00015 #include <string>
00016 //#ifndef COIN_USE_CLP
00017 //#define COIN_USE_CLP
00018 //#endif
00019 #include "ClpPackedMatrix.hpp"
00020 #include "CoinMessageHandler.hpp"
00021 #include "CoinHelperFunctions.hpp"
00022 #include "CoinTypes.hpp"
00023 #include "CoinFinite.hpp"
00024 #include "ClpParameters.hpp"
00025 #include "ClpObjective.hpp"
00026 class ClpEventHandler;
00036 class CoinBuild;
00037 class CoinModel;
00038 class ClpModel {
00039 
00040 public:
00041 
00047 
00048      ClpModel (bool emptyMessages = false  );
00049 
00054      ClpModel(const ClpModel & rhs, int scalingMode = -1);
00056      ClpModel & operator=(const ClpModel & rhs);
00061      ClpModel (const ClpModel * wholeModel,
00062                int numberRows, const int * whichRows,
00063                int numberColumns, const int * whichColumns,
00064                bool dropNames = true, bool dropIntegers = true);
00066      ~ClpModel (  );
00068 
00082      void loadProblem (  const ClpMatrixBase& matrix,
00083                          const double* collb, const double* colub,
00084                          const double* obj,
00085                          const double* rowlb, const double* rowub,
00086                          const double * rowObjective = NULL);
00087      void loadProblem (  const CoinPackedMatrix& matrix,
00088                          const double* collb, const double* colub,
00089                          const double* obj,
00090                          const double* rowlb, const double* rowub,
00091                          const double * rowObjective = NULL);
00092 
00095      void loadProblem (  const int numcols, const int numrows,
00096                          const CoinBigIndex* start, const int* index,
00097                          const double* value,
00098                          const double* collb, const double* colub,
00099                          const double* obj,
00100                          const double* rowlb, const double* rowub,
00101                          const double * rowObjective = NULL);
00107      int loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne = false);
00109      void loadProblem (  const int numcols, const int numrows,
00110                          const CoinBigIndex* start, const int* index,
00111                          const double* value, const int * length,
00112                          const double* collb, const double* colub,
00113                          const double* obj,
00114                          const double* rowlb, const double* rowub,
00115                          const double * rowObjective = NULL);
00117      void loadQuadraticObjective(const int numberColumns,
00118                                  const CoinBigIndex * start,
00119                                  const int * column, const double * element);
00120      void loadQuadraticObjective (  const CoinPackedMatrix& matrix);
00122      void deleteQuadraticObjective();
00124      void setRowObjective(const double * rowObjective);
00126      int readMps(const char *filename,
00127                  bool keepNames = false,
00128                  bool ignoreErrors = false);
00130      int readGMPL(const char *filename, const char * dataName,
00131                   bool keepNames = false);
00133      void copyInIntegerInformation(const char * information);
00135      void deleteIntegerInformation();
00137      void setContinuous(int index);
00139      void setInteger(int index);
00141      bool isInteger(int index) const;
00143      void resize (int newNumberRows, int newNumberColumns);
00145      void deleteRows(int number, const int * which);
00147      void addRow(int numberInRow, const int * columns,
00148                  const double * elements, double rowLower = -COIN_DBL_MAX,
00149                  double rowUpper = COIN_DBL_MAX);
00151      void addRows(int number, const double * rowLower,
00152                   const double * rowUpper,
00153                   const CoinBigIndex * rowStarts, const int * columns,
00154                   const double * elements);
00156      void addRows(int number, const double * rowLower,
00157                   const double * rowUpper,
00158                   const CoinBigIndex * rowStarts, const int * rowLengths,
00159                   const int * columns,
00160                   const double * elements);
00161 #ifndef CLP_NO_VECTOR
00162      void addRows(int number, const double * rowLower,
00163                   const double * rowUpper,
00164                   const CoinPackedVectorBase * const * rows);
00165 #endif
00166 
00171      int addRows(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
00172                  bool checkDuplicates = true);
00181      int addRows(CoinModel & modelObject, bool tryPlusMinusOne = false,
00182                  bool checkDuplicates = true);
00183 
00185      void deleteColumns(int number, const int * which);
00187      void addColumn(int numberInColumn,
00188                     const int * rows,
00189                     const double * elements,
00190                     double columnLower = 0.0,
00191                     double  columnUpper = COIN_DBL_MAX,
00192                     double  objective = 0.0);
00194      void addColumns(int number, const double * columnLower,
00195                      const double * columnUpper,
00196                      const double * objective,
00197                      const CoinBigIndex * columnStarts, const int * rows,
00198                      const double * elements);
00199      void addColumns(int number, const double * columnLower,
00200                      const double * columnUpper,
00201                      const double * objective,
00202                      const CoinBigIndex * columnStarts, const int * columnLengths,
00203                      const int * rows,
00204                      const double * elements);
00205 #ifndef CLP_NO_VECTOR
00206      void addColumns(int number, const double * columnLower,
00207                      const double * columnUpper,
00208                      const double * objective,
00209                      const CoinPackedVectorBase * const * columns);
00210 #endif
00211 
00216      int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
00217                     bool checkDuplicates = true);
00225      int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
00226                     bool checkDuplicates = true);
00228      inline void modifyCoefficient(int row, int column, double newElement,
00229                                    bool keepZero = false) {
00230           matrix_->modifyCoefficient(row, column, newElement, keepZero);
00231      }
00233      void chgRowLower(const double * rowLower);
00235      void chgRowUpper(const double * rowUpper);
00237      void chgColumnLower(const double * columnLower);
00239      void chgColumnUpper(const double * columnUpper);
00241      void chgObjCoefficients(const double * objIn);
00245      void borrowModel(ClpModel & otherModel);
00248      void returnModel(ClpModel & otherModel);
00249 
00251      void createEmptyMatrix();
00259      int cleanMatrix(double threshold = 1.0e-20);
00261      void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
00262 #ifndef CLP_NO_STD
00263 
00264      void dropNames();
00266      void copyNames(std::vector<std::string> & rowNames,
00267                     std::vector<std::string> & columnNames);
00269      void copyRowNames(const std::vector<std::string> & rowNames, int first, int last);
00271      void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
00273      void copyRowNames(const char * const * rowNames, int first, int last);
00275      void copyColumnNames(const char * const * columnNames, int first, int last);
00277      void setRowName(int rowIndex, std::string & name) ;
00279      void setColumnName(int colIndex, std::string & name) ;
00280 #endif
00281 
00288      int findNetwork(char * rotate, double fractionNeeded = 0.75);
00291      CoinModel * createCoinModel() const;
00292 
00305      int writeMps(const char *filename,
00306                   int formatType = 0, int numberAcross = 2,
00307                   double objSense = 0.0) const ;
00309 
00311 
00312      inline int numberRows() const {
00313           return numberRows_;
00314      }
00315      inline int getNumRows() const {
00316           return numberRows_;
00317      }
00319      inline int getNumCols() const {
00320           return numberColumns_;
00321      }
00322      inline int numberColumns() const {
00323           return numberColumns_;
00324      }
00326      inline double primalTolerance() const {
00327           return dblParam_[ClpPrimalTolerance];
00328      }
00329      void setPrimalTolerance( double value) ;
00331      inline double dualTolerance() const  {
00332           return dblParam_[ClpDualTolerance];
00333      }
00334      void setDualTolerance( double value) ;
00336      inline double primalObjectiveLimit() const {
00337           return dblParam_[ClpPrimalObjectiveLimit];
00338      }
00339      void setPrimalObjectiveLimit(double value);
00341      inline double dualObjectiveLimit() const {
00342           return dblParam_[ClpDualObjectiveLimit];
00343      }
00344      void setDualObjectiveLimit(double value);
00346      inline double objectiveOffset() const {
00347           return dblParam_[ClpObjOffset];
00348      }
00349      void setObjectiveOffset(double value);
00351      inline double presolveTolerance() const {
00352           return dblParam_[ClpPresolveTolerance];
00353      }
00354 #ifndef CLP_NO_STD
00355      inline std::string problemName() const {
00356           return strParam_[ClpProbName];
00357      }
00358 #endif
00359 
00360      inline int numberIterations() const  {
00361           return numberIterations_;
00362      }
00363      inline int getIterationCount() const {
00364           return numberIterations_;
00365      }
00366      inline void setNumberIterations(int numberIterationsNew) {
00367           numberIterations_ = numberIterationsNew;
00368      }
00370      inline int solveType() const {
00371           return solveType_;
00372      }
00373      inline void setSolveType(int type) {
00374           solveType_ = type;
00375      }
00377      inline int maximumIterations() const {
00378           return intParam_[ClpMaxNumIteration];
00379      }
00380      void setMaximumIterations(int value);
00382      inline double maximumSeconds() const {
00383           return dblParam_[ClpMaxSeconds];
00384      }
00385      void setMaximumSeconds(double value);
00387      bool hitMaximumIterations() const;
00397      inline int status() const            {
00398           return problemStatus_;
00399      }
00400      inline int problemStatus() const            {
00401           return problemStatus_;
00402      }
00404      inline void setProblemStatus(int problemStatusNew) {
00405           problemStatus_ = problemStatusNew;
00406      }
00421      inline int secondaryStatus() const            {
00422           return secondaryStatus_;
00423      }
00424      inline void setSecondaryStatus(int newstatus) {
00425           secondaryStatus_ = newstatus;
00426      }
00428      inline bool isAbandoned() const             {
00429           return problemStatus_ == 4;
00430      }
00432      inline bool isProvenOptimal() const         {
00433           return problemStatus_ == 0;
00434      }
00436      inline bool isProvenPrimalInfeasible() const {
00437           return problemStatus_ == 1;
00438      }
00440      inline bool isProvenDualInfeasible() const  {
00441           return problemStatus_ == 2;
00442      }
00444      bool isPrimalObjectiveLimitReached() const ;
00446      bool isDualObjectiveLimitReached() const ;
00448      inline bool isIterationLimitReached() const {
00449           return problemStatus_ == 3;
00450      }
00452      inline double optimizationDirection() const {
00453           return  optimizationDirection_;
00454      }
00455      inline double getObjSense() const    {
00456           return optimizationDirection_;
00457      }
00458      void setOptimizationDirection(double value);
00460      inline double * primalRowSolution() const    {
00461           return rowActivity_;
00462      }
00463      inline const double * getRowActivity() const {
00464           return rowActivity_;
00465      }
00467      inline double * primalColumnSolution() const {
00468           return columnActivity_;
00469      }
00470      inline const double * getColSolution() const {
00471           return columnActivity_;
00472      }
00473      inline void setColSolution(const double * input) {
00474           memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
00475      }
00477      inline double * dualRowSolution() const      {
00478           return dual_;
00479      }
00480      inline const double * getRowPrice() const    {
00481           return dual_;
00482      }
00484      inline double * dualColumnSolution() const   {
00485           return reducedCost_;
00486      }
00487      inline const double * getReducedCost() const {
00488           return reducedCost_;
00489      }
00491      inline double* rowLower() const              {
00492           return rowLower_;
00493      }
00494      inline const double* getRowLower() const     {
00495           return rowLower_;
00496      }
00498      inline double* rowUpper() const              {
00499           return rowUpper_;
00500      }
00501      inline const double* getRowUpper() const     {
00502           return rowUpper_;
00503      }
00504      //-------------------------------------------------------------------------
00508      void setObjectiveCoefficient( int elementIndex, double elementValue );
00510      inline void setObjCoeff( int elementIndex, double elementValue ) {
00511           setObjectiveCoefficient( elementIndex, elementValue);
00512      }
00513 
00516      void setColumnLower( int elementIndex, double elementValue );
00517 
00520      void setColumnUpper( int elementIndex, double elementValue );
00521 
00523      void setColumnBounds( int elementIndex,
00524                            double lower, double upper );
00525 
00534      void setColumnSetBounds(const int* indexFirst,
00535                              const int* indexLast,
00536                              const double* boundList);
00537 
00540      inline void setColLower( int elementIndex, double elementValue ) {
00541           setColumnLower(elementIndex, elementValue);
00542      }
00545      inline void setColUpper( int elementIndex, double elementValue ) {
00546           setColumnUpper(elementIndex, elementValue);
00547      }
00548 
00550      inline void setColBounds( int elementIndex,
00551                                double lower, double upper ) {
00552           setColumnBounds(elementIndex, lower, upper);
00553      }
00554 
00561      inline void setColSetBounds(const int* indexFirst,
00562                                  const int* indexLast,
00563                                  const double* boundList) {
00564           setColumnSetBounds(indexFirst, indexLast, boundList);
00565      }
00566 
00569      void setRowLower( int elementIndex, double elementValue );
00570 
00573      void setRowUpper( int elementIndex, double elementValue ) ;
00574 
00576      void setRowBounds( int elementIndex,
00577                         double lower, double upper ) ;
00578 
00585      void setRowSetBounds(const int* indexFirst,
00586                           const int* indexLast,
00587                           const double* boundList);
00588 
00590 
00591      inline const double * rowScale() const {
00592           return rowScale_;
00593      }
00594      inline const double * columnScale() const {
00595           return columnScale_;
00596      }
00597      inline const double * inverseRowScale() const {
00598           return inverseRowScale_;
00599      }
00600      inline const double * inverseColumnScale() const {
00601           return inverseColumnScale_;
00602      }
00603      inline double * mutableRowScale() const {
00604           return rowScale_;
00605      }
00606      inline double * mutableColumnScale() const {
00607           return columnScale_;
00608      }
00609      inline double * mutableInverseRowScale() const {
00610           return inverseRowScale_;
00611      }
00612      inline double * mutableInverseColumnScale() const {
00613           return inverseColumnScale_;
00614      }
00615      void setRowScale(double * scale) ;
00616      void setColumnScale(double * scale);
00618      inline double objectiveScale() const {
00619           return objectiveScale_;
00620      }
00621      inline void setObjectiveScale(double value) {
00622           objectiveScale_ = value;
00623      }
00625      inline double rhsScale() const {
00626           return rhsScale_;
00627      }
00628      inline void setRhsScale(double value) {
00629           rhsScale_ = value;
00630      }
00632      void scaling(int mode = 1);
00635      void unscale();
00637      inline int scalingFlag() const {
00638           return scalingFlag_;
00639      }
00641      inline double * objective() const {
00642           if (objective_) {
00643                double offset;
00644                return objective_->gradient(NULL, NULL, offset, false);
00645           } else {
00646                return NULL;
00647           }
00648      }
00649      inline double * objective(const double * solution, double & offset, bool refresh = true) const {
00650           offset = 0.0;
00651           if (objective_) {
00652                return objective_->gradient(NULL, solution, offset, refresh);
00653           } else {
00654                return NULL;
00655           }
00656      }
00657      inline const double * getObjCoefficients() const {
00658           if (objective_) {
00659                double offset;
00660                return objective_->gradient(NULL, NULL, offset, false);
00661           } else {
00662                return NULL;
00663           }
00664      }
00666      inline double * rowObjective() const         {
00667           return rowObjective_;
00668      }
00669      inline const double * getRowObjCoefficients() const {
00670           return rowObjective_;
00671      }
00673      inline double * columnLower() const          {
00674           return columnLower_;
00675      }
00676      inline const double * getColLower() const    {
00677           return columnLower_;
00678      }
00680      inline double * columnUpper() const          {
00681           return columnUpper_;
00682      }
00683      inline const double * getColUpper() const    {
00684           return columnUpper_;
00685      }
00687      inline CoinPackedMatrix * matrix() const {
00688           if ( matrix_ == NULL ) return NULL;
00689           else return matrix_->getPackedMatrix();
00690      }
00692      inline int getNumElements() const {
00693           return matrix_->getNumElements();
00694      }
00697      inline double getSmallElementValue() const {
00698           return smallElement_;
00699      }
00700      inline void setSmallElementValue(double value) {
00701           smallElement_ = value;
00702      }
00704      inline ClpMatrixBase * rowCopy() const       {
00705           return rowCopy_;
00706      }
00708      void setNewRowCopy(ClpMatrixBase * newCopy);
00710      inline ClpMatrixBase * clpMatrix() const     {
00711           return matrix_;
00712      }
00714      inline ClpPackedMatrix * clpScaledMatrix() const     {
00715           return scaledMatrix_;
00716      }
00718      inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
00719           delete scaledMatrix_;
00720           scaledMatrix_ = scaledMatrix;
00721      }
00727      void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
00733      inline void replaceMatrix(CoinPackedMatrix * newmatrix,
00734                                bool deleteCurrent = false) {
00735           replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
00736      }
00738      inline double objectiveValue() const {
00739           return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
00740      }
00741      inline void setObjectiveValue(double value) {
00742           objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
00743      }
00744      inline double getObjValue() const {
00745           return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
00746      }
00748      inline char * integerInformation() const     {
00749           return integerType_;
00750      }
00753      double * infeasibilityRay() const;
00754      double * unboundedRay() const;
00756      inline bool rayExists() const {
00757          return (ray_!=NULL);
00758      }
00760      inline void deleteRay() {
00761          delete [] ray_;
00762          ray_=NULL;
00763      }
00765      inline bool statusExists() const {
00766           return (status_ != NULL);
00767      }
00769      inline unsigned char *  statusArray() const {
00770           return status_;
00771      }
00774      unsigned char *  statusCopy() const;
00776      void copyinStatus(const unsigned char * statusArray);
00777 
00779      inline void setUserPointer (void * pointer) {
00780           userPointer_ = pointer;
00781      }
00782      inline void * getUserPointer () const {
00783           return userPointer_;
00784      }
00786      inline void setTrustedUserPointer (ClpTrustedData * pointer) {
00787           trustedUserPointer_ = pointer;
00788      }
00789      inline ClpTrustedData * getTrustedUserPointer () const {
00790           return trustedUserPointer_;
00791      }
00793      inline int whatsChanged() const {
00794           return whatsChanged_;
00795      }
00796      inline void setWhatsChanged(int value) {
00797           whatsChanged_ = value;
00798      }
00800      inline int numberThreads() const {
00801           return numberThreads_;
00802      }
00803      inline void setNumberThreads(int value) {
00804           numberThreads_ = value;
00805      }
00807 
00809 
00810      void passInMessageHandler(CoinMessageHandler * handler);
00812      CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
00813                                              bool & oldDefault);
00815      void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
00817      void newLanguage(CoinMessages::Language language);
00818      inline void setLanguage(CoinMessages::Language language) {
00819           newLanguage(language);
00820      }
00822      inline CoinMessageHandler * messageHandler() const       {
00823           return handler_;
00824      }
00826      inline CoinMessages messages() const                     {
00827           return messages_;
00828      }
00830      inline CoinMessages * messagesPointer()                  {
00831           return & messages_;
00832      }
00834      inline CoinMessages coinMessages() const                  {
00835           return coinMessages_;
00836      }
00838      inline CoinMessages * coinMessagesPointer()                  {
00839           return & coinMessages_;
00840      }
00849      inline void setLogLevel(int value)    {
00850           handler_->setLogLevel(value);
00851      }
00852      inline int logLevel() const           {
00853           return handler_->logLevel();
00854      }
00856      inline bool defaultHandler() const {
00857           return defaultHandler_;
00858      }
00860      void passInEventHandler(const ClpEventHandler * eventHandler);
00862      inline ClpEventHandler * eventHandler() const {
00863           return eventHandler_;
00864      }
00866      inline CoinThreadRandom * randomNumberGenerator() {
00867           return &randomNumberGenerator_;
00868      }
00870      inline CoinThreadRandom & mutableRandomNumberGenerator() {
00871           return randomNumberGenerator_;
00872      }
00874      inline void setRandomSeed(int value) {
00875           randomNumberGenerator_.setSeed(value);
00876      }
00878      inline int lengthNames() const {
00879           return lengthNames_;
00880      }
00881 #ifndef CLP_NO_STD
00882 
00883      inline void setLengthNames(int value) {
00884           lengthNames_ = value;
00885      }
00887      inline const std::vector<std::string> * rowNames() const {
00888           return &rowNames_;
00889      }
00890      inline const std::string& rowName(int iRow) const {
00891           return rowNames_[iRow];
00892      }
00894      std::string getRowName(int iRow) const;
00896      inline const std::vector<std::string> * columnNames() const {
00897           return &columnNames_;
00898      }
00899      inline const std::string& columnName(int iColumn) const {
00900           return columnNames_[iColumn];
00901      }
00903      std::string getColumnName(int iColumn) const;
00904 #endif
00905 
00906      inline ClpObjective * objectiveAsObject() const {
00907           return objective_;
00908      }
00909      void setObjective(ClpObjective * objective);
00910      inline void setObjectivePointer(ClpObjective * newobjective) {
00911           objective_ = newobjective;
00912      }
00915      int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
00916 
00918 
00927      void times(double scalar,
00928                 const double * x, double * y) const;
00932      void transposeTimes(double scalar,
00933                          const double * x, double * y) const ;
00935 
00936 
00937      //---------------------------------------------------------------------------
00955 
00956      bool setIntParam(ClpIntParam key, int value) ;
00958      bool setDblParam(ClpDblParam key, double value) ;
00959 #ifndef CLP_NO_STD
00960 
00961      bool setStrParam(ClpStrParam key, const std::string & value);
00962 #endif
00963      // Get an integer parameter
00964      inline bool getIntParam(ClpIntParam key, int& value) const {
00965           if (key < ClpLastIntParam) {
00966                value = intParam_[key];
00967                return true;
00968           } else {
00969                return false;
00970           }
00971      }
00972      // Get an double parameter
00973      inline bool getDblParam(ClpDblParam key, double& value) const {
00974           if (key < ClpLastDblParam) {
00975                value = dblParam_[key];
00976                return true;
00977           } else {
00978                return false;
00979           }
00980      }
00981 #ifndef CLP_NO_STD
00982      // Get a string parameter
00983      inline bool getStrParam(ClpStrParam key, std::string& value) const {
00984           if (key < ClpLastStrParam) {
00985                value = strParam_[key];
00986                return true;
00987           } else {
00988                return false;
00989           }
00990      }
00991 #endif
00992 
00993      void generateCpp( FILE * fp);
01026      inline unsigned int specialOptions() const {
01027           return specialOptions_;
01028      }
01029      void setSpecialOptions(unsigned int value);
01030 #define COIN_CBC_USING_CLP 0x01000000
01031      inline bool inCbcBranchAndBound() const {
01032           return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
01033      }
01035 
01038 protected:
01040      void gutsOfDelete(int type);
01044      void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
01046      void getRowBound(int iRow, double& lower, double& upper) const;
01048      void gutsOfLoadModel ( int numberRows, int numberColumns,
01049                             const double* collb, const double* colub,
01050                             const double* obj,
01051                             const double* rowlb, const double* rowub,
01052                             const double * rowObjective = NULL);
01054      void gutsOfScaling();
01056      inline double rawObjectiveValue() const {
01057           return objectiveValue_;
01058      }
01060      inline bool permanentArrays() const {
01061           return (specialOptions_ & 65536) != 0;
01062      }
01064      void startPermanentArrays();
01066      void stopPermanentArrays();
01068      const char * const * rowNamesAsChar() const;
01070      const char * const * columnNamesAsChar() const;
01072      void deleteNamesAsChar(const char * const * names, int number) const;
01074      void onStopped();
01076 
01077 
01079 protected:
01080 
01083 
01084      double optimizationDirection_;
01086      double dblParam_[ClpLastDblParam];
01088      double objectiveValue_;
01090      double smallElement_;
01092      double objectiveScale_;
01094      double rhsScale_;
01096      int numberRows_;
01098      int numberColumns_;
01100      double * rowActivity_;
01102      double * columnActivity_;
01104      double * dual_;
01106      double * reducedCost_;
01108      double* rowLower_;
01110      double* rowUpper_;
01112      ClpObjective * objective_;
01114      double * rowObjective_;
01116      double * columnLower_;
01118      double * columnUpper_;
01120      ClpMatrixBase * matrix_;
01122      ClpMatrixBase * rowCopy_;
01124      ClpPackedMatrix * scaledMatrix_;
01126      double * ray_;
01128      double * rowScale_;
01130      double * columnScale_;
01132      double * inverseRowScale_;
01134      double * inverseColumnScale_;
01137      int scalingFlag_;
01145      unsigned char * status_;
01147      char * integerType_;
01149      void * userPointer_;
01151      ClpTrustedData * trustedUserPointer_;
01153      int intParam_[ClpLastIntParam];
01155      int numberIterations_;
01157      int solveType_;
01174      unsigned int whatsChanged_;
01176      int problemStatus_;
01178      int secondaryStatus_;
01180      int lengthNames_;
01182      int numberThreads_;
01186      unsigned int specialOptions_;
01188      CoinMessageHandler * handler_;
01190      bool defaultHandler_;
01192      CoinThreadRandom randomNumberGenerator_;
01194      ClpEventHandler * eventHandler_;
01195 #ifndef CLP_NO_STD
01196 
01197      std::vector<std::string> rowNames_;
01199      std::vector<std::string> columnNames_;
01200 #endif
01201 
01202      CoinMessages messages_;
01204      CoinMessages coinMessages_;
01206      int maximumColumns_;
01208      int maximumRows_;
01210      int maximumInternalColumns_;
01212      int maximumInternalRows_;
01214      CoinPackedMatrix baseMatrix_;
01216      CoinPackedMatrix baseRowCopy_;
01218      double * savedRowScale_;
01220      double * savedColumnScale_;
01221 #ifndef CLP_NO_STD
01222 
01223      std::string strParam_[ClpLastStrParam];
01224 #endif
01225 
01226 };
01229 class ClpDataSave {
01230 
01231 public:
01235 
01236      ClpDataSave (  );
01237 
01239      ClpDataSave(const ClpDataSave &);
01241      ClpDataSave & operator=(const ClpDataSave & rhs);
01243      ~ClpDataSave (  );
01244 
01246 
01248 public:
01249 
01252      double dualBound_;
01253      double infeasibilityCost_;
01254      double pivotTolerance_;
01255      double zeroFactorizationTolerance_;
01256      double zeroSimplexTolerance_;
01257      double acceptablePivot_;
01258      double objectiveScale_;
01259      int sparseThreshold_;
01260      int perturbation_;
01261      int forceFactorization_;
01262      int scalingFlag_;
01263      unsigned int specialOptions_;
01265 };
01266 
01267 #endif
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Defines