CoinStructuredModel.hpp

Go to the documentation of this file.

/* $Id: CoinStructuredModel.hpp 1691 2014-03-19 12:43:56Z forrest $ */
// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinStructuredModel_H
#define CoinStructuredModel_H

#include "CoinModel.hpp"
#include <vector>

  typedef struct CoinModelInfo2 {
    int rowBlock; // Which row block
    int columnBlock; // Which column block
    char matrix; // nonzero if matrix exists
    char rhs; // nonzero if non default rhs exists
    char rowName; // nonzero if row names exists
    char integer; // nonzero if integer information exists
    char bounds; // nonzero if non default bounds/objective exists
    char columnName; // nonzero if column names exists
    CoinModelInfo2() : 
      rowBlock(0),
      columnBlock(0),
      matrix(0),
      rhs(0),
      rowName(0),
      integer(0),
      bounds(0),
      columnName(0)
    {}
} CoinModelBlockInfo;

class CoinStructuredModel : public CoinBaseModel {
  
public:
  int addBlock(const std::string & rowBlock,
                const std::string & columnBlock,
                const CoinBaseModel & block);
  int addBlock(const CoinBaseModel & block);
  int addBlock(const std::string & rowBlock,
                const std::string & columnBlock,
                CoinBaseModel * block);
  int addBlock(const std::string & rowBlock,
               const std::string & columnBlock,
               const CoinPackedMatrix & matrix,
               const double * rowLower, const double * rowUpper,
               const double * columnLower, const double * columnUpper,
               const double * objective);

  int writeMps(const char *filename, int compression = 0,
               int formatType = 0, int numberAcross = 2, bool keepStrings=false) ;
  int readSmps(const char *filename,
                 bool keepNames = false,
                 bool ignoreErrors = false);

  int decompose(const CoinModel &model,int type,
                int maxBlocks=50, const char ** starts=NULL);
  int decompose(const CoinPackedMatrix & matrix,
                const double * rowLower, const double * rowUpper,
                const double * columnLower, const double * columnUpper,
                const double * objective, int type,int maxBlocks=50,
                int * starts=NULL,
                double objectiveOffset=0.0);
  


  inline int numberRowBlocks() const
  { return numberRowBlocks_;}
  inline int numberColumnBlocks() const
  { return numberColumnBlocks_;}
  inline CoinBigIndex numberElementBlocks() const
  { return numberElementBlocks_;}
  CoinBigIndex numberElements() const;
  inline const std::string & getRowBlock(int i) const
  { return rowBlockNames_[i];}
  inline void setRowBlock(int i,const std::string &name) 
  { rowBlockNames_[i] = name;}
  int addRowBlock(int numberRows,const std::string &name) ;
  int rowBlock(const std::string &name) const;
  inline const std::string & getColumnBlock(int i) const
  { return columnBlockNames_[i];}
  inline void setColumnBlock(int i,const std::string &name) 
  { columnBlockNames_[i] = name;}
  int addColumnBlock(int numberColumns,const std::string &name) ;
  int columnBlock(const std::string &name) const;
  inline const CoinModelBlockInfo &  blockType(int i) const
  { return blockType_[i];}
  inline CoinBaseModel * block(int i) const
  { return blocks_[i];}
  const CoinBaseModel *  block(int row,int column) const;
  CoinModel * coinBlock(int i) const;
  const CoinBaseModel *  coinBlock(int row,int column) const;
  int  blockIndex(int row,int column) const;
  CoinModel * coinModelBlock(CoinModelBlockInfo & info) ;
  void setCoinModel(CoinModel * block, int iBlock);
  void refresh(int iBlock);
  CoinModelBlockInfo block(int row,int column,
             const double * & rowLower, const double * & rowUpper,
             const double * & columnLower, const double * & columnUpper,
             const double * & objective) const;
  inline double optimizationDirection() const {
    return  optimizationDirection_;
  }
  inline void setOptimizationDirection(double value)
  { optimizationDirection_=value;}

  CoinStructuredModel();
  CoinStructuredModel(const char *fileName,int decompose=0,
                      int maxBlocks=50);
   virtual ~CoinStructuredModel();

   CoinStructuredModel(const CoinStructuredModel&);
   CoinStructuredModel& operator=(const CoinStructuredModel&);
  virtual CoinBaseModel * clone() const;

private:

  int fillInfo(CoinModelBlockInfo & info,const CoinModel * block);
  void fillInfo(CoinModelBlockInfo & info,const CoinStructuredModel * block);
  int numberRowBlocks_;
  int numberColumnBlocks_;
  int numberElementBlocks_;
  int maximumElementBlocks_;
  std::vector<std::string> rowBlockNames_;
  std::vector<std::string> columnBlockNames_;
  CoinBaseModel ** blocks_;
  CoinModel ** coinModelBlocks_;
  CoinModelBlockInfo * blockType_;
};
#endif