ClpModel.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpModel_H
#define ClpModel_H

#include <iostream>
#include <cassert>
#include <cmath>
#include <vector>
#include <string>

#include "ClpMatrixBase.hpp"
#include "CoinMessageHandler.hpp"
#include "ClpParameters.hpp"
#include "ClpObjective.hpp"

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

class ClpModel {

public:


    ClpModel (  );

    ClpModel(const ClpModel &);
    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);
  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);
  void copyInIntegerInformation(const char * information);
  void deleteIntegerInformation();
  void resize (int newNumberRows, int newNumberColumns);
  void deleteRows(int number, const int * which);
  void addRows(int number, const double * rowLower, 
               const double * rowUpper,
               const int * rowStarts, const int * columns,
               const double * elements);
  void addRows(int number, const double * rowLower, 
               const double * rowUpper,
               const int * rowStarts, const int * rowLengths,
               const int * columns,
               const double * elements);
  void addRows(int number, const double * rowLower, 
               const double * rowUpper,
               const CoinPackedVectorBase * const * rows);

  void deleteColumns(int number, const int * which);
  void addColumns(int number, const double * columnLower, 
                  const double * columnUpper,
                  const double * objective,
                  const int * columnStarts, const int * rows,
                  const double * elements);
  void addColumns(int number, const double * columnLower, 
                  const double * columnUpper,
                  const double * objective,
                  const int * columnStarts, const int * columnLengths,
                  const int * rows,
                  const double * elements);
  void addColumns(int number, const double * columnLower, 
               const double * columnUpper,
                  const double * objective,
               const CoinPackedVectorBase * const * columns);
  void borrowModel(ClpModel & otherModel);
  void returnModel(ClpModel & otherModel);

  void createEmptyMatrix();
  void dropNames();
  void copyNames(std::vector<std::string> & rowNames,
                 std::vector<std::string> & columnNames);
  


   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 dualObjectiveLimit() const { return dblParam_[ClpDualObjectiveLimit];}
  void setDualObjectiveLimit(double value);
  inline double objectiveOffset() const { return dblParam_[ClpObjOffset];}
  void setObjectiveOffset(double value);
  inline std::string problemName() const { return strParam_[ClpProbName]; };
   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 void setProblemStatus(int problemStatus)
  { problemStatus_ = problemStatus;};
   inline int secondaryStatus() const            { return secondaryStatus_; }
  inline void setSecondaryStatus(int status)
  { secondaryStatus_ = status;};
   bool isAbandoned() const             { return problemStatus_==4; }
   bool isProvenOptimal() const         { return problemStatus_==0; }
   bool isProvenPrimalInfeasible() const { return problemStatus_==1; }
   bool isProvenDualInfeasible() const  { return problemStatus_==2; }
   bool isPrimalObjectiveLimitReached() const ;
   bool isDualObjectiveLimitReached() const ;
   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_; }
   inline double * objective() const            
  {
    if (objective_) {
      double offset; 
      return objective_->gradient(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(solution,offset,refresh);
    } else {
      return NULL;
    }
  }
   inline const double * getObjCoefficients() const 
  { 
    if (objective_) {
      double offset; 
      return objective_->gradient(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_; }
   void replaceMatrix(ClpMatrixBase * matrix);
   inline double objectiveValue() const {
      return objectiveValue_*optimizationDirection_ - dblParam_[ClpObjOffset];
   }
   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_;};


   void passInMessageHandler(CoinMessageHandler * handler);
   void newLanguage(CoinMessages::Language language);
   void setLanguage(CoinMessages::Language language) { newLanguage(language); }
   CoinMessageHandler * messageHandler() const       { return handler_; }
   CoinMessages messages() const                     { return messages_; }
   CoinMessages * messagesPointer()                  { return & messages_; }
   void setLogLevel(int value)    { handler_->setLogLevel(value); }
   int logLevel() const           { return handler_->logLevel(); }
   inline int lengthNames() const { return lengthNames_; }
   const std::vector<std::string> * rowNames() const {
      return &rowNames_;
   }
   const std::string& rowName(int iRow) const {
      return rowNames_[iRow];
   }
   const std::vector<std::string> * columnNames() const {
      return &columnNames_;
   }
   const std::string& columnName(int iColumn) const {
      return columnNames_[iColumn];
   }
  inline ClpObjective * objectiveAsObject() const
  { return objective_;};
  void setObjective(ClpObjective * objective);
  void setObjectivePointer(ClpObjective * objective)
  { objective_ = objective;};


  //---------------------------------------------------------------------------

    bool setIntParam(ClpIntParam key, int value) ;
    bool setDblParam(ClpDblParam key, double value) ;
    bool setStrParam(ClpStrParam key, const std::string & value);
    // 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;
      }
    }
    // Get a string parameter
    inline bool getStrParam(ClpStrParam key, std::string& value) const {
      if (key!=ClpLastStrParam) {
        value = strParam_[key];
        return true;
      } else {
        return false;
      }
    }

protected:
  void gutsOfDelete();
  void gutsOfCopy(const ClpModel & rhs, bool trueCopy=true);
  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);


protected:


  double optimizationDirection_;
  double dblParam_[ClpLastDblParam];
  double objectiveValue_;
  double smallElement_;
  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_;
  double * ray_;
  unsigned char * status_;
  char * integerType_;
  void * userPointer_;
  int intParam_[ClpLastIntParam];
  int numberIterations_;
  int solveType_;
  int problemStatus_;
  int secondaryStatus_;
  int lengthNames_;
  CoinMessageHandler * handler_;
  bool defaultHandler_;
  std::vector<std::string> rowNames_;
  std::vector<std::string> columnNames_;
  CoinMessages messages_;
  std::string strParam_[ClpLastStrParam];
};
class ClpDataSave {

public:

    ClpDataSave (  );

    ClpDataSave(const ClpDataSave &);
    ClpDataSave & operator=(const ClpDataSave & rhs);
    ~ClpDataSave (  );


public:

  double dualBound_;
  double infeasibilityCost_;
  int sparseThreshold_;
  int perturbation_;

};

#endif

---