# ClpModel.hpp

Go to the documentation of this file.

    00001 /* $Id: ClpModel.hpp 2047 2014-08-20 07:06:32Z forrest $ */
    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 deleteRowsAndColumns(int numberRows, const int * whichRows,
    00188                                int numberColumns, const int * whichColumns);
    00190      void addColumn(int numberInColumn,
    00191                     const int * rows,
    00192                     const double * elements,
    00193                     double columnLower = 0.0,
    00194                     double  columnUpper = COIN_DBL_MAX,
    00195                     double  objective = 0.0);
    00197      void addColumns(int number, const double * columnLower,
    00198                      const double * columnUpper,
    00199                      const double * objective,
    00200                      const CoinBigIndex * columnStarts, const int * rows,
    00201                      const double * elements);
    00202      void addColumns(int number, const double * columnLower,
    00203                      const double * columnUpper,
    00204                      const double * objective,
    00205                      const CoinBigIndex * columnStarts, const int * columnLengths,
    00206                      const int * rows,
    00207                      const double * elements);
    00208 #ifndef CLP_NO_VECTOR
    00209      void addColumns(int number, const double * columnLower,
    00210                      const double * columnUpper,
    00211                      const double * objective,
    00212                      const CoinPackedVectorBase * const * columns);
    00213 #endif
    00214
    00219      int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
    00220                     bool checkDuplicates = true);
    00228      int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
    00229                     bool checkDuplicates = true);
    00231      inline void modifyCoefficient(int row, int column, double newElement,
    00232                                    bool keepZero = false) {
    00233           matrix_->modifyCoefficient(row, column, newElement, keepZero);
    00234      }
    00236      void chgRowLower(const double * rowLower);
    00238      void chgRowUpper(const double * rowUpper);
    00240      void chgColumnLower(const double * columnLower);
    00242      void chgColumnUpper(const double * columnUpper);
    00244      void chgObjCoefficients(const double * objIn);
    00248      void borrowModel(ClpModel & otherModel);
    00251      void returnModel(ClpModel & otherModel);
    00252
    00254      void createEmptyMatrix();
    00262      int cleanMatrix(double threshold = 1.0e-20);
    00264      void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
    00265 #ifndef CLP_NO_STD
    00267      void dropNames();
    00269      void copyNames(const std::vector<std::string> & rowNames,
    00270                     const std::vector<std::string> & columnNames);
    00272      void copyRowNames(const std::vector<std::string> & rowNames, int first, int last);
    00274      void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
    00276      void copyRowNames(const char * const * rowNames, int first, int last);
    00278      void copyColumnNames(const char * const * columnNames, int first, int last);
    00280      void setRowName(int rowIndex, std::string & name) ;
    00282      void setColumnName(int colIndex, std::string & name) ;
    00283 #endif
    00284
    00291      int findNetwork(char * rotate, double fractionNeeded = 0.75);
    00294      CoinModel * createCoinModel() const;
    00295
    00308      int writeMps(const char *filename,
    00309                   int formatType = 0, int numberAcross = 2,
    00310                   double objSense = 0.0) const ;
    00312
    00314
    00315      inline int numberRows() const {
    00316           return numberRows_;
    00317      }
    00318      inline int getNumRows() const {
    00319           return numberRows_;
    00320      }
    00322      inline int getNumCols() const {
    00323           return numberColumns_;
    00324      }
    00325      inline int numberColumns() const {
    00326           return numberColumns_;
    00327      }
    00329      inline double primalTolerance() const {
    00330           return dblParam_[ClpPrimalTolerance];
    00331      }
    00332      void setPrimalTolerance( double value) ;
    00334      inline double dualTolerance() const  {
    00335           return dblParam_[ClpDualTolerance];
    00336      }
    00337      void setDualTolerance( double value) ;
    00339      inline double primalObjectiveLimit() const {
    00340           return dblParam_[ClpPrimalObjectiveLimit];
    00341      }
    00342      void setPrimalObjectiveLimit(double value);
    00344      inline double dualObjectiveLimit() const {
    00345           return dblParam_[ClpDualObjectiveLimit];
    00346      }
    00347      void setDualObjectiveLimit(double value);
    00349      inline double objectiveOffset() const {
    00350           return dblParam_[ClpObjOffset];
    00351      }
    00352      void setObjectiveOffset(double value);
    00354      inline double presolveTolerance() const {
    00355           return dblParam_[ClpPresolveTolerance];
    00356      }
    00357 #ifndef CLP_NO_STD
    00358      inline const std::string & problemName() const {
    00359           return strParam_[ClpProbName];
    00360      }
    00361 #endif
    00363      inline int numberIterations() const  {
    00364           return numberIterations_;
    00365      }
    00366      inline int getIterationCount() const {
    00367           return numberIterations_;
    00368      }
    00369      inline void setNumberIterations(int numberIterationsNew) {
    00370           numberIterations_ = numberIterationsNew;
    00371      }
    00373      inline int solveType() const {
    00374           return solveType_;
    00375      }
    00376      inline void setSolveType(int type) {
    00377           solveType_ = type;
    00378      }
    00380      inline int maximumIterations() const {
    00381           return intParam_[ClpMaxNumIteration];
    00382      }
    00383      void setMaximumIterations(int value);
    00385      inline double maximumSeconds() const {
    00386           return dblParam_[ClpMaxSeconds];
    00387      }
    00388      void setMaximumSeconds(double value);
    00389      void setMaximumWallSeconds(double value);
    00391      bool hitMaximumIterations() const;
    00401      inline int status() const            {
    00402           return problemStatus_;
    00403      }
    00404      inline int problemStatus() const            {
    00405           return problemStatus_;
    00406      }
    00408      inline void setProblemStatus(int problemStatusNew) {
    00409           problemStatus_ = problemStatusNew;
    00410      }
    00426      inline int secondaryStatus() const            {
    00427           return secondaryStatus_;
    00428      }
    00429      inline void setSecondaryStatus(int newstatus) {
    00430           secondaryStatus_ = newstatus;
    00431      }
    00433      inline bool isAbandoned() const             {
    00434           return problemStatus_ == 4;
    00435      }
    00437      inline bool isProvenOptimal() const         {
    00438           return problemStatus_ == 0;
    00439      }
    00441      inline bool isProvenPrimalInfeasible() const {
    00442           return problemStatus_ == 1;
    00443      }
    00445      inline bool isProvenDualInfeasible() const  {
    00446           return problemStatus_ == 2;
    00447      }
    00449      bool isPrimalObjectiveLimitReached() const ;
    00451      bool isDualObjectiveLimitReached() const ;
    00453      inline bool isIterationLimitReached() const {
    00454           return problemStatus_ == 3;
    00455      }
    00457      inline double optimizationDirection() const {
    00458           return  optimizationDirection_;
    00459      }
    00460      inline double getObjSense() const    {
    00461           return optimizationDirection_;
    00462      }
    00463      void setOptimizationDirection(double value);
    00465      inline double * primalRowSolution() const    {
    00466           return rowActivity_;
    00467      }
    00468      inline const double * getRowActivity() const {
    00469           return rowActivity_;
    00470      }
    00472      inline double * primalColumnSolution() const {
    00473           return columnActivity_;
    00474      }
    00475      inline const double * getColSolution() const {
    00476           return columnActivity_;
    00477      }
    00478      inline void setColSolution(const double * input) {
    00479           memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
    00480      }
    00482      inline double * dualRowSolution() const      {
    00483           return dual_;
    00484      }
    00485      inline const double * getRowPrice() const    {
    00486           return dual_;
    00487      }
    00489      inline double * dualColumnSolution() const   {
    00490           return reducedCost_;
    00491      }
    00492      inline const double * getReducedCost() const {
    00493           return reducedCost_;
    00494      }
    00496      inline double* rowLower() const              {
    00497           return rowLower_;
    00498      }
    00499      inline const double* getRowLower() const     {
    00500           return rowLower_;
    00501      }
    00503      inline double* rowUpper() const              {
    00504           return rowUpper_;
    00505      }
    00506      inline const double* getRowUpper() const     {
    00507           return rowUpper_;
    00508      }
    00509      //-------------------------------------------------------------------------
    00513      void setObjectiveCoefficient( int elementIndex, double elementValue );
    00515      inline void setObjCoeff( int elementIndex, double elementValue ) {
    00516           setObjectiveCoefficient( elementIndex, elementValue);
    00517      }
    00518
    00521      void setColumnLower( int elementIndex, double elementValue );
    00522
    00525      void setColumnUpper( int elementIndex, double elementValue );
    00526
    00528      void setColumnBounds( int elementIndex,
    00529                            double lower, double upper );
    00530
    00539      void setColumnSetBounds(const int* indexFirst,
    00540                              const int* indexLast,
    00541                              const double* boundList);
    00542
    00545      inline void setColLower( int elementIndex, double elementValue ) {
    00546           setColumnLower(elementIndex, elementValue);
    00547      }
    00550      inline void setColUpper( int elementIndex, double elementValue ) {
    00551           setColumnUpper(elementIndex, elementValue);
    00552      }
    00553
    00555      inline void setColBounds( int elementIndex,
    00556                                double lower, double upper ) {
    00557           setColumnBounds(elementIndex, lower, upper);
    00558      }
    00559
    00566      inline void setColSetBounds(const int* indexFirst,
    00567                                  const int* indexLast,
    00568                                  const double* boundList) {
    00569           setColumnSetBounds(indexFirst, indexLast, boundList);
    00570      }
    00571
    00574      void setRowLower( int elementIndex, double elementValue );
    00575
    00578      void setRowUpper( int elementIndex, double elementValue ) ;
    00579
    00581      void setRowBounds( int elementIndex,
    00582                         double lower, double upper ) ;
    00583
    00590      void setRowSetBounds(const int* indexFirst,
    00591                           const int* indexLast,
    00592                           const double* boundList);
    00593
    00595
    00596      inline const double * rowScale() const {
    00597           return rowScale_;
    00598      }
    00599      inline const double * columnScale() const {
    00600           return columnScale_;
    00601      }
    00602      inline const double * inverseRowScale() const {
    00603           return inverseRowScale_;
    00604      }
    00605      inline const double * inverseColumnScale() const {
    00606           return inverseColumnScale_;
    00607      }
    00608      inline double * mutableRowScale() const {
    00609           return rowScale_;
    00610      }
    00611      inline double * mutableColumnScale() const {
    00612           return columnScale_;
    00613      }
    00614      inline double * mutableInverseRowScale() const {
    00615           return inverseRowScale_;
    00616      }
    00617      inline double * mutableInverseColumnScale() const {
    00618           return inverseColumnScale_;
    00619      }
    00620      inline double * swapRowScale(double * newScale) {
    00621           double * oldScale = rowScale_;
    00622           rowScale_ = newScale;
    00623           return oldScale;
    00624      }
    00625      void setRowScale(double * scale) ;
    00626      void setColumnScale(double * scale);
    00628      inline double objectiveScale() const {
    00629           return objectiveScale_;
    00630      }
    00631      inline void setObjectiveScale(double value) {
    00632           objectiveScale_ = value;
    00633      }
    00635      inline double rhsScale() const {
    00636           return rhsScale_;
    00637      }
    00638      inline void setRhsScale(double value) {
    00639           rhsScale_ = value;
    00640      }
    00642      void scaling(int mode = 1);
    00645      void unscale();
    00647      inline int scalingFlag() const {
    00648           return scalingFlag_;
    00649      }
    00651      inline double * objective() const {
    00652           if (objective_) {
    00653                double offset;
    00654                return objective_->gradient(NULL, NULL, offset, false);
    00655           } else {
    00656                return NULL;
    00657           }
    00658      }
    00659      inline double * objective(const double * solution, double & offset, bool refresh = true) const {
    00660           offset = 0.0;
    00661           if (objective_) {
    00662                return objective_->gradient(NULL, solution, offset, refresh);
    00663           } else {
    00664                return NULL;
    00665           }
    00666      }
    00667      inline const double * getObjCoefficients() const {
    00668           if (objective_) {
    00669                double offset;
    00670                return objective_->gradient(NULL, NULL, offset, false);
    00671           } else {
    00672                return NULL;
    00673           }
    00674      }
    00676      inline double * rowObjective() const         {
    00677           return rowObjective_;
    00678      }
    00679      inline const double * getRowObjCoefficients() const {
    00680           return rowObjective_;
    00681      }
    00683      inline double * columnLower() const          {
    00684           return columnLower_;
    00685      }
    00686      inline const double * getColLower() const    {
    00687           return columnLower_;
    00688      }
    00690      inline double * columnUpper() const          {
    00691           return columnUpper_;
    00692      }
    00693      inline const double * getColUpper() const    {
    00694           return columnUpper_;
    00695      }
    00697      inline CoinPackedMatrix * matrix() const {
    00698           if ( matrix_ == NULL ) return NULL;
    00699           else return matrix_->getPackedMatrix();
    00700      }
    00702      inline int getNumElements() const {
    00703           return matrix_->getNumElements();
    00704      }
    00707      inline double getSmallElementValue() const {
    00708           return smallElement_;
    00709      }
    00710      inline void setSmallElementValue(double value) {
    00711           smallElement_ = value;
    00712      }
    00714      inline ClpMatrixBase * rowCopy() const       {
    00715           return rowCopy_;
    00716      }
    00718      void setNewRowCopy(ClpMatrixBase * newCopy);
    00720      inline ClpMatrixBase * clpMatrix() const     {
    00721           return matrix_;
    00722      }
    00724      inline ClpPackedMatrix * clpScaledMatrix() const     {
    00725           return scaledMatrix_;
    00726      }
    00728      inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
    00729           delete scaledMatrix_;
    00730           scaledMatrix_ = scaledMatrix;
    00731      }
    00733      inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
    00734           ClpPackedMatrix * oldMatrix = scaledMatrix_;
    00735           scaledMatrix_ = scaledMatrix;
    00736           return oldMatrix;
    00737      }
    00743      void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
    00749      inline void replaceMatrix(CoinPackedMatrix * newmatrix,
    00750                                bool deleteCurrent = false) {
    00751           replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
    00752      }
    00754      inline double objectiveValue() const {
    00755           return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
    00756      }
    00757      inline void setObjectiveValue(double value) {
    00758           objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
    00759      }
    00760      inline double getObjValue() const {
    00761           return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
    00762      }
    00764      inline char * integerInformation() const     {
    00765           return integerType_;
    00766      }
    00769      double * infeasibilityRay(bool fullRay=false) const;
    00770      double * unboundedRay() const;
    00772      inline double * ray() const
    00773      { return ray_;}
    00775      inline bool rayExists() const {
    00776          return (ray_!=NULL);
    00777      }
    00779      inline void deleteRay() {
    00780          delete [] ray_;
    00781          ray_=NULL;
    00782      }
    00784          inline const double * internalRay() const {
    00785                  return ray_;
    00786          }
    00788      inline bool statusExists() const {
    00789           return (status_ != NULL);
    00790      }
    00792      inline unsigned char *  statusArray() const {
    00793           return status_;
    00794      }
    00797      unsigned char *  statusCopy() const;
    00799      void copyinStatus(const unsigned char * statusArray);
    00800
    00802      inline void setUserPointer (void * pointer) {
    00803           userPointer_ = pointer;
    00804      }
    00805      inline void * getUserPointer () const {
    00806           return userPointer_;
    00807      }
    00809      inline void setTrustedUserPointer (ClpTrustedData * pointer) {
    00810           trustedUserPointer_ = pointer;
    00811      }
    00812      inline ClpTrustedData * getTrustedUserPointer () const {
    00813           return trustedUserPointer_;
    00814      }
    00816      inline int whatsChanged() const {
    00817           return whatsChanged_;
    00818      }
    00819      inline void setWhatsChanged(int value) {
    00820           whatsChanged_ = value;
    00821      }
    00823      inline int numberThreads() const {
    00824           return numberThreads_;
    00825      }
    00826      inline void setNumberThreads(int value) {
    00827           numberThreads_ = value;
    00828      }
    00830
    00832
    00833      void passInMessageHandler(CoinMessageHandler * handler);
    00835      CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
    00836                                              bool & oldDefault);
    00838      void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
    00840      void newLanguage(CoinMessages::Language language);
    00841      inline void setLanguage(CoinMessages::Language language) {
    00842           newLanguage(language);
    00843      }
    00845      void setDefaultMessageHandler();
    00847      inline CoinMessageHandler * messageHandler() const       {
    00848           return handler_;
    00849      }
    00851      inline CoinMessages messages() const                     {
    00852           return messages_;
    00853      }
    00855      inline CoinMessages * messagesPointer()                  {
    00856           return & messages_;
    00857      }
    00859      inline CoinMessages coinMessages() const                  {
    00860           return coinMessages_;
    00861      }
    00863      inline CoinMessages * coinMessagesPointer()                  {
    00864           return & coinMessages_;
    00865      }
    00874      inline void setLogLevel(int value)    {
    00875           handler_->setLogLevel(value);
    00876      }
    00877      inline int logLevel() const           {
    00878           return handler_->logLevel();
    00879      }
    00881      inline bool defaultHandler() const {
    00882           return defaultHandler_;
    00883      }
    00885      void passInEventHandler(const ClpEventHandler * eventHandler);
    00887      inline ClpEventHandler * eventHandler() const {
    00888           return eventHandler_;
    00889      }
    00891      inline CoinThreadRandom * randomNumberGenerator() {
    00892           return &randomNumberGenerator_;
    00893      }
    00895      inline CoinThreadRandom & mutableRandomNumberGenerator() {
    00896           return randomNumberGenerator_;
    00897      }
    00899      inline void setRandomSeed(int value) {
    00900           randomNumberGenerator_.setSeed(value);
    00901      }
    00903      inline int lengthNames() const {
    00904           return lengthNames_;
    00905      }
    00906 #ifndef CLP_NO_STD
    00908      inline void setLengthNames(int value) {
    00909           lengthNames_ = value;
    00910      }
    00912      inline const std::vector<std::string> * rowNames() const {
    00913           return &rowNames_;
    00914      }
    00915      inline const std::string& rowName(int iRow) const {
    00916           return rowNames_[iRow];
    00917      }
    00919      std::string getRowName(int iRow) const;
    00921      inline const std::vector<std::string> * columnNames() const {
    00922           return &columnNames_;
    00923      }
    00924      inline const std::string& columnName(int iColumn) const {
    00925           return columnNames_[iColumn];
    00926      }
    00928      std::string getColumnName(int iColumn) const;
    00929 #endif
    00931      inline ClpObjective * objectiveAsObject() const {
    00932           return objective_;
    00933      }
    00934      void setObjective(ClpObjective * objective);
    00935      inline void setObjectivePointer(ClpObjective * newobjective) {
    00936           objective_ = newobjective;
    00937      }
    00940      int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
    00941
    00943
    00952      void times(double scalar,
    00953                 const double * x, double * y) const;
    00957      void transposeTimes(double scalar,
    00958                          const double * x, double * y) const ;
    00960
    00961
    00962      //---------------------------------------------------------------------------
    00980
    00981      bool setIntParam(ClpIntParam key, int value) ;
    00983      bool setDblParam(ClpDblParam key, double value) ;
    00984 #ifndef CLP_NO_STD
    00986      bool setStrParam(ClpStrParam key, const std::string & value);
    00987 #endif
    00988      // Get an integer parameter
    00989      inline bool getIntParam(ClpIntParam key, int& value) const {
    00990           if (key < ClpLastIntParam) {
    00991                value = intParam_[key];
    00992                return true;
    00993           } else {
    00994                return false;
    00995           }
    00996      }
    00997      // Get an double parameter
    00998      inline bool getDblParam(ClpDblParam key, double& value) const {
    00999           if (key < ClpLastDblParam) {
    01000                value = dblParam_[key];
    01001                return true;
    01002           } else {
    01003                return false;
    01004           }
    01005      }
    01006 #ifndef CLP_NO_STD
    01007      // Get a string parameter
    01008      inline bool getStrParam(ClpStrParam key, std::string& value) const {
    01009           if (key < ClpLastStrParam) {
    01010                value = strParam_[key];
    01011                return true;
    01012           } else {
    01013                return false;
    01014           }
    01015      }
    01016 #endif
    01018      void generateCpp( FILE * fp);
    01019
    01052      inline unsigned int specialOptions() const {
    01053           return specialOptions_;
    01054      }
    01055      void setSpecialOptions(unsigned int value);
    01056 #define COIN_CBC_USING_CLP 0x01000000
    01057      inline bool inCbcBranchAndBound() const {
    01058           return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
    01059      }
    01061
    01064 protected:
    01066      void gutsOfDelete(int type);
    01070      void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
    01072      void getRowBound(int iRow, double& lower, double& upper) const;
    01074      void gutsOfLoadModel ( int numberRows, int numberColumns,
    01075                             const double* collb, const double* colub,
    01076                             const double* obj,
    01077                             const double* rowlb, const double* rowub,
    01078                             const double * rowObjective = NULL);
    01080      void gutsOfScaling();
    01082      inline double rawObjectiveValue() const {
    01083           return objectiveValue_;
    01084      }
    01086      inline bool permanentArrays() const {
    01087           return (specialOptions_ & 65536) != 0;
    01088      }
    01090      void startPermanentArrays();
    01092      void stopPermanentArrays();
    01094      const char * const * rowNamesAsChar() const;
    01096      const char * const * columnNamesAsChar() const;
    01098      void deleteNamesAsChar(const char * const * names, int number) const;
    01100      void onStopped();
    01102
    01103
    01105 protected:
    01106
    01109
    01110      double optimizationDirection_;
    01112      double dblParam_[ClpLastDblParam];
    01114      double objectiveValue_;
    01116      double smallElement_;
    01118      double objectiveScale_;
    01120      double rhsScale_;
    01122      int numberRows_;
    01124      int numberColumns_;
    01126      double * rowActivity_;
    01128      double * columnActivity_;
    01130      double * dual_;
    01132      double * reducedCost_;
    01134      double* rowLower_;
    01136      double* rowUpper_;
    01138      ClpObjective * objective_;
    01140      double * rowObjective_;
    01142      double * columnLower_;
    01144      double * columnUpper_;
    01146      ClpMatrixBase * matrix_;
    01148      ClpMatrixBase * rowCopy_;
    01150      ClpPackedMatrix * scaledMatrix_;
    01152      double * ray_;
    01154      double * rowScale_;
    01156      double * columnScale_;
    01158      double * inverseRowScale_;
    01160      double * inverseColumnScale_;
    01163      int scalingFlag_;
    01171      unsigned char * status_;
    01173      char * integerType_;
    01175      void * userPointer_;
    01177      ClpTrustedData * trustedUserPointer_;
    01179      int intParam_[ClpLastIntParam];
    01181      int numberIterations_;
    01183      int solveType_;
    01200 #define ROW_COLUMN_COUNTS_SAME 1
    01201 #define MATRIX_SAME 2
    01202 #define MATRIX_JUST_ROWS_ADDED 4
    01203 #define MATRIX_JUST_COLUMNS_ADDED 8
    01204 #define ROW_LOWER_SAME 16
    01205 #define ROW_UPPER_SAME 32
    01206 #define OBJECTIVE_SAME 64
    01207 #define COLUMN_LOWER_SAME 128
    01208 #define COLUMN_UPPER_SAME 256
    01209 #define BASIS_SAME 512
    01210 #define ALL_SAME 65339
    01211 #define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
    01212      unsigned int whatsChanged_;
    01214      int problemStatus_;
    01216      int secondaryStatus_;
    01218      int lengthNames_;
    01220      int numberThreads_;
    01224      unsigned int specialOptions_;
    01226      CoinMessageHandler * handler_;
    01228      bool defaultHandler_;
    01230      CoinThreadRandom randomNumberGenerator_;
    01232      ClpEventHandler * eventHandler_;
    01233 #ifndef CLP_NO_STD
    01235      std::vector<std::string> rowNames_;
    01237      std::vector<std::string> columnNames_;
    01238 #endif
    01240      CoinMessages messages_;
    01242      CoinMessages coinMessages_;
    01244      int maximumColumns_;
    01246      int maximumRows_;
    01248      int maximumInternalColumns_;
    01250      int maximumInternalRows_;
    01252      CoinPackedMatrix baseMatrix_;
    01254      CoinPackedMatrix baseRowCopy_;
    01256      double * savedRowScale_;
    01258      double * savedColumnScale_;
    01259 #ifndef CLP_NO_STD
    01261      std::string strParam_[ClpLastStrParam];
    01262 #endif
    01263
    01264 };
    01267 class ClpDataSave {
    01268
    01269 public:
    01273
    01274      ClpDataSave (  );
    01275
    01277      ClpDataSave(const ClpDataSave &);
    01279      ClpDataSave & operator=(const ClpDataSave & rhs);
    01281      ~ClpDataSave (  );
    01282
    01284
    01286 public:
    01287
    01290      double dualBound_;
    01291      double infeasibilityCost_;
    01292      double pivotTolerance_;
    01293      double zeroFactorizationTolerance_;
    01294      double zeroSimplexTolerance_;
    01295      double acceptablePivot_;
    01296      double objectiveScale_;
    01297      int sparseThreshold_;
    01298      int perturbation_;
    01299      int forceFactorization_;
    01300      int scalingFlag_;
    01301      unsigned int specialOptions_;
    01303 };
    01304
    01305 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines