/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpModel.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#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 "ClpParameters.hpp"
#include "ClpObjective.hpp"
class ClpEventHandler;

// Plus infinity
#ifndef COIN_DBL_MAX
#define COIN_DBL_MAX DBL_MAX
#endif

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 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(std::vector<std::string> & rowNames,
                 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 std::string problemName() const { return strParam_[ClpProbName]; }
#endif
   inline int numberIterations() const  { return numberIterations_; }
   inline int getIterationCount() const { return numberIterations_; }
  inline void setNumberIterations(int numberIterations)
  { numberIterations_ = numberIterations;}
  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);
  bool hitMaximumIterations() const;
   inline int status() const            { return problemStatus_; }
   inline int problemStatus() const            { return problemStatus_; }
  inline void setProblemStatus(int problemStatus)
  { problemStatus_ = problemStatus;}
   inline int secondaryStatus() const            { return secondaryStatus_; }
  inline void setSecondaryStatus(int status)
  { secondaryStatus_ = status;}
   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 double * mutableRowScale() const {return rowScale_;}
   inline double * mutableColumnScale() const {return columnScale_;}
   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_; }
   inline ClpMatrixBase * clpMatrix() const     { return matrix_; }
   inline ClpPackedMatrix * clpScaledMatrix() const     { return scaledMatrix_; }
   inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix)
  { delete scaledMatrix_; scaledMatrix_=scaledMatrix; }
   void replaceMatrix(ClpMatrixBase * matrix,bool deleteCurrent=false);
   inline void replaceMatrix(CoinPackedMatrix * matrix,
                             bool deleteCurrent=false)
  { replaceMatrix(new ClpPackedMatrix(matrix),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() const;
   double * unboundedRay() const;
  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 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); }
   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 * objective)
  { objective_ = objective;}
  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);

#define COIN_CBC_USING_CLP 0x01000000
  inline unsigned int specialOptions() const
  { return specialOptions_;}
  void setSpecialOptions(unsigned int value);
  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_;
  int scalingFlag_;
  unsigned char * status_;
  char * integerType_;
  void * userPointer_;
  int intParam_[ClpLastIntParam];
  int numberIterations_;
  int solveType_;
  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_;
  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 acceptablePivot_;
  double objectiveScale_;
  int sparseThreshold_;
  int perturbation_;
  int forceFactorization_;
  int scalingFlag_;
};

#endif

---