ClpModel.hpp

Go to the documentation of this file.

/* $Id$ */
// 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);
private:
  void synchronizeMatrix();
public:
  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();
  CoinBigIndex 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 CoinBigIndex 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/