diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CoinLpIO.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/CoinLpIO.hpp | 805 |
1 files changed, 805 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CoinLpIO.hpp b/thirdparty/linux/include/coin/CoinLpIO.hpp new file mode 100644 index 0000000..43c0e20 --- /dev/null +++ b/thirdparty/linux/include/coin/CoinLpIO.hpp @@ -0,0 +1,805 @@ +/* $Id: CoinLpIO.hpp 1749 2014-10-24 20:00:14Z tkr $ */ +// Last edit: 11/5/08 +// +// Name: CoinLpIO.hpp; Support for Lp files +// Author: Francois Margot +// Tepper School of Business +// Carnegie Mellon University, Pittsburgh, PA 15213 +// email: fmargot@andrew.cmu.edu +// Date: 12/28/03 +//----------------------------------------------------------------------------- +// Copyright (C) 2003, Francois Margot, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinLpIO_H +#define CoinLpIO_H + +#include <cstdio> + +#include "CoinPackedMatrix.hpp" +#include "CoinMessage.hpp" +class CoinSet; + +const int MAX_OBJECTIVES = 2; + +typedef int COINColumnIndex; + + /** Class to read and write Lp files + + Lp file format: + +/ this is a comment <BR> +\ this too <BR> + Min<BR> + obj: x0 + x1 + 3 x2 - 4.5 xyr + 1 <BR> + s.t. <BR> + cons1: x0 - x2 - 2.3 x4 <= 4.2 / this is another comment <BR> + c2: x1 + x2 >= 1 <BR> + cc: x1 + x2 + xyr = 2 <BR> + Bounds <BR> + 0 <= x1 <= 3 <BR> + 1 >= x2 <BR> + x3 = 1 <BR> + -2 <= x4 <= Inf <BR> + xyr free <BR> + Integers <BR> + x0 <BR> + Generals <BR> + x1 xyr <BR> + Binaries <BR> + x2 <BR> + End + +Notes: <UL> + <LI> Keywords are: Min, Max, Minimize, Maximize, s.t., Subject To, + Bounds, Integers, Generals, Binaries, End, Free, Inf. + <LI> Keywords are not case sensitive and may be in plural or singular form. + They should not be used as objective, row or column names. + <LI> Bounds, Integers, Generals, Binaries sections are optional. + <LI> Generals and Integers are synonymous. + <LI> Bounds section (if any) must come before Integers, Generals, and + Binaries sections. + <LI> Row names must be followed by ':' without blank space. + Row names are optional. If row names are present, + they must be distinct (if the k-th constraint has no given name, its name + is set automatically to "consk" for k=0,...,). + For valid row names, see the method is_invalid_name(). + <LI> Column names must be followed by a blank space. They must be distinct. + For valid column names, see the method is_invalid_name(). + <LI> Multiple objectives may be specified, but when there are multiple + objectives, they must have names (to indicate where each one starts). + <LI> The objective function names must be followed by ':' without blank space. + If there is a single objective, the objective function name is optional. + If no name is given, the name is set to "obj" by default. + For valid objective function names, see the method is_invalid_name(). + <LI> Ranged constraints are written as two constraints. + If a name is given for a ranged constraint, the upper bound constraint + has that name and the lower bound constraint has that name with "_low" + as suffix. This should be kept in mind when assigning names to ranged + constraint, as the resulting name must be distinct from all the other + names and be considered valid by the method is_invalid_name(). + <LI> At most one term related to any single variable may appear in the + objective function; if more than one term are present, only the last + one is taken into account. + At most one constant term may appear in the objective function; + if present, it must appear last. + <LI> Default bounds are 0 for lower bound and +infinity for upper bound. + <LI> Free variables get default lower bound -infinity and + default upper bound +infinity. Writing "x0 Free" in an + LP file means "set lower bound on x0 to -infinity". + <LI> If more than one upper (resp. lower) bound on a variable appears in + the Bounds section, the last one is the one taken into + account. The bounds for a binary variable are set to 0/1 only if this + bound is stronger than the bound obtained from the Bounds section. + <LI> Numbers larger than DBL_MAX (or larger than 1e+400) in the input file + might crash the code. + <LI> A comment must start with '\' or '/'. That symbol must either be + the first character of a line or be preceded by a blank space. The + comment ends at the end of the + line. Comments are skipped while reading an Lp file and they may be + inserted anywhere. +</UL> +*/ +class CoinLpIO { + friend void CoinLpIOUnitTest(const std::string & lpDir); +public: + + /**@name Constructor and Destructor */ + //@{ + /// Default Constructor + CoinLpIO(); + + /// Does the heavy lifting for destruct and assignment. + void gutsOfDestructor(); + + /// Does the heavy lifting for copy and assignment + void gutsOfCopy(const CoinLpIO &); + + /// assignment operator + CoinLpIO & operator = (const CoinLpIO& rhs) ; + + /// Copy constructor + CoinLpIO (const CoinLpIO &); + + /// Destructor + ~CoinLpIO(); + + /** Free the vector previous_names_[section] and set + card_previous_names_[section] to 0. + section = 0 for row names, + section = 1 for column names. + */ + void freePreviousNames(const int section); + + /// Free all memory (except memory related to hash tables and objName_). + void freeAll(); + //@} + + /** A quick inlined function to convert from lb/ub style constraint + definition to sense/rhs/range style */ + inline void + convertBoundToSense(const double lower, const double upper, + char& sense, double& right, double& range) const; + + /**@name Queries */ + //@{ + + /// Get the problem name + const char * getProblemName() const; + + /// Set problem name + void setProblemName(const char *name); + + /// Get number of columns + int getNumCols() const; + + /// Get number of rows + int getNumRows() const; + + /// Get number of nonzero elements + int getNumElements() const; + + /// Get pointer to array[getNumCols()] of column lower bounds + const double * getColLower() const; + + /// Get pointer to array[getNumCols()] of column upper bounds + const double * getColUpper() const; + + /// Get pointer to array[getNumRows()] of row lower bounds + const double * getRowLower() const; + + /// Get pointer to array[getNumRows()] of row upper bounds + const double * getRowUpper() const; + /** Get pointer to array[getNumRows()] of constraint senses. + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + const char * getRowSense() 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 + <ul> + <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] + <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 + </ul> + */ + const double * getRightHandSide() 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 + <ul> + <li> if rowsense()[i] == 'R' then + rowrange()[i] == rowupper()[i] - rowlower()[i] + <li> if rowsense()[i] != 'R' then + rowrange()[i] is 0.0 + </ul> + Put another way, only ranged constraints have a nontrivial value for + rowrange. + */ + const double * getRowRange() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const int getNumObjectives() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const double * getObjCoefficients() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients for objective j + const double * getObjCoefficients(int j) const; + + /// Get pointer to row-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByCol() const; + + /// Get objective function name + const char * getObjName() const; + + /// Get objective function name for objective j + const char * getObjName(int j) const; + + /// Get pointer to array[*card_prev] of previous row names. + /// The value of *card_prev might be different than getNumRows()+1 if + /// non distinct + /// row names were present or if no previous names were saved or if + /// the object was holding a different problem before. + void getPreviousRowNames(char const * const * prev, + int *card_prev) const; + + /// Get pointer to array[*card_prev] of previous column names. + /// The value of *card_prev might be different than getNumCols() if non + /// distinct column names were present of if no previous names were saved, + /// or if the object was holding a different problem before. + void getPreviousColNames(char const * const * prev, + int *card_prev) const; + + /// Get pointer to array[getNumRows()+1] of row names, including + /// objective function name as last entry. + char const * const * getRowNames() const; + + /// Get pointer to array[getNumCols()] of column names + char const * const *getColNames() const; + + /// Return the row name for the specified index. + /// Return the objective function name if index = getNumRows(). + /// Return 0 if the index is out of range or if row names are not defined. + const char * rowName(int index) const; + + /// Return the column name for the specified index. + /// Return 0 if the index is out of range or if column names are not + /// defined. + const char * columnName(int index) const; + + /// Return the index for the specified row name. + /// Return getNumRows() for the objective function name. + /// Return -1 if the name is not found. + int rowIndex(const char * name) const; + + /// Return the index for the specified column name. + /// Return -1 if the name is not found. + int columnIndex(const char * name) const; + + ///Returns the (constant) objective offset + double objectiveOffset() const; + + ///Returns the (constant) objective offset for objective j + double objectiveOffset(int j) const; + + /// Set objective offset + inline void setObjectiveOffset(double value) + { objectiveOffset_[0] = value;} + + /// Set objective offset + inline void setObjectiveOffset(double value, int j) + { objectiveOffset_[j] = value;} + + /// Return true if a column is an integer (binary or general + /// integer) variable + bool isInteger(int columnNumber) const; + + /// Get characteristic vector of integer variables + const char * integerColumns() const; + //@} + + /**@name Parameters */ + //@{ + /// Get infinity + double getInfinity() const; + + /// Set infinity. Any number larger is considered infinity. + /// Default: DBL_MAX + void setInfinity(const double); + + /// Get epsilon + double getEpsilon() const; + + /// Set epsilon. + /// Default: 1e-5. + void setEpsilon(const double); + + /// Get numberAcross, the number of monomials to be printed per line + int getNumberAcross() const; + + /// Set numberAcross. + /// Default: 10. + void setNumberAcross(const int); + + /// Get decimals, the number of digits to write after the decimal point + int getDecimals() const; + + /// Set decimals. + /// Default: 5 + void setDecimals(const int); + //@} + + /**@name Public methods */ + //@{ + /** Set the data of the object. + Set it from the coefficient matrix m, the lower bounds + collb, the upper bounds colub, objective function obj_coeff, + integrality vector integrality, lower/upper bounds on the constraints. + The sense of optimization of the objective function is assumed to be + a minimization. + Numbers larger than DBL_MAX (or larger than 1e+400) + might crash the code. There are two version. The second one is for + setting multiple objectives. + */ + void setLpDataWithoutRowAndColNames( + const CoinPackedMatrix& m, + const double* collb, const double* colub, + const double* obj_coeff, + const char* integrality, + const double* rowlb, const double* rowub); + + void setLpDataWithoutRowAndColNames( + const CoinPackedMatrix& m, + const double* collb, const double* colub, + const double* obj_coeff[MAX_OBJECTIVES], + int num_objectives, + const char* integrality, + const double* rowlb, const double* rowub); + + /** Return 0 if buff is a valid name for a row, a column or objective + function, return a positive number otherwise. + If parameter ranged = true, the name is intended for a ranged + constraint. <BR> + Return 1 if the name has more than 100 characters (96 characters + for a ranged constraint name, as "_low" will be added to the name).<BR> + Return 2 if the name starts with a number.<BR> + Return 3 if the name is not built with + the letters a to z, A to Z, the numbers 0 to 9 or the characters + " ! # $ % & ( ) . ; ? @ _ ' ` { } ~ <BR> + Return 4 if the name is a keyword.<BR> + Return 5 if the name is empty or NULL. */ + int is_invalid_name(const char *buff, const bool ranged) const; + + /** Return 0 if each of the card_vnames entries of vnames is a valid name, + return a positive number otherwise. The return value, if not 0, is the + return value of is_invalid_name() for the last invalid name + in vnames. If check_ranged = true, the names are row names and + names for ranged constaints must be checked for additional restrictions + since "_low" will be added to the name if an Lp file is written. + When check_ranged = true, card_vnames must have getNumRows()+1 entries, + with entry vnames[getNumRows()] being the + name of the objective function. + For a description of valid names and return values, see the method + is_invalid_name(). + + This method must not be called with check_ranged = true before + setLpDataWithoutRowAndColNames() has been called, since access + to the indices of all the ranged constraints is required. + */ + int are_invalid_names(char const * const *vnames, + const int card_vnames, + const bool check_ranged) const; + + /// Set objective function name to the default "obj" and row + /// names to the default "cons0", "cons1", ... + void setDefaultRowNames(); + + /// Set column names to the default "x0", "x1", ... + void setDefaultColNames(); + + /** Set the row and column names. + The array rownames must either be NULL or have exactly getNumRows()+1 + distinct entries, + each of them being a valid name (see is_invalid_name()) and the + last entry being the intended name for the objective function. + If rownames is NULL, existing row names and objective function + name are not changed. + If rownames is deemed invalid, default row names and objective function + name are used (see setDefaultRowNames()). The memory location of + array rownames (or its entries) should not be related + to the memory location of the array (or entries) obtained from + getRowNames() or getPreviousRowNames(), as the call to + setLpDataRowAndColNames() modifies the corresponding arrays. + Unpredictable results + are obtained if this requirement is ignored. + + Similar remarks apply to the array colnames, which must either be + NULL or have exactly getNumCols() entries. + */ + void setLpDataRowAndColNames(char const * const * const rownames, + char const * const * const colnames); + + /** Write the data in Lp format in the file with name filename. + Coefficients with value less than epsilon away from an integer value + are written as integers. + Write at most numberAcross monomials on a line. + Write non integer numbers with decimals digits after the decimal point. + Write objective function name and row names if useRowNames = true. + + Ranged constraints are written as two constraints. + If row names are used, the upper bound constraint has the + name of the original ranged constraint and the + lower bound constraint has for name the original name with + "_low" as suffix. If doing so creates two identical row names, + default row names are used (see setDefaultRowNames()). + */ + int writeLp(const char *filename, + const double epsilon, + const int numberAcross, + const int decimals, + const bool useRowNames = true); + + /** Write the data in Lp format in the file pointed to by the paramater fp. + Coefficients with value less than epsilon away from an integer value + are written as integers. + Write at most numberAcross monomials on a line. + Write non integer numbers with decimals digits after the decimal point. + Write objective function name and row names if useRowNames = true. + + Ranged constraints are written as two constraints. + If row names are used, the upper bound constraint has the + name of the original ranged constraint and the + lower bound constraint has for name the original name with + "_low" as suffix. If doing so creates two identical row names, + default row names are used (see setDefaultRowNames()). + */ + int writeLp(FILE *fp, + const double epsilon, + const int numberAcross, + const int decimals, + const bool useRowNames = true); + + /// Write the data in Lp format in the file with name filename. + /// Write objective function name and row names if useRowNames = true. + int writeLp(const char *filename, const bool useRowNames = true); + + /// Write the data in Lp format in the file pointed to by the parameter fp. + /// Write objective function name and row names if useRowNames = true. + int writeLp(FILE *fp, const bool useRowNames = true); + + /// Read the data in Lp format from the file with name filename, using + /// the given value for epsilon. If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(const char *filename, const double epsilon); + + /// Read the data in Lp format from the file with name filename. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(const char *filename); + + /// Read the data in Lp format from the file stream, using + /// the given value for epsilon. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(FILE *fp, const double epsilon); + + /// Read the data in Lp format from the file stream. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(FILE *fp); + + /// Dump the data. Low level method for debugging. + void print() const; + + /// Load in SOS stuff + void loadSOS(int numberSets,const CoinSet * sets); + + /// Load in SOS stuff + void loadSOS(int numberSets,const CoinSet ** sets); + + /// Number of SOS sets + inline int numberSets() const + { return numberSets_;} + + /// Set information + inline CoinSet ** setInformation() const + { return set_;} + //@} +/**@name Message handling */ +//@{ + /** Pass in Message handler + + Supply a custom message handler. It will not be destroyed when the + CoinMpsIO object is destroyed. + */ + void passInMessageHandler(CoinMessageHandler * handler); + + /// Set the language for messages. + void newLanguage(CoinMessages::Language language); + + /// Set the language for messages. + inline void setLanguage(CoinMessages::Language language) {newLanguage(language);} + + /// Return the message handler + inline CoinMessageHandler * messageHandler() const {return handler_;} + + /// Return the messages + inline CoinMessages messages() {return messages_;} + /// Return the messages pointer + inline CoinMessages * messagesPointer() {return & messages_;} +//@} + +protected: + /// Problem name + char * problemName_; + + /// Message handler + CoinMessageHandler * handler_; + /** 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. + */ + bool defaultHandler_; + /// Messages + CoinMessages messages_; + + /// Number of rows + int numberRows_; + + /// Number of columns + int numberColumns_; + + /// Number of elements + int numberElements_; + + /// Pointer to column-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByColumn_; + + /// Pointer to row-wise copy of problem matrix coefficients. + CoinPackedMatrix *matrixByRow_; + + /// Pointer to dense vector of row lower bounds + double * rowlower_; + + /// Pointer to dense vector of row upper bounds + double * rowupper_; + + /// Pointer to dense vector of column lower bounds + double * collower_; + + /// Pointer to dense vector of column upper bounds + double * colupper_; + + /// Pointer to dense vector of row rhs + mutable double * rhs_; + + /** Pointer to dense vector of slack variable upper bounds for ranged + constraints (undefined for non-ranged constraints) + */ + mutable double *rowrange_; + + /// Pointer to dense vector of row senses + mutable char * rowsense_; + + /// Pointer to dense vector of objective coefficients + double * objective_[MAX_OBJECTIVES]; + + /// Number of objectives + int num_objectives_; + + /// Constant offset for objective value + double objectiveOffset_[MAX_OBJECTIVES]; + + /// Pointer to dense vector specifying if a variable is continuous + /// (0) or integer (1). + char * integerType_; + + /// Pointer to sets + CoinSet ** set_; + + /// Number of sets + int numberSets_; + + /// Current file name + char * fileName_; + + /// Value to use for infinity + double infinity_; + + /// Value to use for epsilon + double epsilon_; + + /// Number of monomials printed in a row + int numberAcross_; + + /// Number of decimals printed for coefficients + int decimals_; + + /// Objective function name + char *objName_[MAX_OBJECTIVES]; + + /** Row names (including objective function name) + and column names when stopHash() for the corresponding + section was last called or for initial names (deemed invalid) + read from a file.<BR> + section = 0 for row names, + section = 1 for column names. */ + char **previous_names_[2]; + + /// card_previous_names_[section] holds the number of entries in the vector + /// previous_names_[section]. + /// section = 0 for row names, + /// section = 1 for column names. + int card_previous_names_[2]; + + /// Row names (including objective function name) + /// and column names (linked to Hash tables). + /// section = 0 for row names, + /// section = 1 for column names. + char **names_[2]; + + typedef struct { + int index, next; + } CoinHashLink; + + /// Maximum number of entries in a hash table section. + /// section = 0 for row names, + /// section = 1 for column names. + int maxHash_[2]; + + /// Number of entries in a hash table section. + /// section = 0 for row names, + /// section = 1 for column names. + int numberHash_[2]; + + /// Hash tables with two sections. + /// section = 0 for row names (including objective function name), + /// section = 1 for column names. + mutable CoinHashLink *hash_[2]; + + /// Build the hash table for the given names. The parameter number is + /// the cardinality of parameter names. Remove duplicate names. + /// + /// section = 0 for row names, + /// section = 1 for column names. + void startHash(char const * const * const names, + const COINColumnIndex number, + int section); + + /// Delete hash storage. If section = 0, it also frees objName_. + /// section = 0 for row names, + /// section = 1 for column names. + void stopHash(int section); + + /// Return the index of the given name, return -1 if the name is not found. + /// Return getNumRows() for the objective function name. + /// section = 0 for row names (including objective function name), + /// section = 1 for column names. + COINColumnIndex findHash(const char *name, int section) const; + + /// Insert thisName in the hash table if not present yet; does nothing + /// if the name is already in. + /// section = 0 for row names, + /// section = 1 for column names. + void insertHash(const char *thisName, int section); + + /// Write a coefficient. + /// print_1 = 0 : do not print the value 1. + void out_coeff(FILE *fp, double v, int print_1) const; + + /// Locate the objective function. + /// Return 1 if found the keyword "Minimize" or one of its variants, + /// -1 if found keyword "Maximize" or one of its variants. + int find_obj(FILE *fp) const; + + /// Return an integer indicating if the keyword "subject to" or one + /// of its variants has been read. + /// Return 1 if buff is the keyword "s.t" or one of its variants. + /// Return 2 if buff is the keyword "subject" or one of its variants. + /// Return 0 otherwise. + int is_subject_to(const char *buff) const; + + /// Return 1 if the first character of buff is a number. + /// Return 0 otherwise. + int first_is_number(const char *buff) const; + + /// Return 1 if the first character of buff is '/' or '\'. + /// Return 0 otherwise. + int is_comment(const char *buff) const; + + /// Read the file fp until buff contains an end of line + void skip_comment(char *buff, FILE *fp) const; + + /// Put in buff the next string that is not part of a comment + void scan_next(char *buff, FILE *fp) const; + + /// Return 1 if buff is the keyword "free" or one of its variants. + /// Return 0 otherwise. + int is_free(const char *buff) const; + + /// Return 1 if buff is the keyword "inf" or one of its variants. + /// Return 0 otherwise. + int is_inf(const char *buff) const; + + /// Return an integer indicating the inequality sense read. + /// Return 0 if buff is '<='. + /// Return 1 if buff is '='. + /// Return 2 if buff is '>='. + /// Return -1 otherwise. + int is_sense(const char *buff) const; + + /// Return an integer indicating if one of the keywords "Bounds", "Integers", + /// "Generals", "Binaries", "Semi-continuous", "Sos", "End", or one + /// of their variants has been read. (note Semi-continuous not coded) + /// Return 1 if buff is the keyword "Bounds" or one of its variants. + /// Return 2 if buff is the keyword "Integers" or "Generals" or one of their + /// variants. + /// Return 3 if buff is the keyword "Binaries" or one of its variants. + /// Return 4 if buff is the keyword "Semi-continuous" or one of its variants. + /// Return 5 if buff is the keyword "Sos" or one of its variants. + /// Return 6 if buff is the keyword "End" or one of its variants. + /// Return 0 otherwise. + int is_keyword(const char *buff) const; + + /// Read a monomial of the objective function. + /// Return 1 if "subject to" or one of its variants has been read. + int read_monom_obj(FILE *fp, double *coeff, char **name, int *cnt, + char **obj_name, int *num_objectives, int *obj_starts); + + /// Read a monomial of a constraint. + /// Return a positive number if the sense of the inequality has been + /// read (see method is_sense() for the return code). + /// Return -1 otherwise. + int read_monom_row(FILE *fp, char *start_str, double *coeff, char **name, + int cnt_coeff) const; + + /// Reallocate vectors related to number of coefficients. + void realloc_coeff(double **coeff, char ***colNames, int *maxcoeff) const; + + /// Reallocate vectors related to rows. + void realloc_row(char ***rowNames, int **start, double **rhs, + double **rowlow, double **rowup, int *maxrow) const; + + /// Reallocate vectors related to columns. + void realloc_col(double **collow, double **colup, char **is_int, + int *maxcol) const; + + /// Read a constraint. + void read_row(FILE *fp, char *buff, double **pcoeff, char ***pcolNames, + int *cnt_coeff, int *maxcoeff, + double *rhs, double *rowlow, double *rowup, + int *cnt_row, double inf) const; + + /** Check that current objective name and all row names are distinct + including row names obtained by adding "_low" for ranged constraints. + If there is a conflict in the names, they are replaced by default + row names (see setDefaultRowNames()). + + This method must not be called before + setLpDataWithoutRowAndColNames() has been called, since access + to the indices of all the ranged constraints is required. + + This method must not be called before + setLpDataRowAndColNames() has been called, since access + to all the row names is required. + */ + void checkRowNames(); + + /** Check that current column names are distinct. + If not, they are replaced by default + column names (see setDefaultColNames()). + + This method must not be called before + setLpDataRowAndColNames() has been called, since access + to all the column names is required. + */ + void checkColNames(); + +}; + +void +CoinLpIOUnitTest(const std::string& lpDir); + + +#endif |