CoinMpsIO Class Reference

#include <CoinMpsIO.hpp>

List of all members.

Public Member Functions
Methods to retrieve problem information
These methods return information about the problem held by the CoinMpsIO object. Querying an object that has no data associated with it result in zeros for the number of rows and columns, and NULL pointers from the methods that return vectors. Const pointers returned from any data-query method are always valid
int	getNumCols () const
	Get number of columns.
int	getNumRows () const
	Get number of rows.
int	getNumElements () const
	Get number of nonzero elements.
const double *	getColLower () const
	Get pointer to array[getNumCols()] of column lower bounds.
const double *	getColUpper () const
	Get pointer to array[getNumCols()] of column upper bounds.
const char *	getRowSense () const
const double *	getRightHandSide () const
const double *	getRowRange () const
const double *	getRowLower () const
	Get pointer to array[getNumRows()] of row lower bounds.
const double *	getRowUpper () const
	Get pointer to array[getNumRows()] of row upper bounds.
const double *	getObjCoefficients () const
	Get pointer to array[getNumCols()] of objective function coefficients.
const CoinPackedMatrix *	getMatrixByRow () const
	Get pointer to row-wise copy of the coefficient matrix.
const CoinPackedMatrix *	getMatrixByCol () const
	Get pointer to column-wise copy of the coefficient matrix.
bool	isContinuous (int colNumber) const
	Return true if column is a continuous variable.
bool	isInteger (int columnNumber) const
const char *	integerColumns () const
const char *	rowName (int index) const
const char *	columnName (int index) const
int	rowIndex (const char *name) const
int	columnIndex (const char *name) const
double	objectiveOffset () const
const char *	getProblemName () const
	Return the problem name.
const char *	getObjectiveName () const
	Return the objective name.
const char *	getRhsName () const
	Return the RHS vector name.
const char *	getRangeName () const
	Return the range vector name.
const char *	getBoundName () const
	Return the bound vector name.
Methods to set problem information
Methods to load a problem into the CoinMpsIO object.
void	setMpsData (const CoinPackedMatrix &m, const double infinity, const double *collb, const double *colub, const double *obj, const char *integrality, const double *rowlb, const double *rowub, char const *const *const colnames, char const *const *const rownames)
	Set the problem data.
void	setMpsData (const CoinPackedMatrix &m, const double infinity, const double *collb, const double *colub, const double *obj, const char *integrality, const double *rowlb, const double *rowub, const std::vector< std::string > &colnames, const std::vector< std::string > &rownames)
void	setMpsData (const CoinPackedMatrix &m, const double infinity, const double *collb, const double *colub, const double *obj, const char *integrality, const char *rowsen, const double *rowrhs, const double *rowrng, char const *const *const colnames, char const *const *const rownames)
void	setMpsData (const CoinPackedMatrix &m, const double infinity, const double *collb, const double *colub, const double *obj, const char *integrality, const char *rowsen, const double *rowrhs, const double *rowrng, const std::vector< std::string > &colnames, const std::vector< std::string > &rownames)
void	copyInIntegerInformation (const char *integerInformation)
Parameter set/get methods
Methods to set and retrieve MPS IO parameters.
void	setInfinity (double value)
	Set infinity.
double	getInfinity () const
	Get infinity.
void	setDefaultBound (int value)
	Set default upper bound for integer variables.
int	getDefaultBound () const
	Get default upper bound for integer variables.
Methods for problem input and output
Methods to read and write MPS format problem files. The read and write methods return the number of errors that occurred during the IO operation, or -1 if no file is opened. Note: If the CoinMpsIO class was compiled with support for libz then readMps will automatically try to append .gz to the file name and open it as a compressed file if the specified file name cannot be opened. (Automatic append of the .bz2 suffix when libbz is used is on the TODO list.) Todo: Allow for file pointers and positioning
void	setFileName (const char *name)
	Set the current file name for the CoinMpsIO object.
const char *	getFileName () const
	Get the current file name for the CoinMpsIO object.
const bool	fileReadable () const
	Test if a file with the currrent file name exists and is readable.
int	readMps (const char *filename, const char *extension="mps")
int	readMps ()
int	writeMps (const char *filename, int compression=0, int formatType=0, int numberAcross=2) const
int	readQuadraticMps (const char *filename, int *&columnStart, int *&column, double *&elements, int checkSymmetry)
int	readConicMps (const char *filename, int *&columnStart, int *&column, int &numberCones)
Constructors and destructors
	CoinMpsIO ()
	Default Constructor.
	CoinMpsIO (const CoinMpsIO &)
	Copy constructor.
CoinMpsIO &	operator= (const CoinMpsIO &rhs)
	Assignment operator.
	~CoinMpsIO ()
	Destructor.
Message handling
void	passInMessageHandler (CoinMessageHandler *handler)
void	newLanguage (CoinMessages::Language language)
	Set the language for messages.
void	setLanguage (CoinMessages::Language language)
	Set the language for messages.
CoinMessageHandler *	messageHandler () const
	Return the message handler.
CoinMessages	messages ()
	Return the messages.
Methods to release storage
These methods allow the client to reduce the storage used by the CoinMpsIO object be selectively releasing unneeded problem information.
void	releaseRedundantInformation ()
void	releaseRowInformation ()
	Release all row information (lower, upper).
void	releaseColumnInformation ()
	Release all column information (lower, upper, objective).
void	releaseIntegerInformation ()
	Release integer information.
void	releaseRowNames ()
	Release row names.
void	releaseColumnNames ()
	Release column names.
void	releaseMatrixInformation ()
	Release matrix information.
Protected Member Functions
Miscellaneous helper functions
void	setMpsDataWithoutRowAndColNames (const CoinPackedMatrix &m, const double infinity, const double *collb, const double *colub, const double *obj, const char *integrality, const double *rowlb, const double *rowub)
	Utility method used several times to implement public methods.
void	setMpsDataColAndRowNames (const std::vector< std::string > &colnames, const std::vector< std::string > &rownames)
void	setMpsDataColAndRowNames (char const *const *const colnames, char const *const *const rownames)
void	gutsOfDestructor ()
	Does the heavy lifting for destruct and assignment.
void	gutsOfCopy (const CoinMpsIO &)
	Does the heavy lifting for copy and assignment.
void	freeAll ()
	Clears problem data from the CoinMpsIO object.
void	convertBoundToSense (const double lower, const double upper, char &sense, double &right, double &range) const
void	convertSenseToBound (const char sense, const double right, const double range, double &lower, double &upper) const
int	dealWithFileName (const char *filename, const char *extension, FILE *&fp, gzFile &gzfp)
Hash table methods
void	startHash (char **names, const int number, int section)
	Creates hash list for names (section = 0 for rows, 1 columns).
void	startHash (int section) const
	This one does it when names are already in.
void	stopHash (int section)
	Deletes hash storage.
int	findHash (const char *name, int section) const
	Finds match using hash, -1 not found.
Protected Attributes
Cached problem information
char *	problemName_
	Problem name.
char *	objectiveName_
	Objective row name.
char *	rhsName_
	Right-hand side vector name.
char *	rangeName_
	Range vector name.
char *	boundName_
	Bounds vector name.
int	numberRows_
	Number of rows.
int	numberColumns_
	Number of columns.
CoinBigIndex	numberElements_
	Number of coefficients.
char *	rowsense_
	Pointer to dense vector of row sense indicators.
double *	rhs_
	Pointer to dense vector of row right-hand side values.
double *	rowrange_
CoinPackedMatrix *	matrixByRow_
	Pointer to row-wise copy of problem matrix coefficients.
CoinPackedMatrix *	matrixByColumn_
	Pointer to column-wise copy of problem matrix coefficients.
double *	rowlower_
	Pointer to dense vector of row lower bounds.
double *	rowupper_
	Pointer to dense vector of row upper bounds.
double *	collower_
	Pointer to dense vector of column lower bounds.
double *	colupper_
	Pointer to dense vector of column upper bounds.
double *	objective_
	Pointer to dense vector of objective coefficients.
double	objectiveOffset_
	Constant offset for objective value (i.e., RHS value for OBJ row).
char *	integerType_
char **	names_ [2]
Hash tables
char *	fileName_
	Current file name.
int	numberHash_ [2]
	Number of entries in a hash table section.
CoinHashLink *	hash_ [2]
	Hash tables (two sections, 0 - row names, 1 - column names).
CoinMpsIO object parameters
int	defaultBound_
	Upper bound when no bounds for integers.
double	infinity_
	Value to use for infinity.
CoinMessageHandler *	handler_
	Message handler.
bool	defaultHandler_
CoinMessages	messages_
	Messages.
CoinMpsCardReader *	cardReader_
	Card reader.
Friends
void	CoinMpsIOUnitTest (const std::string &mpsDir)

---

Detailed Description

MPS IO Interface

This class can be used to read in mps files without a solver. After reading the file, the CoinMpsIO object contains all relevant data, which may be more than a particular OsiSolverInterface allows for. Items may be deleted to allow for flexibility of data storage.

The implementation makes the CoinMpsIO object look very like a dummy solver, as the same conventions are used.

Definition at line 163 of file CoinMpsIO.hpp.

---

Member Function Documentation

int CoinMpsIO::columnIndex (  const char *  name  )  const

Returns the index for the specified column name Returns -1 if the name is not found. Definition at line 2942 of file CoinMpsIO.cpp. References findHash(), hash_, and startHash(). { if (!hash_[1]) { if (numberColumns_) { startHash(1); } else { return -1; } } return findHash ( name , 1 ); }

const char * CoinMpsIO::columnName (  int  index  )  const

Returns the column name for the specified index. Returns 0 if the index is out of range. Definition at line 2922 of file CoinMpsIO.cpp. Referenced by readMps(). { if (index>=0&&index<numberColumns_) { return names_[1][index]; } else { return NULL; } }

void CoinMpsIO::convertBoundToSense (  const double  lower, const double  upper, char &  sense, double &  right, double &  range )  const [inline, protected]

A quick inlined function to convert from lb/ub style constraint definition to sense/rhs/range style Definition at line 2538 of file CoinMpsIO.cpp. References infinity_. Referenced by getRightHandSide(), getRowRange(), and getRowSense(). { range = 0.0; if (lower > -infinity_) { if (upper < infinity_) { right = upper; if (upper==lower) { sense = 'E'; } else { sense = 'R'; range = upper - lower; } } else { sense = 'G'; right = lower; } } else { if (upper < infinity_) { sense = 'L'; right = upper; } else { sense = 'N'; right = 0.0; } } }

void CoinMpsIO::convertSenseToBound (  const char  sense, const double  right, const double  range, double &  lower, double &  upper )  const [inline, protected]

A quick inlined function to convert from sense/rhs/range stryle constraint definition to lb/ub style Definition at line 2571 of file CoinMpsIO.cpp. References infinity_. { switch (sense) { case 'E': lower = upper = right; break; case 'L': lower = -infinity_; upper = right; break; case 'G': lower = right; upper = infinity_; break; case 'R': lower = right - range; upper = right; break; case 'N': lower = -infinity_; upper = infinity_; break; } }

void CoinMpsIO::copyInIntegerInformation (  const char *  integerInformation  )

Pass in an array[getNumCols()] specifying if a variable is integer. At present, simply coded as zero (continuous) and non-zero (integer) May be extended at a later date. Definition at line 2902 of file CoinMpsIO.cpp. References integerType_. { if (integerType) { if (!integerType_) integerType_ = new char [numberColumns_]; memcpy(integerType_,integerType,numberColumns_); } else { delete [] integerType_; integerType_=NULL; } }

int CoinMpsIO::dealWithFileName (  const char *  filename, const char *  extension, FILE *&  fp, gzFile &  gzfp )  [protected]

Deal with a filename As the name says. Returns +1 if the file name is new, 0 if it's the same as before (i.e., matches fileName_), and -1 if there's an error and the file can't be opened. Handles automatic append of .gz suffix when compiled with libz. Todo: Add automatic append of .bz2 suffix when compiled with libbz. Definition at line 930 of file CoinMpsIO.cpp. References fileName_, handler_, CoinMessageHandler::message(), and messages_. Referenced by readConicMps(), readMps(), and readQuadraticMps(). { fp=NULL; int goodFile=0; gzfp=NULL; if (!fileName_||(filename!=NULL&&strcmp(filename,fileName_))) { if (filename==NULL) { handler_->message(COIN_MPS_FILE,messages_)<<"NULL" <<CoinMessageEol; return -1; } goodFile=-1; // looks new name char newName[400]; if (strcmp(filename,"stdin")&&strcmp(filename,"-")) { if (extension&&strlen(extension)) { // There was an extension - but see if user gave .xxx int i = strlen(filename)-1; strcpy(newName,filename); bool foundDot=false; for (;i>=0;i--) { char character = filename[i]; if (character=='/'||character=='\\') { break; } else if (character=='.') { foundDot=true; break; } } if (!foundDot) { strcat(newName,"."); strcat(newName,extension); } } else { // no extension strcpy(newName,filename); } } else { strcpy(newName,"stdin"); } // See if new name if (fileName_&&!strcmp(newName,fileName_)) { // old name return 0; } else { // new file free(fileName_); fileName_=strdup(newName); if (strcmp(fileName_,"stdin")) { #ifdef COIN_USE_ZLIB int length=strlen(fileName_); if (!strcmp(fileName_+length-3,".gz")) { gzfp = gzopen(fileName_,"rb"); fp = NULL; goodFile = (gzfp!=NULL); } else { #endif fp = fopen ( fileName_, "r" ); if (fp!=NULL) goodFile=1; #ifdef COIN_USE_ZLIB if (goodFile<0) { std::string fname(fileName_); fname += ".gz"; gzfp = gzopen(fname.c_str(),"rb"); printf("%s\n", fname.c_str()); if (gzfp!=NULL) goodFile=1; } } #endif } else { fp = stdin; goodFile = 1; } } } else { // same as before // reset section ? goodFile=0; } if (goodFile<0) handler_->message(COIN_MPS_FILE,messages_)<<fileName_ <<CoinMessageEol; return goodFile; }

const double * CoinMpsIO::getRightHandSide (   )  const

Get pointer to array[getNumRows()] of constraint right-hand sides. Given constraints with upper (rowupper) and/or lower (rowlower) bounds, the constraint right-hand side (rhs) is set as if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] if rowsense()[i] == 'N' then rhs()[i] == 0.0 Definition at line 2620 of file CoinMpsIO.cpp. References convertBoundToSense(), numberRows_, rhs_, rowlower_, and rowupper_. { if ( rhs_==NULL ) { int nr=numberRows_; rhs_ = (double *) malloc(nr*sizeof(double)); char dum1; double dum2; int i; for ( i=0; i<nr; i++ ) { convertBoundToSense(rowlower_[i],rowupper_[i],dum1,rhs_[i],dum2); } } return rhs_; }

const double * CoinMpsIO::getRowRange (   )  const

Get pointer to array[getNumRows()] of row ranges. Given constraints with upper (rowupper) and/or lower (rowlower) bounds, the constraint range (rowrange) is set as if rowsense()[i] == 'R' then rowrange()[i] == rowupper()[i] - rowlower()[i] if rowsense()[i] != 'R' then rowrange()[i] is 0.0 Put another way, only range constraints have a nontrivial value for rowrange. Definition at line 2642 of file CoinMpsIO.cpp. References convertBoundToSense(), numberRows_, rowlower_, rowrange_, and rowupper_. { if ( rowrange_==NULL ) { int nr=numberRows_; rowrange_ = (double *) malloc(nr*sizeof(double)); std::fill(rowrange_,rowrange_+nr,0.0); char dum1; double dum2; int i; for ( i=0; i<nr; i++ ) { convertBoundToSense(rowlower_[i],rowupper_[i],dum1,dum2,rowrange_[i]); } } return rowrange_; }

const char * CoinMpsIO::getRowSense (   )  const

Get pointer to array[getNumRows()] of constraint senses. 'L': <= constraint 'E': = constraint 'G': >= constraint 'R': ranged constraint 'N': free constraint Definition at line 2600 of file CoinMpsIO.cpp. References convertBoundToSense(), numberRows_, rowlower_, rowsense_, and rowupper_. Referenced by writeMps(). { if ( rowsense_==NULL ) { int nr=numberRows_; rowsense_ = (char *) malloc(nr*sizeof(char)); double dum1,dum2; int i; for ( i=0; i<nr; i++ ) { convertBoundToSense(rowlower_[i],rowupper_[i],rowsense_[i],dum1,dum2); } } return rowsense_; }

const char * CoinMpsIO::integerColumns (   )  const

Returns array[getNumCols()] specifying if a variable is integer. At present, simply coded as zero (continuous) and non-zero (integer) May be extended at a later date. Definition at line 2896 of file CoinMpsIO.cpp. References integerType_. { return integerType_; }

bool CoinMpsIO::isInteger (  int  columnNumber  )  const

Return true if a column is an integer variable Note: This function returns true if the the column is a binary or general integer variable. Definition at line 2887 of file CoinMpsIO.cpp. References integerType_. Referenced by writeMps(). { const char * intType = integerType_; if ( intType==NULL ) return false; assert (columnNumber>=0 && columnNumber < numberColumns_); if ( intType[columnNumber]!=0 ) return true; return false; }

double CoinMpsIO::objectiveOffset (   )  const

Returns the (constant) objective offset This is the RHS entry for the objective row Definition at line 1018 of file CoinMpsIO.cpp. References objectiveOffset_. { return objectiveOffset_; }

void CoinMpsIO::passInMessageHandler (  CoinMessageHandler *  handler  )

Pass in Message handler Supply a custom message handler. It will not be destroyed when the CoinMpsIO object is destroyed. Definition at line 3258 of file CoinMpsIO.cpp. References defaultHandler_, and handler_. { if (defaultHandler_) delete handler_; defaultHandler_=false; handler_=handler; }

int CoinMpsIO::readConicMps (  const char *  filename, int *&  columnStart, int *&  column, int &  numberCones )

Read in a list of cones from the given filename. If filename is NULL (or the same as the currently open file) then reading continues from the current file. If not, the file is closed and the specified file is opened. Code should be added to general MPS reader to read this if CSECTION No checking is done that in unique cone Arrays should be deleted by delete [] Returns number of errors, -1 bad file, -2 no conic section, -3 empty section columnStart is numberCones+1 long, other number of columns in matrix Definition at line 3503 of file CoinMpsIO.cpp. References CoinMpsCardReader::card(), CoinMpsCardReader::cardNumber(), cardReader_, CoinMpsCardReader::columnName(), dealWithFileName(), fileName_, findHash(), handler_, CoinMessageHandler::message(), messages_, CoinMpsCardReader::mpsType(), CoinMpsCardReader::nextField(), CoinMpsCardReader::readToNextSection(), startHash(), stopHash(), and CoinMpsCardReader::whichSection(). { // Deal with filename - +1 if new, 0 if same as before, -1 if error FILE *fp=NULL; gzFile gzfp=NULL; int returnCode = dealWithFileName(filename,"",fp,gzfp); if (returnCode<0) { return -1; } else if (returnCode>0) { delete cardReader_; cardReader_ = new CoinMpsCardReader ( fp , gzfp, this); } cardReader_->readToNextSection(); // Skip NAME if ( cardReader_->whichSection ( ) == COIN_NAME_SECTION ) cardReader_->readToNextSection(); numberCones=0; // Get arrays columnStart = new int [numberColumns_+1]; column = new int [numberColumns_]; int numberErrors = 0; columnStart[0]=0; int numberElements=0; startHash(1); //if (cardReader_->whichSection()==COIN_CONIC_SECTION) //cardReader_->cleanCard(); // skip doing last while ( cardReader_->nextField ( ) == COIN_CONIC_SECTION ) { // should check QUAD // Have to check by hand if (!strncmp(cardReader_->card(),"CSECTION",8)) { if (numberElements==columnStart[numberCones]) { printf("Cone must have at least one column\n"); abort(); } columnStart[++numberCones]=numberElements; continue; } COINColumnIndex iColumn1; switch ( cardReader_->mpsType ( ) ) { case COIN_BLANK_COLUMN: // get index iColumn1 = findHash ( cardReader_->columnName ( ) , 1 ); if ( iColumn1 >= 0 ) { column[numberElements++]=iColumn1; } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHCOL,messages_) <<cardReader_->columnName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } if ( cardReader_->whichSection ( ) == COIN_ENDATA_SECTION ) { // Error if no cones if (!numberElements) { handler_->message(COIN_MPS_EOF,messages_)<<fileName_ <<CoinMessageEol; delete [] columnStart; delete [] column; columnStart = NULL; column = NULL; return -3; } else { columnStart[++numberCones]=numberElements; } } else { handler_->message(COIN_MPS_BADFILE1,messages_)<<cardReader_->card() <<cardReader_->cardNumber() <<fileName_ <<CoinMessageEol; delete [] columnStart; delete [] column; columnStart = NULL; column = NULL; numberCones=0; return -2; } stopHash(1); return numberErrors; }

int CoinMpsIO::readMps (   )

Read a problem in MPS format from a previously opened file More precisely, read a problem using a CoinMpsCardReader object already associated with this CoinMpsIO object. Todo: Provide an interface that will allow a client to associate a CoinMpsCardReader object with a CoinMpsIO object by setting the cardReader_ field. Definition at line 1056 of file CoinMpsIO.cpp. References boundName_, CoinMpsCardReader::card(), CoinMpsCardReader::cardNumber(), cardReader_, collower_, columnName(), CoinMpsCardReader::columnName(), colupper_, defaultBound_, fileName_, CoinMpsCardReader::filePointer(), findHash(), handler_, infinity_, integerType_, matrixByColumn_, CoinMessageHandler::message(), messages_, CoinMpsCardReader::mpsType(), CoinMpsCardReader::nextField(), numberColumns_, numberElements_, numberRows_, objective_, objectiveName_, objectiveOffset_, problemName_, rangeName_, CoinMpsCardReader::readToNextSection(), rhsName_, rowlower_, CoinMpsCardReader::rowName(), rowName(), rowupper_, startHash(), stopHash(), CoinMpsCardReader::value(), and CoinMpsCardReader::whichSection(). Referenced by readMps(). { bool ifmps; cardReader_->readToNextSection(); if ( cardReader_->whichSection ( ) == COIN_NAME_SECTION ) { ifmps = true; // save name of section free(problemName_); problemName_=strdup(cardReader_->columnName()); } else if ( cardReader_->whichSection ( ) == COIN_UNKNOWN_SECTION ) { handler_->message(COIN_MPS_BADFILE1,messages_)<<cardReader_->card() <<1 <<fileName_ <<CoinMessageEol; #ifdef COIN_USE_ZLIB if (!cardReader_->filePointer()) handler_->message(COIN_MPS_BADFILE2,messages_)<<CoinMessageEol; #endif return -2; } else if ( cardReader_->whichSection ( ) != COIN_EOF_SECTION ) { // save name of section free(problemName_); problemName_=strdup(cardReader_->card()); ifmps = false; } else { handler_->message(COIN_MPS_EOF,messages_)<<fileName_ <<CoinMessageEol; return -3; } CoinBigIndex *start; COINRowIndex *row; double *element; objectiveOffset_ = 0.0; int numberErrors = 0; int i; if ( ifmps ) { // mps file - always read in free format bool gotNrow = false; //get ROWS cardReader_->nextField ( ) ; // Fudge for what ever code has OBJSENSE if (!strncmp(cardReader_->card(),"OBJSENSE",8)) { cardReader_->nextField(); int i; const char * thisCard = cardReader_->card(); int direction = 0; for (i=0;i<20;i++) { if (thisCard[i]!=' ') { if (!strncmp(thisCard+i,"MAX",3)) direction=-1; else if (!strncmp(thisCard+i,"MIN",3)) direction=1; break; } } if (!direction) printf("No MAX/MIN found after OBJSENSE\n"); else printf("%s found after OBJSENSE - Coin ignores\n", (direction>0 ? "MIN" : "MAX")); cardReader_->nextField(); } if ( cardReader_->whichSection ( ) != COIN_ROW_SECTION ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } //use malloc etc as I don't know how to do realloc in C++ numberRows_ = 0; numberColumns_ = 0; numberElements_ = 0; COINRowIndex maxRows = 1000; COINMpsType *rowType = ( COINMpsType * ) malloc ( maxRows * sizeof ( COINMpsType ) ); char **rowName = ( char ** ) malloc ( maxRows * sizeof ( char * ) ); // for discarded free rows COINRowIndex maxFreeRows = 100; COINRowIndex numberOtherFreeRows = 0; char **freeRowName = ( char ** ) malloc ( maxFreeRows * sizeof ( char * ) ); while ( cardReader_->nextField ( ) == COIN_ROW_SECTION ) { switch ( cardReader_->mpsType ( ) ) { case COIN_N_ROW: if ( !gotNrow ) { gotNrow = true; // save name of section free(objectiveName_); objectiveName_=strdup(cardReader_->columnName()); } else { // add to discard list if ( numberOtherFreeRows == maxFreeRows ) { maxFreeRows = ( 3 * maxFreeRows ) / 2 + 100; freeRowName = ( char ** ) realloc ( freeRowName, maxFreeRows * sizeof ( char * ) ); } freeRowName[numberOtherFreeRows] = strdup ( cardReader_->columnName ( ) ); numberOtherFreeRows++; } break; case COIN_E_ROW: case COIN_L_ROW: case COIN_G_ROW: if ( numberRows_ == maxRows ) { maxRows = ( 3 * maxRows ) / 2 + 1000; rowType = ( COINMpsType * ) realloc ( rowType, maxRows * sizeof ( COINMpsType ) ); rowName = ( char ** ) realloc ( rowName, maxRows * sizeof ( char * ) ); } rowType[numberRows_] = cardReader_->mpsType ( ); rowName[numberRows_] = strdup ( cardReader_->columnName ( ) ); numberRows_++; break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } if ( cardReader_->whichSection ( ) != COIN_COLUMN_SECTION ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } assert ( gotNrow ); rowType = ( COINMpsType * ) realloc ( rowType, numberRows_ * sizeof ( COINMpsType ) ); // put objective and other free rows at end rowName = ( char ** ) realloc ( rowName, ( numberRows_ + 1 + numberOtherFreeRows ) * sizeof ( char * ) ); rowName[numberRows_] = strdup(objectiveName_); memcpy ( rowName + numberRows_ + 1, freeRowName, numberOtherFreeRows * sizeof ( char * ) ); // now we can get rid of this array free(freeRowName); startHash ( rowName, numberRows_ + 1 + numberOtherFreeRows , 0 ); COINColumnIndex maxColumns = 1000 + numberRows_ / 5; CoinBigIndex maxElements = 5000 + numberRows_ / 2; COINMpsType *columnType = ( COINMpsType * ) malloc ( maxColumns * sizeof ( COINMpsType ) ); char **columnName = ( char ** ) malloc ( maxColumns * sizeof ( char * ) ); objective_ = ( double * ) malloc ( maxColumns * sizeof ( double ) ); start = ( CoinBigIndex * ) malloc ( ( maxColumns + 1 ) * sizeof ( CoinBigIndex ) ); row = ( COINRowIndex * ) malloc ( maxElements * sizeof ( COINRowIndex ) ); element = ( double * ) malloc ( maxElements * sizeof ( double ) ); // for duplicates CoinBigIndex *rowUsed = new CoinBigIndex[numberRows_]; for (i=0;i<numberRows_;i++) { rowUsed[i]=-1; } bool objUsed = false; numberElements_ = 0; char lastColumn[200]; memset ( lastColumn, '\0', 200 ); COINColumnIndex column = -1; bool inIntegerSet = false; COINColumnIndex numberIntegers = 0; const double tinyElement = 1.0e-14; while ( cardReader_->nextField ( ) == COIN_COLUMN_SECTION ) { switch ( cardReader_->mpsType ( ) ) { case COIN_BLANK_COLUMN: if ( strcmp ( lastColumn, cardReader_->columnName ( ) ) ) { // new column // reset old column and take out tiny if ( numberColumns_ ) { objUsed = false; CoinBigIndex i; CoinBigIndex k = start[column]; for ( i = k; i < numberElements_; i++ ) { COINRowIndex irow = row[i]; #if 0 if ( fabs ( element[i] ) > tinyElement ) { element[k++] = element[i]; } #endif rowUsed[irow] = -1; } //numberElements_ = k; } column = numberColumns_; if ( numberColumns_ == maxColumns ) { maxColumns = ( 3 * maxColumns ) / 2 + 1000; columnType = ( COINMpsType * ) realloc ( columnType, maxColumns * sizeof ( COINMpsType ) ); columnName = ( char ** ) realloc ( columnName, maxColumns * sizeof ( char * ) ); objective_ = ( double * ) realloc ( objective_, maxColumns * sizeof ( double ) ); start = ( CoinBigIndex * ) realloc ( start, ( maxColumns + 1 ) * sizeof ( CoinBigIndex ) ); } if ( !inIntegerSet ) { columnType[column] = COIN_UNSET_BOUND; } else { columnType[column] = COIN_INTORG; numberIntegers++; } columnName[column] = strdup ( cardReader_->columnName ( ) ); strcpy ( lastColumn, cardReader_->columnName ( ) ); objective_[column] = 0.0; start[column] = numberElements_; numberColumns_++; } if ( fabs ( cardReader_->value ( ) ) > tinyElement ) { if ( numberElements_ == maxElements ) { maxElements = ( 3 * maxElements ) / 2 + 1000; row = ( COINRowIndex * ) realloc ( row, maxElements * sizeof ( COINRowIndex ) ); element = ( double * ) realloc ( element, maxElements * sizeof ( double ) ); } // get row number COINRowIndex irow = findHash ( cardReader_->rowName ( ) , 0 ); if ( irow >= 0 ) { double value = cardReader_->value ( ); // check for duplicates if ( irow == numberRows_ ) { // objective if ( objUsed ) { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPOBJ,messages_) <<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_) <<CoinMessageEol; return numberErrors; } } else { objUsed = true; } value += objective_[column]; if ( fabs ( value ) <= tinyElement ) value = 0.0; objective_[column] = value; } else if ( irow < numberRows_ ) { // other free rows will just be discarded so won't get here if ( rowUsed[irow] >= 0 ) { element[rowUsed[irow]] += value; numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_) <<CoinMessageEol; return numberErrors; } } else { row[numberElements_] = irow; element[numberElements_] = value; rowUsed[irow] = numberElements_; numberElements_++; } } } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } break; case COIN_INTORG: inIntegerSet = true; break; case COIN_INTEND: inIntegerSet = false; break; case COIN_S1_COLUMN: case COIN_S2_COLUMN: case COIN_S3_COLUMN: case COIN_SOSEND: std::cout << "** code sos etc later" << std::endl; abort ( ); break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } start[numberColumns_] = numberElements_; delete[]rowUsed; if ( cardReader_->whichSection ( ) != COIN_RHS_SECTION ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } columnType = ( COINMpsType * ) realloc ( columnType, numberColumns_ * sizeof ( COINMpsType ) ); columnName = ( char ** ) realloc ( columnName, numberColumns_ * sizeof ( char * ) ); objective_ = ( double * ) realloc ( objective_, numberColumns_ * sizeof ( double ) ); start = ( CoinBigIndex * ) realloc ( start, ( numberColumns_ + 1 ) * sizeof ( CoinBigIndex ) ); row = ( COINRowIndex * ) realloc ( row, numberElements_ * sizeof ( COINRowIndex ) ); element = ( double * ) realloc ( element, numberElements_ * sizeof ( double ) ); rowlower_ = ( double * ) malloc ( numberRows_ * sizeof ( double ) ); rowupper_ = ( double * ) malloc ( numberRows_ * sizeof ( double ) ); for (i=0;i<numberRows_;i++) { rowlower_[i]=-infinity_; rowupper_[i]=infinity_; } objUsed = false; memset ( lastColumn, '\0', 200 ); bool gotRhs = false; // need coding for blank rhs while ( cardReader_->nextField ( ) == COIN_RHS_SECTION ) { COINRowIndex irow; switch ( cardReader_->mpsType ( ) ) { case COIN_BLANK_COLUMN: if ( strcmp ( lastColumn, cardReader_->columnName ( ) ) ) { // skip rest if got a rhs if ( gotRhs ) { while ( cardReader_->nextField ( ) == COIN_RHS_SECTION ) { } break; } else { gotRhs = true; strcpy ( lastColumn, cardReader_->columnName ( ) ); // save name of section free(rhsName_); rhsName_=strdup(cardReader_->columnName()); } } // get row number irow = findHash ( cardReader_->rowName ( ) , 0 ); if ( irow >= 0 ) { double value = cardReader_->value ( ); // check for duplicates if ( irow == numberRows_ ) { // objective if ( objUsed ) { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPOBJ,messages_) <<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } else { objUsed = true; } objectiveOffset_ += value; } else if ( irow < numberRows_ ) { if ( rowlower_[irow] != -infinity_ ) { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } else { rowlower_[irow] = value; } } } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } if ( cardReader_->whichSection ( ) == COIN_RANGES_SECTION ) { memset ( lastColumn, '\0', 200 ); bool gotRange = false; COINRowIndex irow; // need coding for blank range while ( cardReader_->nextField ( ) == COIN_RANGES_SECTION ) { switch ( cardReader_->mpsType ( ) ) { case COIN_BLANK_COLUMN: if ( strcmp ( lastColumn, cardReader_->columnName ( ) ) ) { // skip rest if got a range if ( gotRange ) { while ( cardReader_->nextField ( ) == COIN_RANGES_SECTION ) { } break; } else { gotRange = true; strcpy ( lastColumn, cardReader_->columnName ( ) ); // save name of section free(rangeName_); rangeName_=strdup(cardReader_->columnName()); } } // get row number irow = findHash ( cardReader_->rowName ( ) , 0 ); if ( irow >= 0 ) { double value = cardReader_->value ( ); // check for duplicates if ( irow == numberRows_ ) { // objective numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPOBJ,messages_) <<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } else { if ( rowupper_[irow] != infinity_ ) { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_DUPROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_) <<CoinMessageEol; return numberErrors; } } else { rowupper_[irow] = value; } } } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } } stopHash ( 0 ); // massage ranges { COINRowIndex irow; for ( irow = 0; irow < numberRows_; irow++ ) { double lo = rowlower_[irow]; double up = rowupper_[irow]; double up2 = rowupper_[irow]; //range switch ( rowType[irow] ) { case COIN_E_ROW: if ( lo == -infinity_ ) lo = 0.0; if ( up == infinity_ ) { up = lo; } else if ( up > 0.0 ) { up += lo; } else { up = lo; lo += up2; } break; case COIN_L_ROW: if ( lo == -infinity_ ) { up = 0.0; } else { up = lo; lo = -infinity_; } if ( up2 != infinity_ ) { lo = up - fabs ( up2 ); } break; case COIN_G_ROW: if ( lo == -infinity_ ) { lo = 0.0; up = infinity_; } else { up = infinity_; } if ( up2 != infinity_ ) { up = lo + fabs ( up2 ); } break; default: abort(); } rowlower_[irow] = lo; rowupper_[irow] = up; } } free ( rowType ); // default bounds collower_ = ( double * ) malloc ( numberColumns_ * sizeof ( double ) ); colupper_ = ( double * ) malloc ( numberColumns_ * sizeof ( double ) ); for (i=0;i<numberColumns_;i++) { collower_[i]=0.0; colupper_[i]=infinity_; } // set up integer region just in case integerType_ = (char *) malloc (numberColumns_*sizeof(char)); for ( column = 0; column < numberColumns_; column++ ) { if ( columnType[column] == COIN_INTORG ) { columnType[column] = COIN_UNSET_BOUND; integerType_[column] = 1; } else { integerType_[column] = 0; } } // start hash even if no bound section - to make sure names survive startHash ( columnName, numberColumns_ , 1 ); if ( cardReader_->whichSection ( ) == COIN_BOUNDS_SECTION ) { memset ( lastColumn, '\0', 200 ); bool gotBound = false; while ( cardReader_->nextField ( ) == COIN_BOUNDS_SECTION ) { if ( strcmp ( lastColumn, cardReader_->columnName ( ) ) ) { // skip rest if got a bound if ( gotBound ) { while ( cardReader_->nextField ( ) == COIN_BOUNDS_SECTION ) { } break; } else { gotBound = true;; strcpy ( lastColumn, cardReader_->columnName ( ) ); // save name of section free(boundName_); boundName_=strdup(cardReader_->columnName()); } } // get column number COINColumnIndex icolumn = findHash ( cardReader_->rowName ( ) , 1 ); if ( icolumn >= 0 ) { double value = cardReader_->value ( ); bool ifError = false; switch ( cardReader_->mpsType ( ) ) { case COIN_UP_BOUND: if ( value == -1.0e100 ) ifError = true; if ( columnType[icolumn] == COIN_UNSET_BOUND ) { if ( value < 0.0 ) { collower_[icolumn] = -infinity_; } } else if ( columnType[icolumn] == COIN_LO_BOUND ) { if ( value < collower_[icolumn] ) { ifError = true; } else if ( value < collower_[icolumn] + tinyElement ) { value = collower_[icolumn]; } } else if ( columnType[icolumn] == COIN_MI_BOUND ) { } else { ifError = true; } colupper_[icolumn] = value; columnType[icolumn] = COIN_UP_BOUND; break; case COIN_LO_BOUND: if ( value == -1.0e100 ) ifError = true; if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else if ( columnType[icolumn] == COIN_UP_BOUND || columnType[icolumn] == COIN_UI_BOUND ) { if ( value > colupper_[icolumn] ) { ifError = true; } else if ( value > colupper_[icolumn] - tinyElement ) { value = colupper_[icolumn]; } } else { ifError = true; } collower_[icolumn] = value; columnType[icolumn] = COIN_LO_BOUND; break; case COIN_FX_BOUND: if ( value == -1.0e100 ) ifError = true; if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else if ( columnType[icolumn] == COIN_UI_BOUND || columnType[icolumn] == COIN_BV_BOUND) { // Allow so people can easily put FX's at end double value2 = floor(value); if (fabs(value2-value)>1.0e-12|| value2<collower_[icolumn]|| value2>colupper_[icolumn]) { ifError=true; } else { // take off integer list assert(integerType_[icolumn] ); numberIntegers--; integerType_[icolumn] = 0; } } else { ifError = true; } collower_[icolumn] = value; colupper_[icolumn] = value; columnType[icolumn] = COIN_FX_BOUND; break; case COIN_FR_BOUND: if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else { ifError = true; } collower_[icolumn] = -infinity_; colupper_[icolumn] = infinity_; columnType[icolumn] = COIN_FR_BOUND; break; case COIN_MI_BOUND: if ( columnType[icolumn] == COIN_UNSET_BOUND ) { colupper_[icolumn] = COIN_DBL_MAX; } else if ( columnType[icolumn] == COIN_UP_BOUND ) { } else { ifError = true; } collower_[icolumn] = -infinity_; columnType[icolumn] = COIN_MI_BOUND; break; case COIN_PL_BOUND: if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else { ifError = true; } columnType[icolumn] = COIN_PL_BOUND; break; case COIN_UI_BOUND: #if 0 if ( value == -1.0e100 ) ifError = true; if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else if ( columnType[icolumn] == COIN_LO_BOUND ) { if ( value < collower_[icolumn] ) { ifError = true; } else if ( value < collower_[icolumn] + tinyElement ) { value = collower_[icolumn]; } } else { ifError = true; } #else if ( value == -1.0e100 ) { value = infinity_; if (columnType[icolumn] != COIN_UNSET_BOUND && columnType[icolumn] != COIN_LO_BOUND) { ifError = true; } } else { if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else if ( columnType[icolumn] == COIN_LO_BOUND ) { if ( value < collower_[icolumn] ) { ifError = true; } else if ( value < collower_[icolumn] + tinyElement ) { value = collower_[icolumn]; } } else { ifError = true; } } #endif colupper_[icolumn] = value; columnType[icolumn] = COIN_UI_BOUND; if ( !integerType_[icolumn] ) { numberIntegers++; integerType_[icolumn] = 1; } break; case COIN_BV_BOUND: if ( columnType[icolumn] == COIN_UNSET_BOUND ) { } else { ifError = true; } collower_[icolumn] = 0.0; colupper_[icolumn] = 1.0; columnType[icolumn] = COIN_BV_BOUND; if ( !integerType_[icolumn] ) { numberIntegers++; integerType_[icolumn] = 1; } break; default: ifError = true; break; } if ( ifError ) { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_) <<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHCOL,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } } stopHash ( 1 ); // clean up integers if ( !numberIntegers ) { free(integerType_); integerType_ = NULL; } else { COINColumnIndex icolumn; for ( icolumn = 0; icolumn < numberColumns_; icolumn++ ) { if ( integerType_[icolumn] ) { assert ( collower_[icolumn] >= -MAX_INTEGER ); // if 0 infinity make 0-1 ??? if ( columnType[icolumn] == COIN_UNSET_BOUND ) colupper_[icolumn] = defaultBound_; if ( colupper_[icolumn] > MAX_INTEGER ) colupper_[icolumn] = MAX_INTEGER; } } } free ( columnType ); if ( cardReader_->whichSection ( ) != COIN_ENDATA_SECTION ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } else { // This is very simple format - what should we use? COINColumnIndex i; FILE * fp = cardReader_->filePointer(); fscanf ( fp, "%d %d %d\n", &numberRows_, &numberColumns_, &i); numberElements_ = i; // done this way in case numberElements_ long rowlower_ = ( double * ) malloc ( numberRows_ * sizeof ( double ) ); rowupper_ = ( double * ) malloc ( numberRows_ * sizeof ( double ) ); for ( i = 0; i < numberRows_; i++ ) { int j; fscanf ( fp, "%d %lg %lg\n", &j, &rowlower_[i], &rowupper_[i] ); assert ( i == j ); } collower_ = ( double * ) malloc ( numberColumns_ * sizeof ( double ) ); colupper_ = ( double * ) malloc ( numberColumns_ * sizeof ( double ) ); objective_= ( double * ) malloc ( numberColumns_ * sizeof ( double ) ); start = ( CoinBigIndex *) malloc ((numberColumns_ + 1) * sizeof (CoinBigIndex) ); row = ( COINRowIndex * ) malloc (numberElements_ * sizeof (COINRowIndex)); element = ( double * ) malloc (numberElements_ * sizeof (double) ); start[0] = 0; numberElements_ = 0; for ( i = 0; i < numberColumns_; i++ ) { int j; int n; fscanf ( fp, "%d %d %lg %lg %lg\n", &j, &n, &collower_[i], &colupper_[i], &objective_[i] ); assert ( i == j ); for ( j = 0; j < n; j++ ) { fscanf ( fp, " %d %lg\n", &row[numberElements_], &element[numberElements_] ); numberElements_++; } start[i + 1] = numberElements_; } } // construct packed matrix matrixByColumn_ = new CoinPackedMatrix(true, numberRows_,numberColumns_,numberElements_, element,row,start,NULL); free ( row ); free ( start ); free ( element ); handler_->message(COIN_MPS_STATS,messages_)<<problemName_ <<numberRows_ <<numberColumns_ <<numberElements_ <<CoinMessageEol; return numberErrors; }

int CoinMpsIO::readMps (  const char *  filename, const char *  extension = "mps" )

Read a problem in MPS format from the given filename. Use "stdin" or "-" to read from stdin. Definition at line 1042 of file CoinMpsIO.cpp. References cardReader_, dealWithFileName(), and readMps(). { // Deal with filename - +1 if new, 0 if same as before, -1 if error FILE *fp=NULL; gzFile gzfp=NULL; int returnCode = dealWithFileName(filename,extension,fp,gzfp); if (returnCode<0) { return -1; } else if (returnCode>0) { delete cardReader_; cardReader_ = new CoinMpsCardReader ( fp , gzfp, this); } return readMps(); }

int CoinMpsIO::readQuadraticMps (  const char *  filename, int *&  columnStart, int *&  column, double *&  elements, int  checkSymmetry )

Read in a quadratic objective from the given filename. If filename is NULL (or the same as the currently open file) then reading continues from the current file. If not, the file is closed and the specified file is opened. Code should be added to general MPS reader to read this if QSECTION Data is assumed to be Q and objective is c + 1/2 xT Q x No assumption is made for symmetry, positive definite, etc. No check is made for duplicates or non-triangular if checkSymmetry==0. If 1 checks lower triangular (so off diagonal should be 2*Q) if 2 makes lower triangular and assumes full Q (but adds off diagonals) Arrays should be deleted by delete [] Returns number of errors: -1: bad file -2: no Quadratic section -3: an empty section +n: then matching errors etc (symmetry forced) -4: no matching errors but fails triangular test (triangularity forced) columnStart is numberColumns+1 long, others numberNonZeros Definition at line 3282 of file CoinMpsIO.cpp. References CoinMpsCardReader::card(), CoinMpsCardReader::cardNumber(), cardReader_, CoinMpsCardReader::columnName(), dealWithFileName(), fileName_, findHash(), handler_, CoinMessageHandler::message(), messages_, CoinMpsCardReader::mpsType(), CoinMpsCardReader::nextField(), problemName_, CoinMpsCardReader::readToNextSection(), CoinMpsCardReader::rowName(), startHash(), stopHash(), CoinMpsCardReader::value(), and CoinMpsCardReader::whichSection(). { // Deal with filename - +1 if new, 0 if same as before, -1 if error FILE *fp=NULL; gzFile gzfp=NULL; int returnCode = dealWithFileName(filename,"",fp,gzfp); if (returnCode<0) { return -1; } else if (returnCode>0) { delete cardReader_; cardReader_ = new CoinMpsCardReader ( fp , gzfp, this); } cardReader_->readToNextSection(); // Skip NAME if ( cardReader_->whichSection ( ) == COIN_NAME_SECTION ) cardReader_->readToNextSection(); if ( cardReader_->whichSection ( ) == COIN_QUADRATIC_SECTION ) { // save name of section free(problemName_); problemName_=strdup(cardReader_->columnName()); } else if ( cardReader_->whichSection ( ) == COIN_EOF_SECTION ) { handler_->message(COIN_MPS_EOF,messages_)<<fileName_ <<CoinMessageEol; return -3; } else { handler_->message(COIN_MPS_BADFILE1,messages_)<<cardReader_->card() <<cardReader_->cardNumber() <<fileName_ <<CoinMessageEol; return -2; } int numberErrors = 0; // Guess at size of data int maximumNonZeros = 5 *numberColumns_; // Use malloc so can use realloc int * column = (int *) malloc(maximumNonZeros*sizeof(int)); int * column2Temp = (int *) malloc(maximumNonZeros*sizeof(int)); double * elementTemp = (double *) malloc(maximumNonZeros*sizeof(double)); startHash(1); int numberElements=0; const double tinyElement = 1.0e-14; while ( cardReader_->nextField ( ) == COIN_QUADRATIC_SECTION ) { switch ( cardReader_->mpsType ( ) ) { case COIN_BLANK_COLUMN: if ( fabs ( cardReader_->value ( ) ) > tinyElement ) { if ( numberElements == maximumNonZeros ) { maximumNonZeros = ( 3 * maximumNonZeros ) / 2 + 1000; column = ( COINColumnIndex * ) realloc ( column, maximumNonZeros * sizeof ( COINColumnIndex ) ); column2Temp = ( COINColumnIndex * ) realloc ( column2Temp, maximumNonZeros * sizeof ( COINColumnIndex ) ); elementTemp = ( double * ) realloc ( elementTemp, maximumNonZeros * sizeof ( double ) ); } // get indices COINColumnIndex iColumn1 = findHash ( cardReader_->columnName ( ) , 1 ); COINColumnIndex iColumn2 = findHash ( cardReader_->rowName ( ) , 1 ); if ( iColumn1 >= 0 ) { if (iColumn2 >=0) { double value = cardReader_->value ( ); column[numberElements]=iColumn1; column2Temp[numberElements]=iColumn2; elementTemp[numberElements++]=value; } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHROW,messages_) <<cardReader_->rowName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } else { numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_NOMATCHCOL,messages_) <<cardReader_->columnName()<<cardReader_->cardNumber()<<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } break; default: numberErrors++; if ( numberErrors < 100 ) { handler_->message(COIN_MPS_BADIMAGE,messages_)<<cardReader_->cardNumber() <<cardReader_->card() <<CoinMessageEol; } else if (numberErrors > 100000) { handler_->message(COIN_MPS_RETURNING,messages_)<<CoinMessageEol; return numberErrors; } } } stopHash(1); // Do arrays as new [] and make column ordered columnStart = new int [numberColumns_+1]; // for counts int * count = new int[numberColumns_]; memset(count,0,numberColumns_*sizeof(int)); CoinBigIndex i; // See about lower triangular if (checkSymmetry&&numberErrors) checkSymmetry=2; // force corrections if (checkSymmetry) { if (checkSymmetry==1) { // just check lower triangular for ( i = 0; i < numberElements; i++ ) { int iColumn = column[i]; int iColumn2 = column2Temp[i]; if (iColumn2<iColumn) { numberErrors=-4; column[i]=iColumn2; column2Temp[i]=iColumn; } } } else { // make lower triangular for ( i = 0; i < numberElements; i++ ) { int iColumn = column[i]; int iColumn2 = column2Temp[i]; if (iColumn2<iColumn) { column[i]=iColumn2; column2Temp[i]=iColumn; } } } } for ( i = 0; i < numberElements; i++ ) { int iColumn = column[i]; count[iColumn]++; } // Do starts int number = 0; columnStart[0]=0; for (i=0;i<numberColumns_;i++) { number += count[i]; count[i]= columnStart[i]; columnStart[i+1]=number; } column2 = new int[numberElements]; elements = new double[numberElements]; // Get column ordering for ( i = 0; i < numberElements; i++ ) { int iColumn = column[i]; int iColumn2 = column2Temp[i]; int put = count[iColumn]; elements[put]=elementTemp[i]; column2[put++]=iColumn2; count[iColumn]=put; } free(column); free(column2Temp); free(elementTemp); // Now in column order - deal with duplicates for (i=0;i<numberColumns_;i++) count[i] = -1; int start = 0; number=0; for (i=0;i<numberColumns_;i++) { int j; for (j=start;j<columnStart[i+1];j++) { int iColumn2 = column2[j]; if (count[iColumn2]<0) { count[iColumn2]=j; } else { // duplicate int iOther = count[iColumn2]; double value = elements[iOther]+elements[j]; elements[iOther]=value; elements[j]=0.0; } } for (j=start;j<columnStart[i+1];j++) { int iColumn2 = column2[j]; count[iColumn2]=-1; double value = elements[j]; if (value) { column2[number]=iColumn2; elements[number++]=value; } } start = columnStart[i+1]; columnStart[i+1]=number; } delete [] count; return numberErrors; }

void CoinMpsIO::releaseRedundantInformation (   )

Release all information which can be re-calculated. E.g., row sense, copies of rows, hash tables for names. Definition at line 3241 of file CoinMpsIO.cpp. References hash_, matrixByRow_, rhs_, rowrange_, and rowsense_. Referenced by freeAll(), releaseColumnNames(), releaseMatrixInformation(), and releaseRowNames(). { free( rowsense_); free( rhs_); free( rowrange_); rowsense_=NULL; rhs_=NULL; rowrange_=NULL; free (hash_[0]); free (hash_[1]); hash_[0]=0; hash_[1]=0; delete matrixByRow_; matrixByRow_=NULL; }

int CoinMpsIO::rowIndex (  const char *  name  )  const

Returns the index for the specified row name Returns -1 if the name is not found. Returns numberRows for the objective row and > numberRows for dropped free rows. Definition at line 2931 of file CoinMpsIO.cpp. References findHash(), hash_, and startHash(). { if (!hash_[0]) { if (numberRows_) { startHash(0); } else { return -1; } } return findHash ( name , 0 ); }

const char * CoinMpsIO::rowName (  int  index  )  const

Returns the row name for the specified index. Returns 0 if the index is out of range. Definition at line 2914 of file CoinMpsIO.cpp. Referenced by readMps(). { if (index>=0&&index<numberRows_) { return names_[0][index]; } else { return NULL; } }

int CoinMpsIO::writeMps (  const char *  filename, int  compression = 0, int  formatType = 0, int  numberAcross = 2 )  const

Write the problem in MPS format to a file with the given filename. Parameters: compression  can be set to three values to indicate what kind of file should be written 0: plain text (default) 1: gzip compressed (.gz is appended to filename) 2: bzip2 compressed (.bz2 is appended to filename) (TODO) If the library was not compiled with the requested compression then writeMps falls back to writing a plain text file. formatType  specifies the precision to used for values in the MPS file 0: normal precision (default) 1: extra accuracy 2: IEEE hex (TODO) numberAcross  specifies whether 1 or 2 (default) values should be specified on every data line in the MPS file. Definition at line 2104 of file CoinMpsIO.cpp. References getColLower(), getColUpper(), getMatrixByCol(), getObjCoefficients(), getRowLower(), getRowSense(), getRowUpper(), infinity_, isInteger(), names_, numberColumns_, numberRows_, and problemName_. { std::string line = filename; FILE * fp = NULL; gzFile gzfp = NULL; switch (compression) { case 1: #ifdef COIN_USE_ZLIB { if (strcmp(line.c_str() +(line.size()-3), ".gz") != 0) { line += ".gz"; } gzfp = gzopen(line.c_str(), "wb"); if (gzfp) { break; } } #endif fp = fopen(filename,"w"); if (!fp) return -1; break; case 2: /* bzip2: to be implemented */ case 0: fp = fopen(filename,"w"); if (!fp) return -1; break; } const char * const * const rowNames = names_[0]; const char * const * const columnNames = names_[1]; int i; unsigned int length = 8; bool freeFormat = (formatType!=0); for (i = 0 ; i < numberRows_; ++i) { if (strlen(rowNames[i]) > length) { length = strlen(rowNames[i]); break; } } if (length <= 8) { for (i = 0 ; i < numberColumns_; ++i) { if (strlen(columnNames[i]) > length) { length = strlen(columnNames[i]); break; } } } if (length > 8 && !freeFormat) { freeFormat = true; formatType = 4; } // NAME card line = "NAME "; if (strcmp(problemName_,"")==0) { line.append("BLANK "); } else { if (strlen(problemName_) >= 8) { line.append(problemName_, 8); } else { line.append(problemName_); line.append(8-strlen(problemName_), ' '); } } if (freeFormat) line.append(" FREE"); // finish off name and do ROWS card and objective line.append("\nROWS\n N OBJROW\n"); writeString(fp, gzfp, line.c_str()); // Rows section // Sense array // But massage if looks odd char * sense = new char [numberRows_]; memcpy( sense , getRowSense(), numberRows_); const double * rowLower = getRowLower(); const double * rowUpper = getRowUpper(); for (i=0;i<numberRows_;i++) { line = " "; if (sense[i]!='R') { line.append(1,sense[i]); } else { if (rowLower[i]>-1.0e30) { if(rowUpper[i]<1.0e30) { line.append("L"); } else { sense[i]='G'; line.append(1,sense[i]); } } else { sense[i]='L'; line.append(1,sense[i]); } } line.append(" "); line.append(rowNames[i]); line.append("\n"); writeString(fp, gzfp, line.c_str()); } // COLUMNS card writeString(fp, gzfp, "COLUMNS\n"); bool ifBounds=false; double largeValue = infinity_; const double * columnLower = getColLower(); const double * columnUpper = getColUpper(); const double * objective = getObjCoefficients(); const CoinPackedMatrix * matrix = getMatrixByCol(); const double * elements = matrix->getElements(); const int * rows = matrix->getIndices(); const CoinBigIndex * starts = matrix->getVectorStarts(); const int * lengths = matrix->getVectorLengths(); char outputValue[2][20]; char outputRow[2][100]; // Through columns (only put out if elements or objective value) for (i=0;i<numberColumns_;i++) { if (objective[i]||lengths[i]) { // see if bound will be needed if (columnLower[i]||columnUpper[i]<largeValue||isInteger(i)) ifBounds=true; int numberFields=0; if (objective[i]) { convertDouble(formatType,objective[i],outputValue[0], "OBJROW",outputRow[0]); numberFields=1; } if (numberFields==numberAcross) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", columnNames[i], outputValue, outputRow); numberFields=0; } int j; for (j=0;j<lengths[i];j++) { convertDouble(formatType,elements[starts[i]+j], outputValue[numberFields], rowNames[rows[starts[i]+j]], outputRow[numberFields]); numberFields++; if (numberFields==numberAcross) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", columnNames[i], outputValue, outputRow); numberFields=0; } } if (numberFields) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", columnNames[i], outputValue, outputRow); } } } bool ifRange=false; // RHS writeString(fp, gzfp, "RHS\n"); int numberFields = 0; for (i=0;i<numberRows_;i++) { double value; switch (sense[i]) { case 'E': value=rowLower[i]; break; case 'R': value=rowUpper[i]; ifRange=true; break; case 'L': value=rowUpper[i]; break; case 'G': value=rowLower[i]; break; default: value=0.0; break; } if (value != 0.0) { convertDouble(formatType,value, outputValue[numberFields], rowNames[i], outputRow[numberFields]); numberFields++; if (numberFields==numberAcross) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", "RHS", outputValue, outputRow); numberFields=0; } } } if (numberFields) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", "RHS", outputValue, outputRow); } if (ifRange) { // RANGES writeString(fp, gzfp, "RANGES\n"); numberFields = 0; for (i=0;i<numberRows_;i++) { if (sense[i]=='R') { double value =rowUpper[i]-rowLower[i]; if (value<1.0e30) { convertDouble(formatType,value, outputValue[numberFields], rowNames[i], outputRow[numberFields]); numberFields++; if (numberFields==numberAcross) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", "RANGE", outputValue, outputRow); numberFields=0; } } } } if (numberFields) { // put out card outputCard(formatType, numberFields, fp, gzfp, " ", "RANGE", outputValue, outputRow); } } delete [] sense; if (ifBounds) { // BOUNDS writeString(fp, gzfp, "BOUNDS\n"); for (i=0;i<numberColumns_;i++) { if (objective[i]||lengths[i]) { // see if bound will be needed if (columnLower[i]||columnUpper[i]<largeValue||isInteger(i)) { double lowerValue = columnLower[i]; double upperValue = columnUpper[i]; if (isInteger(i)) { // Old argument - what are correct ranges for integer variables lowerValue = max(lowerValue,(double) -INT_MAX); upperValue = min(upperValue,(double) INT_MAX); } int numberFields=1; std::string header[2]; double value[2]; if (lowerValue<=-largeValue) { // FR or MI if (upperValue>=largeValue) { header[0]=" FR "; value[0] = largeValue; } else { header[0]=" MI "; value[0] = largeValue; header[1]=" UP "; value[1] = upperValue; numberFields=2; } } else if (fabs(upperValue-lowerValue)<1.0e-8) { header[0]=" FX "; value[0] = lowerValue; } else { // do LO if needed if (lowerValue) { // LO header[0]=" LO "; value[0] = lowerValue; if (isInteger(i)) { // Integer variable so UI header[1]=" UI "; value[1] = upperValue; numberFields=2; } else if (upperValue<largeValue) { // UP header[1]=" UP "; value[1] = upperValue; numberFields=2; } } else { if (isInteger(i)) { // Integer variable so BV or UI if (fabs(upperValue-1.0)<1.0e-8) { // BV header[0]=" BV "; value[0] = largeValue; } else { // UI header[0]=" UI "; value[0] = upperValue; } } else { // UP header[0]=" UP "; value[0] = upperValue; } } } // put out fields int j; for (j=0;j<numberFields;j++) { convertDouble(formatType,value[j], outputValue[0], columnNames[i], outputRow[0]); // put out card outputCard(formatType, 1, fp, gzfp, header[j], "BOUND", outputValue, outputRow); } } } } } // and finish writeString(fp, gzfp, "ENDATA\n"); if (fp) { fclose(fp); } #ifdef COIN_USE_ZLIB if (gzfp) { gzclose(gzfp); } #endif return 0; }

---

Friends And Related Function Documentation

void CoinMpsIOUnitTest (  const std::string &  mpsDir  )  [friend]

A function that tests the methods in the CoinMpsIO class. The only reason for it not to be a member method is that this way it doesn't have to be compiled into the library. And that's a gain, because the library should be compiled with optimization on, but this method should be compiled with debugging. Also, if this method is compiled with optimization, the compilation takes 10-15 minutes and the machine pages (has 256M core memory!)... Definition at line 21 of file CoinMpsIOTest.cpp. { // Test default constructor { CoinMpsIO m; assert( m.rowsense_==NULL ); assert( m.rhs_==NULL ); assert( m.rowrange_==NULL ); assert( m.matrixByRow_==NULL ); assert( m.matrixByColumn_==NULL ); assert( m.integerType_==NULL); assert( !strcmp( m.getFileName() , "stdin")); assert( !strcmp( m.getProblemName() , "")); assert( !strcmp( m.objectiveName_ , "")); assert( !strcmp( m.rhsName_ , "")); assert( !strcmp( m.rangeName_ , "")); assert( !strcmp( m.boundName_ , "")); } { CoinRelFltEq eq; CoinMpsIO m; std::string fn = mpsDir+"exmip1"; int numErr = m.readMps(fn.c_str(),"mps"); assert( numErr== 0 ); assert( !strcmp( m.problemName_ , "EXAMPLE")); assert( !strcmp( m.objectiveName_ , "OBJ")); assert( !strcmp( m.rhsName_ , "RHS1")); assert( !strcmp( m.rangeName_ , "RNG1")); assert( !strcmp( m.boundName_ , "BND1")); // Test language and re-use m.newLanguage(CoinMessages::it); m.messageHandler()->setPrefix(false); // This call should return an error indicating that the // end-of-file was reached. // This is because the file remains open to possibly read // a quad. section. numErr = m.readMps(fn.c_str(),"mps"); assert( numErr < 0 ); // Test copy constructor and assignment operator { CoinMpsIO lhs; { CoinMpsIO im(m); CoinMpsIO imC1(im); assert( imC1.getNumCols() == im.getNumCols() ); assert( imC1.getNumRows() == im.getNumRows() ); CoinMpsIO imC2(im); assert( imC2.getNumCols() == im.getNumCols() ); assert( imC2.getNumRows() == im.getNumRows() ); lhs=imC2; } // Test that lhs has correct values even though rhs has gone out of scope assert( lhs.getNumCols() == m.getNumCols() ); assert( lhs.getNumRows() == m.getNumRows() ); } { CoinMpsIO dumSi(m); int nc = dumSi.getNumCols(); int nr = dumSi.getNumRows(); const double * cl = dumSi.getColLower(); const double * cu = dumSi.getColUpper(); const double * rl = dumSi.getRowLower(); const double * ru = dumSi.getRowUpper(); assert( nc == 8 ); assert( nr == 5 ); assert( eq(cl[0],2.5) ); assert( eq(cl[1],0.0) ); assert( eq(cu[1],4.1) ); assert( eq(cu[2],1.0) ); assert( eq(rl[0],2.5) ); assert( eq(rl[4],3.0) ); assert( eq(ru[1],2.1) ); assert( eq(ru[4],15.0) ); assert( !eq(cl[3],1.2345) ); assert( !eq(cu[4],10.2345) ); assert( eq( dumSi.getObjCoefficients()[0], 1.0) ); assert( eq( dumSi.getObjCoefficients()[1], 0.0) ); assert( eq( dumSi.getObjCoefficients()[2], 0.0) ); assert( eq( dumSi.getObjCoefficients()[3], 0.0) ); assert( eq( dumSi.getObjCoefficients()[4], 2.0) ); assert( eq( dumSi.getObjCoefficients()[5], 0.0) ); assert( eq( dumSi.getObjCoefficients()[6], 0.0) ); assert( eq( dumSi.getObjCoefficients()[7], -1.0) ); dumSi.writeMps("CoinMpsIoTest.mps");//,0,0,1); } // Read just written file { CoinMpsIO dumSi; dumSi.readMps("CoinMpsIoTest"); int nc = dumSi.getNumCols(); int nr = dumSi.getNumRows(); const double * cl = dumSi.getColLower(); const double * cu = dumSi.getColUpper(); const double * rl = dumSi.getRowLower(); const double * ru = dumSi.getRowUpper(); assert( nc == 8 ); assert( nr == 5 ); assert( eq(cl[0],2.5) ); assert( eq(cl[1],0.0) ); assert( eq(cu[1],4.1) ); assert( eq(cu[2],1.0) ); assert( eq(rl[0],2.5) ); assert( eq(rl[4],3.0) ); assert( eq(ru[1],2.1) ); assert( eq(ru[4],15.0) ); assert( !eq(cl[3],1.2345) ); assert( !eq(cu[4],10.2345) ); assert( eq( dumSi.getObjCoefficients()[0], 1.0) ); assert( eq( dumSi.getObjCoefficients()[1], 0.0) ); assert( eq( dumSi.getObjCoefficients()[2], 0.0) ); assert( eq( dumSi.getObjCoefficients()[3], 0.0) ); assert( eq( dumSi.getObjCoefficients()[4], 2.0) ); assert( eq( dumSi.getObjCoefficients()[5], 0.0) ); assert( eq( dumSi.getObjCoefficients()[6], 0.0) ); assert( eq( dumSi.getObjCoefficients()[7], -1.0) ); } // Test matrixByRow method { const CoinMpsIO si(m); const CoinPackedMatrix * smP = si.getMatrixByRow(); // LL: const CoinDumPackedMatrix * osmP = dynamic_cast<const CoinDumPackedMatrix*>(smP); // LL: assert( osmP!=NULL ); CoinRelFltEq eq; const double * ev = smP->getElements(); assert( eq(ev[0], 3.0) ); assert( eq(ev[1], 1.0) ); assert( eq(ev[2], -2.0) ); assert( eq(ev[3], -1.0) ); assert( eq(ev[4], -1.0) ); assert( eq(ev[5], 2.0) ); assert( eq(ev[6], 1.1) ); assert( eq(ev[7], 1.0) ); assert( eq(ev[8], 1.0) ); assert( eq(ev[9], 2.8) ); assert( eq(ev[10], -1.2) ); assert( eq(ev[11], 5.6) ); assert( eq(ev[12], 1.0) ); assert( eq(ev[13], 1.9) ); const CoinBigIndex * mi = smP->getVectorStarts(); assert( mi[0]==0 ); assert( mi[1]==5 ); assert( mi[2]==7 ); assert( mi[3]==9 ); assert( mi[4]==11 ); assert( mi[5]==14 ); const int * ei = smP->getIndices(); assert( ei[0] == 0 ); assert( ei[1] == 1 ); assert( ei[2] == 3 ); assert( ei[3] == 4 ); assert( ei[4] == 7 ); assert( ei[5] == 1 ); assert( ei[6] == 2 ); assert( ei[7] == 2 ); assert( ei[8] == 5 ); assert( ei[9] == 3 ); assert( ei[10] == 6 ); assert( ei[11] == 0 ); assert( ei[12] == 4 ); assert( ei[13] == 7 ); assert( smP->getMajorDim() == 5 ); assert( smP->getNumElements() == 14 ); } // Test matrixByCol method { const CoinMpsIO si(m); const CoinPackedMatrix * smP = si.getMatrixByCol(); // LL: const CoinDumPackedMatrix * osmP = dynamic_cast<const CoinDumPackedMatrix*>(smP); // LL: assert( osmP!=NULL ); CoinRelFltEq eq; const double * ev = smP->getElements(); assert( eq(ev[0], 3.0) ); assert( eq(ev[1], 5.6) ); assert( eq(ev[2], 1.0) ); assert( eq(ev[3], 2.0) ); assert( eq(ev[4], 1.1) ); assert( eq(ev[5], 1.0) ); assert( eq(ev[6], -2.0) ); assert( eq(ev[7], 2.8) ); assert( eq(ev[8], -1.0) ); assert( eq(ev[9], 1.0) ); assert( eq(ev[10], 1.0) ); assert( eq(ev[11], -1.2) ); assert( eq(ev[12], -1.0) ); assert( eq(ev[13], 1.9) ); const CoinBigIndex * mi = smP->getVectorStarts(); assert( mi[0]==0 ); assert( mi[1]==2 ); assert( mi[2]==4 ); assert( mi[3]==6 ); assert( mi[4]==8 ); assert( mi[5]==10 ); assert( mi[6]==11 ); assert( mi[7]==12 ); assert( mi[8]==14 ); const int * ei = smP->getIndices(); assert( ei[0] == 0 ); assert( ei[1] == 4 ); assert( ei[2] == 0 ); assert( ei[3] == 1 ); assert( ei[4] == 1 ); assert( ei[5] == 2 ); assert( ei[6] == 0 ); assert( ei[7] == 3 ); assert( ei[8] == 0 ); assert( ei[9] == 4 ); assert( ei[10] == 2 ); assert( ei[11] == 3 ); assert( ei[12] == 0 ); assert( ei[13] == 4 ); assert( smP->getMajorDim() == 8 ); assert( smP->getNumElements() == 14 ); assert( smP->getSizeVectorStarts()==9 ); assert( smP->getMinorDim() == 5 ); } //-------------- // Test rowsense, rhs, rowrange, matrixByRow { CoinMpsIO lhs; { assert( m.rowrange_==NULL ); assert( m.rowsense_==NULL ); assert( m.rhs_==NULL ); assert( m.matrixByRow_==NULL ); CoinMpsIO siC1(m); assert( siC1.rowrange_==NULL ); assert( siC1.rowsense_==NULL ); assert( siC1.rhs_==NULL ); assert( siC1.matrixByRow_==NULL ); const char * siC1rs = siC1.getRowSense(); assert( siC1rs[0]=='G' ); assert( siC1rs[1]=='L' ); assert( siC1rs[2]=='E' ); assert( siC1rs[3]=='R' ); assert( siC1rs[4]=='R' ); const double * siC1rhs = siC1.getRightHandSide(); assert( eq(siC1rhs[0],2.5) ); assert( eq(siC1rhs[1],2.1) ); assert( eq(siC1rhs[2],4.0) ); assert( eq(siC1rhs[3],5.0) ); assert( eq(siC1rhs[4],15.) ); const double * siC1rr = siC1.getRowRange(); assert( eq(siC1rr[0],0.0) ); assert( eq(siC1rr[1],0.0) ); assert( eq(siC1rr[2],0.0) ); assert( eq(siC1rr[3],5.0-1.8) ); assert( eq(siC1rr[4],15.0-3.0) ); const CoinPackedMatrix * siC1mbr = siC1.getMatrixByRow(); assert( siC1mbr != NULL ); const double * ev = siC1mbr->getElements(); assert( eq(ev[0], 3.0) ); assert( eq(ev[1], 1.0) ); assert( eq(ev[2], -2.0) ); assert( eq(ev[3], -1.0) ); assert( eq(ev[4], -1.0) ); assert( eq(ev[5], 2.0) ); assert( eq(ev[6], 1.1) ); assert( eq(ev[7], 1.0) ); assert( eq(ev[8], 1.0) ); assert( eq(ev[9], 2.8) ); assert( eq(ev[10], -1.2) ); assert( eq(ev[11], 5.6) ); assert( eq(ev[12], 1.0) ); assert( eq(ev[13], 1.9) ); const CoinBigIndex * mi = siC1mbr->getVectorStarts(); assert( mi[0]==0 ); assert( mi[1]==5 ); assert( mi[2]==7 ); assert( mi[3]==9 ); assert( mi[4]==11 ); assert( mi[5]==14 ); const int * ei = siC1mbr->getIndices(); assert( ei[0] == 0 ); assert( ei[1] == 1 ); assert( ei[2] == 3 ); assert( ei[3] == 4 ); assert( ei[4] == 7 ); assert( ei[5] == 1 ); assert( ei[6] == 2 ); assert( ei[7] == 2 ); assert( ei[8] == 5 ); assert( ei[9] == 3 ); assert( ei[10] == 6 ); assert( ei[11] == 0 ); assert( ei[12] == 4 ); assert( ei[13] == 7 ); assert( siC1mbr->getMajorDim() == 5 ); assert( siC1mbr->getNumElements() == 14 ); assert( siC1rs == siC1.getRowSense() ); assert( siC1rhs == siC1.getRightHandSide() ); assert( siC1rr == siC1.getRowRange() ); } } } }

---

Member Data Documentation

bool CoinMpsIO::defaultHandler_ [protected]

Flag to say if the message handler is the default handler. If true, the handler will be destroyed when the CoinMpsIO object is destroyed; if false, it will not be destroyed. Definition at line 746 of file CoinMpsIO.hpp. Referenced by CoinMpsIO(), gutsOfCopy(), gutsOfDestructor(), operator=(), and passInMessageHandler().

char* CoinMpsIO::integerType_ [protected]

Pointer to dense vector specifying if a variable is continuous (0) or integer (1). Definition at line 711 of file CoinMpsIO.hpp. Referenced by copyInIntegerInformation(), freeAll(), gutsOfCopy(), integerColumns(), isContinuous(), isInteger(), readMps(), releaseIntegerInformation(), and setMpsDataWithoutRowAndColNames().

char** CoinMpsIO::names_[2] [protected]

Row and column names Linked to hash table sections (0 - row names, 1 column names) Definition at line 716 of file CoinMpsIO.hpp. Referenced by findHash(), gutsOfCopy(), startHash(), and writeMps().

double* CoinMpsIO::rowrange_ [mutable, protected]

Pointer to dense vector of slack variable upper bounds for range constraints (undefined for non-range rows) Definition at line 681 of file CoinMpsIO.hpp. Referenced by getRowRange(), and releaseRedundantInformation().

---

The documentation for this class was generated from the following files:

• CoinMpsIO.hpp
• CoinMpsIO.cpp

---