ClpModel.hpp

Go to the documentation of this file.

/* $Id: ClpModel.hpp 2074 2014-12-10 09:43:54Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef ClpModel_H
#define ClpModel_H
 
#include "ClpConfig.h"
 
#include <iostream>
#include <cassert>
#include <cmath>
#include <vector>
#include <string>
//#ifndef COIN_USE_CLP
//#define COIN_USE_CLP
//#endif
#include "ClpPackedMatrix.hpp"
#include "CoinMessageHandler.hpp"
#include "CoinHelperFunctions.hpp"
#include "CoinTypes.hpp"
#include "CoinFinite.hpp"
#include "ClpParameters.hpp"
#include "ClpObjective.hpp"
class ClpEventHandler;
class CoinBuild;
class CoinModel;
class ClpModel {
 
public:
 
     ClpModel (bool emptyMessages = false  );
 
     ClpModel(const ClpModel & rhs, int scalingMode = -1);
     ClpModel & operator=(const ClpModel & rhs);
     ClpModel (const ClpModel * wholeModel,
               int numberRows, const int * whichRows,
               int numberColumns, const int * whichColumns,
               bool dropNames = true, bool dropIntegers = true);
     ~ClpModel (  );
 
     void loadProblem (  const ClpMatrixBase& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadProblem (  const CoinPackedMatrix& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
 
     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     int loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne = false);
     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value, const int * length,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadQuadraticObjective(const int numberColumns,
                                 const CoinBigIndex * start,
                                 const int * column, const double * element);
     void loadQuadraticObjective (  const CoinPackedMatrix& matrix);
     void deleteQuadraticObjective();
     void setRowObjective(const double * rowObjective);
     int readMps(const char *filename,
                 bool keepNames = false,
                 bool ignoreErrors = false);
     int readGMPL(const char *filename, const char * dataName,
                  bool keepNames = false);
     void copyInIntegerInformation(const char * information);
     void deleteIntegerInformation();
     void setContinuous(int index);
     void setInteger(int index);
     bool isInteger(int index) const;
     void resize (int newNumberRows, int newNumberColumns);
     void deleteRows(int number, const int * which);
     void addRow(int numberInRow, const int * columns,
                 const double * elements, double rowLower = -COIN_DBL_MAX,
                 double rowUpper = COIN_DBL_MAX);
     void addRows(int number, const double * rowLower,
                  const double * rowUpper,
                  const CoinBigIndex * rowStarts, const int * columns,
                  const double * elements);
     void addRows(int number, const double * rowLower,
                  const double * rowUpper,
                  const CoinBigIndex * rowStarts, const int * rowLengths,
                  const int * columns,
                  const double * elements);
#ifndef CLP_NO_VECTOR
     void addRows(int number, const double * rowLower,
                  const double * rowUpper,
                  const CoinPackedVectorBase * const * rows);
#endif
     int addRows(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
                 bool checkDuplicates = true);
     int addRows(CoinModel & modelObject, bool tryPlusMinusOne = false,
                 bool checkDuplicates = true);
 
     void deleteColumns(int number, const int * which);
     void deleteRowsAndColumns(int numberRows, const int * whichRows,
                               int numberColumns, const int * whichColumns);
     void addColumn(int numberInColumn,
                    const int * rows,
                    const double * elements,
                    double columnLower = 0.0,
                    double  columnUpper = COIN_DBL_MAX,
                    double  objective = 0.0);
     void addColumns(int number, const double * columnLower,
                     const double * columnUpper,
                     const double * objective,
                     const CoinBigIndex * columnStarts, const int * rows,
                     const double * elements);
     void addColumns(int number, const double * columnLower,
                     const double * columnUpper,
                     const double * objective,
                     const CoinBigIndex * columnStarts, const int * columnLengths,
                     const int * rows,
                     const double * elements);
#ifndef CLP_NO_VECTOR
     void addColumns(int number, const double * columnLower,
                     const double * columnUpper,
                     const double * objective,
                     const CoinPackedVectorBase * const * columns);
#endif
     int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
                    bool checkDuplicates = true);
     int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
                    bool checkDuplicates = true);
     inline void modifyCoefficient(int row, int column, double newElement,
                                   bool keepZero = false) {
          matrix_->modifyCoefficient(row, column, newElement, keepZero);
     }
     void chgRowLower(const double * rowLower);
     void chgRowUpper(const double * rowUpper);
     void chgColumnLower(const double * columnLower);
     void chgColumnUpper(const double * columnUpper);
     void chgObjCoefficients(const double * objIn);
     void borrowModel(ClpModel & otherModel);
     void returnModel(ClpModel & otherModel);
 
     void createEmptyMatrix();
     int cleanMatrix(double threshold = 1.0e-20);
     void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
#ifndef CLP_NO_STD
     void dropNames();
     void copyNames(const std::vector<std::string> & rowNames,
                    const std::vector<std::string> & columnNames);
     void copyRowNames(const std::vector<std::string> & rowNames, int first, int last);
     void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
     void copyRowNames(const char * const * rowNames, int first, int last);
     void copyColumnNames(const char * const * columnNames, int first, int last);
     void setRowName(int rowIndex, std::string & name) ;
     void setColumnName(int colIndex, std::string & name) ;
#endif
     int findNetwork(char * rotate, double fractionNeeded = 0.75);
     CoinModel * createCoinModel() const;
 
     int writeMps(const char *filename,
                  int formatType = 0, int numberAcross = 2,
                  double objSense = 0.0) const ;
 
     inline int numberRows() const {
          return numberRows_;
     }
     inline int getNumRows() const {
          return numberRows_;
     }
     inline int getNumCols() const {
          return numberColumns_;
     }
     inline int numberColumns() const {
          return numberColumns_;
     }
     inline double primalTolerance() const {
          return dblParam_[ClpPrimalTolerance];
     }
     void setPrimalTolerance( double value) ;
     inline double dualTolerance() const  {
          return dblParam_[ClpDualTolerance];
     }
     void setDualTolerance( double value) ;
     inline double primalObjectiveLimit() const {
          return dblParam_[ClpPrimalObjectiveLimit];
     }
     void setPrimalObjectiveLimit(double value);
     inline double dualObjectiveLimit() const {
          return dblParam_[ClpDualObjectiveLimit];
     }
     void setDualObjectiveLimit(double value);
     inline double objectiveOffset() const {
          return dblParam_[ClpObjOffset];
     }
     void setObjectiveOffset(double value);
     inline double presolveTolerance() const {
          return dblParam_[ClpPresolveTolerance];
     }
#ifndef CLP_NO_STD
     inline const std::string & problemName() const {
          return strParam_[ClpProbName];
     }
#endif
     inline int numberIterations() const  {
          return numberIterations_;
     }
     inline int getIterationCount() const {
          return numberIterations_;
     }
     inline void setNumberIterations(int numberIterationsNew) {
          numberIterations_ = numberIterationsNew;
     }
     inline int solveType() const {
          return solveType_;
     }
     inline void setSolveType(int type) {
          solveType_ = type;
     }
     inline int maximumIterations() const {
          return intParam_[ClpMaxNumIteration];
     }
     void setMaximumIterations(int value);
     inline double maximumSeconds() const {
          return dblParam_[ClpMaxSeconds];
     }
     void setMaximumSeconds(double value);
     void setMaximumWallSeconds(double value);
     bool hitMaximumIterations() const;
     inline int status() const            {
          return problemStatus_;
     }
     inline int problemStatus() const            {
          return problemStatus_;
     }
     inline void setProblemStatus(int problemStatusNew) {
          problemStatus_ = problemStatusNew;
     }
     inline int secondaryStatus() const            {
          return secondaryStatus_;
     }
     inline void setSecondaryStatus(int newstatus) {
          secondaryStatus_ = newstatus;
     }
     inline bool isAbandoned() const             {
          return problemStatus_ == 4;
     }
     inline bool isProvenOptimal() const         {
          return problemStatus_ == 0;
     }
     inline bool isProvenPrimalInfeasible() const {
          return problemStatus_ == 1;
     }
     inline bool isProvenDualInfeasible() const  {
          return problemStatus_ == 2;
     }
     bool isPrimalObjectiveLimitReached() const ;
     bool isDualObjectiveLimitReached() const ;
     inline bool isIterationLimitReached() const {
          return problemStatus_ == 3;
     }
     inline double optimizationDirection() const {
          return  optimizationDirection_;
     }
     inline double getObjSense() const    {
          return optimizationDirection_;
     }
     void setOptimizationDirection(double value);
     inline double * primalRowSolution() const    {
          return rowActivity_;
     }
     inline const double * getRowActivity() const {
          return rowActivity_;
     }
     inline double * primalColumnSolution() const {
          return columnActivity_;
     }
     inline const double * getColSolution() const {
          return columnActivity_;
     }
     inline void setColSolution(const double * input) {
          memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
     }
     inline double * dualRowSolution() const      {
          return dual_;
     }
     inline const double * getRowPrice() const    {
          return dual_;
     }
     inline double * dualColumnSolution() const   {
          return reducedCost_;
     }
     inline const double * getReducedCost() const {
          return reducedCost_;
     }
     inline double* rowLower() const              {
          return rowLower_;
     }
     inline const double* getRowLower() const     {
          return rowLower_;
     }
     inline double* rowUpper() const              {
          return rowUpper_;
     }
     inline const double* getRowUpper() const     {
          return rowUpper_;
     }
     //-------------------------------------------------------------------------
     void setObjectiveCoefficient( int elementIndex, double elementValue );
     inline void setObjCoeff( int elementIndex, double elementValue ) {
          setObjectiveCoefficient( elementIndex, elementValue);
     }
 
     void setColumnLower( int elementIndex, double elementValue );
 
     void setColumnUpper( int elementIndex, double elementValue );
 
     void setColumnBounds( int elementIndex,
                           double lower, double upper );
 
     void setColumnSetBounds(const int* indexFirst,
                             const int* indexLast,
                             const double* boundList);
 
     inline void setColLower( int elementIndex, double elementValue ) {
          setColumnLower(elementIndex, elementValue);
     }
     inline void setColUpper( int elementIndex, double elementValue ) {
          setColumnUpper(elementIndex, elementValue);
     }
 
     inline void setColBounds( int elementIndex,
                               double lower, double upper ) {
          setColumnBounds(elementIndex, lower, upper);
     }
 
     inline void setColSetBounds(const int* indexFirst,
                                 const int* indexLast,
                                 const double* boundList) {
          setColumnSetBounds(indexFirst, indexLast, boundList);
     }
 
     void setRowLower( int elementIndex, double elementValue );
 
     void setRowUpper( int elementIndex, double elementValue ) ;
 
     void setRowBounds( int elementIndex,
                        double lower, double upper ) ;
 
     void setRowSetBounds(const int* indexFirst,
                          const int* indexLast,
                          const double* boundList);
 
 
     inline const double * rowScale() const {
          return rowScale_;
     }
     inline const double * columnScale() const {
          return columnScale_;
     }
     inline const double * inverseRowScale() const {
          return inverseRowScale_;
     }
     inline const double * inverseColumnScale() const {
          return inverseColumnScale_;
     }
     inline double * mutableRowScale() const {
          return rowScale_;
     }
     inline double * mutableColumnScale() const {
          return columnScale_;
     }
     inline double * mutableInverseRowScale() const {
          return inverseRowScale_;
     }
     inline double * mutableInverseColumnScale() const {
          return inverseColumnScale_;
     }
     inline double * swapRowScale(double * newScale) {
          double * oldScale = rowScale_;
          rowScale_ = newScale;
          return oldScale;
     }
     void setRowScale(double * scale) ;
     void setColumnScale(double * scale);
     inline double objectiveScale() const {
          return objectiveScale_;
     }
     inline void setObjectiveScale(double value) {
          objectiveScale_ = value;
     }
     inline double rhsScale() const {
          return rhsScale_;
     }
     inline void setRhsScale(double value) {
          rhsScale_ = value;
     }
     void scaling(int mode = 1);
     void unscale();
     inline int scalingFlag() const {
          return scalingFlag_;
     }
     inline double * objective() const {
          if (objective_) {
               double offset;
               return objective_->gradient(NULL, NULL, offset, false);
          } else {
               return NULL;
          }
     }
     inline double * objective(const double * solution, double & offset, bool refresh = true) const {
          offset = 0.0;
          if (objective_) {
               return objective_->gradient(NULL, solution, offset, refresh);
          } else {
               return NULL;
          }
     }
     inline const double * getObjCoefficients() const {
          if (objective_) {
               double offset;
               return objective_->gradient(NULL, NULL, offset, false);
          } else {
               return NULL;
          }
     }
     inline double * rowObjective() const         {
          return rowObjective_;
     }
     inline const double * getRowObjCoefficients() const {
          return rowObjective_;
     }
     inline double * columnLower() const          {
          return columnLower_;
     }
     inline const double * getColLower() const    {
          return columnLower_;
     }
     inline double * columnUpper() const          {
          return columnUpper_;
     }
     inline const double * getColUpper() const    {
          return columnUpper_;
     }
     inline CoinPackedMatrix * matrix() const {
          if ( matrix_ == NULL ) return NULL;
          else return matrix_->getPackedMatrix();
     }
     inline int getNumElements() const {
          return matrix_->getNumElements();
     }
     inline double getSmallElementValue() const {
          return smallElement_;
     }
     inline void setSmallElementValue(double value) {
          smallElement_ = value;
     }
     inline ClpMatrixBase * rowCopy() const       {
          return rowCopy_;
     }
     void setNewRowCopy(ClpMatrixBase * newCopy);
     inline ClpMatrixBase * clpMatrix() const     {
          return matrix_;
     }
     inline ClpPackedMatrix * clpScaledMatrix() const     {
          return scaledMatrix_;
     }
     inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
          delete scaledMatrix_;
          scaledMatrix_ = scaledMatrix;
     }
     inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
          ClpPackedMatrix * oldMatrix = scaledMatrix_;
          scaledMatrix_ = scaledMatrix;
          return oldMatrix;
     }
     void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
     inline void replaceMatrix(CoinPackedMatrix * newmatrix,
                               bool deleteCurrent = false) {
          replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
     }
     inline double objectiveValue() const {
          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
     }
     inline void setObjectiveValue(double value) {
          objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
     }
     inline double getObjValue() const {
          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
     }
     inline char * integerInformation() const     {
          return integerType_;
     }
     double * infeasibilityRay(bool fullRay=false) const;
     double * unboundedRay() const;
     inline double * ray() const
     { return ray_;}
     inline bool rayExists() const {
         return (ray_!=NULL);
     }
     inline void deleteRay() {
         delete [] ray_;
         ray_=NULL;
     }
         inline const double * internalRay() const {
                 return ray_;
         }
     inline bool statusExists() const {
          return (status_ != NULL);
     }
     inline unsigned char *  statusArray() const {
          return status_;
     }
     unsigned char *  statusCopy() const;
     void copyinStatus(const unsigned char * statusArray);
 
     inline void setUserPointer (void * pointer) {
          userPointer_ = pointer;
     }
     inline void * getUserPointer () const {
          return userPointer_;
     }
     inline void setTrustedUserPointer (ClpTrustedData * pointer) {
          trustedUserPointer_ = pointer;
     }
     inline ClpTrustedData * getTrustedUserPointer () const {
          return trustedUserPointer_;
     }
     inline int whatsChanged() const {
          return whatsChanged_;
     }
     inline void setWhatsChanged(int value) {
          whatsChanged_ = value;
     }
     inline int numberThreads() const {
          return numberThreads_;
     }
     inline void setNumberThreads(int value) {
          numberThreads_ = value;
     }
 
     void passInMessageHandler(CoinMessageHandler * handler);
     CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
                                             bool & oldDefault);
     void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
     void newLanguage(CoinMessages::Language language);
     inline void setLanguage(CoinMessages::Language language) {
          newLanguage(language);
     }
     void setDefaultMessageHandler();
     inline CoinMessageHandler * messageHandler() const       {
          return handler_;
     }
     inline CoinMessages messages() const                     {
          return messages_;
     }
     inline CoinMessages * messagesPointer()                  {
          return & messages_;
     }
     inline CoinMessages coinMessages() const                  {
          return coinMessages_;
     }
     inline CoinMessages * coinMessagesPointer()                  {
          return & coinMessages_;
     }
     inline void setLogLevel(int value)    {
          handler_->setLogLevel(value);
     }
     inline int logLevel() const           {
          return handler_->logLevel();
     }
     inline bool defaultHandler() const {
          return defaultHandler_;
     }
     void passInEventHandler(const ClpEventHandler * eventHandler);
     inline ClpEventHandler * eventHandler() const {
          return eventHandler_;
     }
     inline CoinThreadRandom * randomNumberGenerator() {
          return &randomNumberGenerator_;
     }
     inline CoinThreadRandom & mutableRandomNumberGenerator() {
          return randomNumberGenerator_;
     }
     inline void setRandomSeed(int value) {
          randomNumberGenerator_.setSeed(value);
     }
     inline int lengthNames() const {
          return lengthNames_;
     }
#ifndef CLP_NO_STD
     inline void setLengthNames(int value) {
          lengthNames_ = value;
     }
     inline const std::vector<std::string> * rowNames() const {
          return &rowNames_;
     }
     inline const std::string& rowName(int iRow) const {
          return rowNames_[iRow];
     }
     std::string getRowName(int iRow) const;
     inline const std::vector<std::string> * columnNames() const {
          return &columnNames_;
     }
     inline const std::string& columnName(int iColumn) const {
          return columnNames_[iColumn];
     }
     std::string getColumnName(int iColumn) const;
#endif
     inline ClpObjective * objectiveAsObject() const {
          return objective_;
     }
     void setObjective(ClpObjective * objective);
     inline void setObjectivePointer(ClpObjective * newobjective) {
          objective_ = newobjective;
     }
     int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
 
 
     void times(double scalar,
                const double * x, double * y) const;
     void transposeTimes(double scalar,
                         const double * x, double * y) const ;
 
 
     //---------------------------------------------------------------------------
 
     bool setIntParam(ClpIntParam key, int value) ;
     bool setDblParam(ClpDblParam key, double value) ;
#ifndef CLP_NO_STD
     bool setStrParam(ClpStrParam key, const std::string & value);
#endif
     // Get an integer parameter
     inline bool getIntParam(ClpIntParam key, int& value) const {
          if (key < ClpLastIntParam) {
               value = intParam_[key];
               return true;
          } else {
               return false;
          }
     }
     // Get an double parameter
     inline bool getDblParam(ClpDblParam key, double& value) const {
          if (key < ClpLastDblParam) {
               value = dblParam_[key];
               return true;
          } else {
               return false;
          }
     }
#ifndef CLP_NO_STD
     // Get a string parameter
     inline bool getStrParam(ClpStrParam key, std::string& value) const {
          if (key < ClpLastStrParam) {
               value = strParam_[key];
               return true;
          } else {
               return false;
          }
     }
#endif
     void generateCpp( FILE * fp);
     inline unsigned int specialOptions() const {
          return specialOptions_;
     }
     void setSpecialOptions(unsigned int value);
#define COIN_CBC_USING_CLP 0x01000000
     inline bool inCbcBranchAndBound() const {
          return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
     }
 
protected:
     void gutsOfDelete(int type);
     void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
     void getRowBound(int iRow, double& lower, double& upper) const;
     void gutsOfLoadModel ( int numberRows, int numberColumns,
                            const double* collb, const double* colub,
                            const double* obj,
                            const double* rowlb, const double* rowub,
                            const double * rowObjective = NULL);
     void gutsOfScaling();
     inline double rawObjectiveValue() const {
          return objectiveValue_;
     }
     inline bool permanentArrays() const {
          return (specialOptions_ & 65536) != 0;
     }
     void startPermanentArrays();
     void stopPermanentArrays();
     const char * const * rowNamesAsChar() const;
     const char * const * columnNamesAsChar() const;
     void deleteNamesAsChar(const char * const * names, int number) const;
     void onStopped();
 
 
protected:
 
     double optimizationDirection_;
     double dblParam_[ClpLastDblParam];
     double objectiveValue_;
     double smallElement_;
     double objectiveScale_;
     double rhsScale_;
     int numberRows_;
     int numberColumns_;
     double * rowActivity_;
     double * columnActivity_;
     double * dual_;
     double * reducedCost_;
     double* rowLower_;
     double* rowUpper_;
     ClpObjective * objective_;
     double * rowObjective_;
     double * columnLower_;
     double * columnUpper_;
     ClpMatrixBase * matrix_;
     ClpMatrixBase * rowCopy_;
     ClpPackedMatrix * scaledMatrix_;
     double * ray_;
     double * rowScale_;
     double * columnScale_;
     double * inverseRowScale_;
     double * inverseColumnScale_;
     int scalingFlag_;
     unsigned char * status_;
     char * integerType_;
     void * userPointer_;
     ClpTrustedData * trustedUserPointer_;
     int intParam_[ClpLastIntParam];
     int numberIterations_;
     int solveType_;
#define ROW_COLUMN_COUNTS_SAME 1
#define MATRIX_SAME 2
#define MATRIX_JUST_ROWS_ADDED 4
#define MATRIX_JUST_COLUMNS_ADDED 8
#define ROW_LOWER_SAME 16
#define ROW_UPPER_SAME 32
#define OBJECTIVE_SAME 64 
#define COLUMN_LOWER_SAME 128
#define COLUMN_UPPER_SAME 256
#define BASIS_SAME 512
#define ALL_SAME 65339
#define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
     unsigned int whatsChanged_;
     int problemStatus_;
     int secondaryStatus_;
     int lengthNames_;
     int numberThreads_;
     unsigned int specialOptions_;
     CoinMessageHandler * handler_;
     bool defaultHandler_;
     CoinThreadRandom randomNumberGenerator_;
     ClpEventHandler * eventHandler_;
#ifndef CLP_NO_STD
     std::vector<std::string> rowNames_;
     std::vector<std::string> columnNames_;
#endif
     CoinMessages messages_;
     CoinMessages coinMessages_;
     int maximumColumns_;
     int maximumRows_;
     int maximumInternalColumns_;
     int maximumInternalRows_;
     CoinPackedMatrix baseMatrix_;
     CoinPackedMatrix baseRowCopy_;
     double * savedRowScale_;
     double * savedColumnScale_;
#ifndef CLP_NO_STD
     std::string strParam_[ClpLastStrParam];
#endif
};
class ClpDataSave {
 
public:
     ClpDataSave (  );
 
     ClpDataSave(const ClpDataSave &);
     ClpDataSave & operator=(const ClpDataSave & rhs);
     ~ClpDataSave (  );
 
 
public:
 
     double dualBound_;
     double infeasibilityCost_;
     double pivotTolerance_;
     double zeroFactorizationTolerance_;
     double zeroSimplexTolerance_;
     double acceptablePivot_;
     double objectiveScale_;
     int sparseThreshold_;
     int perturbation_;
     int forceFactorization_;
     int scalingFlag_;
     unsigned int specialOptions_;
};
 
#endif